/*
 * Copyright (c) 2011-2018, Emulex
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. 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.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * 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.
 *
 */

/**
 * @file
 * Defines the elxsdkutil command handlers.
 */

 /**
 *
 * @defgroup cmd_handler Command Handlers
 *
 */

#include <stdio.h>
#include <getopt.h>
#include <string.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <ctype.h>
#include <fcntl.h>

#include "version.h"
#include "elxu_commands.h"
#include "elxu_common.h"
#include "elxu_dwnld.h"
#include "elxu_device.h"
#include "elxu_dump.h"
#include "elxu_mgmt.h"
#include "elx_pt_ioctl.h"

#include <ocs_ioctl.h>

#define PORTSPEED_1GFC              0x00000001      /* 1G FC */
#define PORTSPEED_2GFC              0x00000002      /* 2G FC */
#define PORTSPEED_4GFC              0x00000008      /* 4G FC */
#define PORTSPEED_8GFC              0x00000010      /* 8G FC */
#define PORTSPEED_16GFC             0x00000020      /* 16G FC */
#define PORTSPEED_32GFC             0x00000040      /* 32G FC */
#define PORTSPEED_64GFC             0x00000400      /* 64G FC*/
#define PORTSPEED_128GFC            0x00000200      /* 128G FC */
#define PORTSPEED_UNKNOWN           0x00008000      /* Unknown*/
char *supported_linkcfgs[] = {
	OCS_CONFIG_LINKCFG_4X10G,
	OCS_CONFIG_LINKCFG_1X40G,
	OCS_CONFIG_LINKCFG_2X16G,
	OCS_CONFIG_LINKCFG_4X8G,
	OCS_CONFIG_LINKCFG_4X1G,
	OCS_CONFIG_LINKCFG_2X10G,
	OCS_CONFIG_LINKCFG_2X10G_2X8G};

#define ETH_FC_AUTO "0"
#define ETH_FC_10G "1000"
#define FC_2G "2000"
#define FC_4G "4000"
#define FC_8G "8000"
#define FC_16G "16000"
#define FC_32G "32000"

char *supported_linkspeed[] = {
	ETH_FC_AUTO,
	ETH_FC_10G,
	FC_2G,
	FC_4G,
	FC_8G,
	FC_16G,
	FC_32G};

#define AUTO "0"
#define N_PORT "1"
#define LOOP "2"
char *supported_linktopology[] = {
	AUTO,
	N_PORT,
	LOOP
};

#define OCS_MAX_SLI_PORTS_PER_DEVICE		4

#define OCS_FC_TRUNK_2_PORT_CONFIG		0x30
#define OCS_FC_TRUNK_2_PORT_HI_CONFIG		0xC0
#define OCS_FC_TRUNK_4_PORT_CONFIG		0xF0

#define OCS_FC_TRUNK_CONFIG_MASK		0xF0
#define OCS_FC_TRUNK_LINK_STATE_MASK		0x0F

static void show_examples();

typedef struct elx_sfp_transceiver_data_A0_s {
	uint8_t identifier;
	uint8_t ext_identifier;
	uint8_t connector;
	uint8_t transceiver[8];
	uint8_t encoding;
	uint8_t br_nominal;
	uint8_t rate_id;
	uint8_t length_9um_km;
	uint8_t length_9um;
	uint8_t length_50um;
	uint8_t length_62_5_um;
	uint8_t len_copper;
	uint8_t length_om3;
	char    vendor_name[16];
	uint8_t transciever;
	uint8_t vendor_oui[3];
	char    vendor_pn[16];
	char    vendor_rev[4];
	uint8_t wavelength[2];
	uint8_t unallocated;
	uint8_t cc_base;
	uint8_t options[2];
	uint8_t br_max;
	uint8_t br_min;
	char    vendor_sn[16];
	uint8_t date_code[8];
	uint8_t diag_monitor_type;
	uint8_t enhance_opt;
	uint8_t SFF_8472_compliance;
	uint8_t cc_ext;
	uint8_t vendor_specific[32];
} elx_sfp_transceiver_data_A0_t;

typedef struct {
	char*	vendor;
	char*	vendor_pn;
	char*	vendor_rev; /* Note: This is minimum rev number */
	uint8_t	length_copper;
} elx_dport_sfp_table1_entry;


typedef struct {
	char*	vendor_pn;
} elx_dport_sfp_table2_entry;

/**
 * @ingroup cmd_handler
 * @brief Command handler for the file-info command.
 *
 * @par Description
 * This function processes the file-info command. <br><br>
 * Command:</b> file-info <br>
 * Required Parameters: <filename> <br>
 * Optional Parameters: None <br>
 * Supported Devices: N/A<br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line
 *             arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value
 *         on failure.
 */
int elxu_cmd_file_info(int argc, char **argv)
{
	cmd_options_t options;
	if (argc < 3) {
		fprintf(stderr, "Filename is required\n");
		return -1;
	}

	/* Parse arguments, to pick up a --host argument */
	if (parse_arguments(argc, argv, &options, 0, 1) == -1) {
		return -1;
	}

	if (options.file == NULL) {
		fprintf(stderr, "Filename missing\n");
		return -1;
	}

	printf("file: %s \n", options.file);
	file_handler(NULL, options.file, FW_FILE_DISPLAY_INFO);
	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the list command.
 *
 * @par Description
 * This function processes the list command.
 *
 * Command: list <br>
 * Required Parameters: None <br>
 * Optional Parameters: None <br>
 * Supported Devices: N/A <br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line
 *             arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value
 *         on failure.
 */
int elxu_cmd_list(int argc, char **argv)
{
	cmd_options_t options;

	/* Parse arguments, to pick up a --host argument */
	if (parse_arguments(argc, argv, &options, 0, 1) == -1) {
		return -1;
	}

	elxu_display_device_list(options.hostname);
	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the read command.
 *
 * @par Description
 * This function processes the read command.
 *
 * Command: read<br>
 * Required Parameters: <objname> <br>
 * Optional Parameters: -d <device> -f <filename> <br>
 * Supported Devices: Lancer  <br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_read(int argc, char **argv)
{
	char *objname = NULL;
	cmd_options_t options;

	if (argc < 3) {
		fprintf(stderr, "objname is required\n");
		return -1;
	}

	objname = argv[2];

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if (objname == NULL) {
		printf ("Missing object name argument\n");
		return -1;
	}

	/* Read Obj only supported for Lancer */
	if(!is_lancer(options.device) && !is_prism(options.device)) {
		fprintf(stderr, "readobj is only supported on Lancer/Prism\n");
		return -1;
	}

	hba_data_object_upload (options.device, objname, options.file);

	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the write command.
 *
 * @par Description
 * This function processes the write command.
 *
 * Command: write <br>
 * Required Parameters: -f <filename> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Any  <br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_write(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (options.device == NULL) {
		fprintf(stderr, "Unable to open device\n");
		return -1;
	}

	if (options.file == NULL) {
		fprintf(stderr, "Filename missing\n");
		return -1;
	}

	return file_handler (options.device, options.file, FW_FILE_DOWNLOAD);
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the version command.
 *
 * @par Description
 * This function processes the version command.
 *
 * Command: version <br>
 * Required Parameters: None <br>
 * Optional Parameters: None <br>
 * Supported Devices: N/A  <br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_version(int argc, char **argv)
{
	printf ("\nVersion %s\n", ELXU_VERSION);
	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the cmp command.
 *
 * @par Description
 * This function processes the cmp command.
 *
 * Command: cmp <br>
 * Required Parameters: -f <filename> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_cmp(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (options.device == NULL) {
		fprintf(stderr, "Unable to open device\n");
		return -1;
	}

	if (options.file == NULL) {
		fprintf(stderr, "Filename missing\n");
		return -1;
	}

	return file_handler (options.device, options.file, FW_FILE_VERIFY);
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the dump command.
 *
 * @par Description
 * This function processes the dump command.
 *
 * Command: dump <br>
 * Required Parameters: None <br>
 * Optional Parameters: dump type (--fat, --efd, --ecd), -f <filename>, -d <device> <br>
 * Supported Devices: Any  <br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_dump(int argc, char **argv)
{
	cmd_options_t options;
	data_type_req_t dump_type;
	int rc;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (options.device == NULL) {
		fprintf(stderr, "Unable to open device\n");
		return -1;
	}

	if (is_lancer(options.device) || is_prism(options.device)) {
		/* No dump type option for Lancer */
		if ((options.fat) || (options.efd) || (options.ecd) || (options.ecd_test)) {
			fprintf(stderr, "Dump type option does not apply to Lancer/Prism\n");
			return -1;
		}
		dump_type = LANCER_DUMP;
	} else {
		/* Could be ecd, ecdtest, fat, or efd.  Default is ecd */
		dump_type = ECD_DATA;

		/* Verify that no more than one dump type is selected */
		if ((options.fat + options.efd + options.ecd + options.ecd_test) > 1) {
			fprintf(stderr, "Choose no more than one of --fat, --efd, --ecd, or --ecdtest\n");
			return -1;
		}
		if (options.efd) {
			dump_type = EFD_DATA;
		} else if (options.fat) {
			dump_type = FAT_DATA;
		}
	}

	switch(dump_type) {
	case FAT_DATA:
	case EFD_DATA:
	case LANCER_DUMP:
		rc =  hba_data_upload (options.device, options.file, dump_type);
		break;
	case ECD_DATA:
		/*
		 * Because of the way ioctls are implemented in the user space driver an ECD
		 * is very slow (several days to get a dump.)  For that reason ECD dump is
		 * not supported with the userspace driver.
		 */
		if (is_uspace(options.device)) {
			fprintf(stderr, "ECD dump not supported with user space driver.\n");
			return -1;
		}
		rc = elxu_core_dump(options.device, options.file, options.ecd_test);
		break;
	default:
		/* This shouldn't happen */
		fprintf(stderr, "No dump type selected\n");
		rc = -1;

	}

	return rc;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the efdc command.
 *
 * @par Description
 * This function processes the efdc command.
 *
 * Command: efdc <br>
 * Required Parameters: None <br>
 * Optional Parameters: -f <filename>, -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_efdc(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (options.device == NULL) {
		fprintf(stderr, "Unable to open device\n");
		return -1;
	}

	if (!is_skyhawk(options.device)) {
		fprintf(stderr, "efdc is only supported on Skyhwawk\n");
		return -1;
	}

	return ext_fat_capabilities_upld(options.device);
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the objenum command.
 *
 * @par Description
 * This function processes the objenum command.
 *
 * Command: objenum <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Lancer  <br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_objenum(int argc, char **argv)
{
	sli4_object_t *objlist;
	sli4_object_t *obj;
	int cnt = 0;
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (options.device == NULL) {
		fprintf(stderr, "Unable to open device\n");
		return -1;
	}

	if (!is_lancer(options.device) && !is_prism(options.device)) {
		fprintf(stderr, "objenum is only supported on Lancer/Prism\n");
		return -1;
	}

	objlist = sli4_object_enumerate(options.device);

	for (obj = objlist; obj; obj=obj->next, cnt++) {
		if (obj->type != OFT_DIRECTORY_OBJECT) {
			printf ("[%2d] %-20s  ......... %6d\n",
					cnt, obj->name, obj->length);
		} else {
			printf ("[%2d] %-20s \n", cnt, obj->name);
		}
	}
	sli4_object_free_list (objlist);
	return 0;
}
char * elxu_decode_sfp_id(uint32_t value)
{
       char *identify = "UNKNOWN";
       switch (value) {
       case 0x0:
               identify = "Unknown";
               break;   
       case 0x1:
               identify = "GBIC";
               break;   
       case 0x2:
               identify = "Module/connector soldered to motherboard ";
               break;   
       case 0x3:
               identify = "SFP"; 
               break;   
       case 0x4:
               identify = "300 pin XBI";
               break;   
       case 0x5:
               identify = "XENPAK";
               break;   
       case 0x6:
               identify = "XFP"; 
               break;   
       case 0xC:
               identify = "QSFP";
               break;   
       default: 
               identify = "Refer Spec";
       }

       return identify;
}
char * elxu_decode_sfp_connector(uint32_t value)
{
       char *identify = "UNKNOWN";

       switch (value) {
       case 0x0:
               identify = "Unknown";
               break;   
       case 0x1:
               identify = "SC";
               break;   
       case 0x2:
               identify = "Fibre Channel Style 1 copper connector";
               break;   
       case 0x3:
               identify = "Fibre Channel Style 2 copper connector";
               break;
       case 0x4:
               identify = "BNC/TNC";
               break;
       case 0x5:
               identify = "Fibre Channel coaxial headers";
               break;
       case 0x6:
               identify = "FiberJack";
               break;
       case 0x7:
               identify = "LC";
               break;
       default:
               identify = "Refer Spec";
       }

       return identify;
}

char * elxu_decode_sfp_rate_id(uint32_t value)
{
       char *identify;

       switch (value) {
       case 0x1:
               identify = "SFF-8079";
               break;
       case 0x2:
       case 0x4:
       case 0x6:
               identify = "SFF-8431";
               break;
       case 0x8:
       case 0xA:
               identify = "FC-PI-5";
               break;
       default:
               identify = "Unspecified";
       }
       return identify;
}

char * elxu_sfp_encoding_info(uint32_t value)
{
       char *identify;

       switch (value) {
       case 0x0:
               identify = "Unspecified";
               break;
       case 0x1:
               identify = "8B10B";
               break;
       case 0x2:
               identify = "4B5B";
               break;
       case 0x3:
               identify = "NRZ";
               break;
       case 0x4:
               identify = "Manchester";
               break;
       case 0x5:
               identify = "SONET Scrambled";
               break;
       case 0x6:
               identify = "64B/66B";
               break;
       default:
               identify = "Unspecified";
       }
       return identify;
}

int elxu_device_get_lancer_temp(elxu_device_t *device)
{
	int rc;
	uint32_t *resp_buff;

	resp_buff = malloc(OCS_DUMP_TYPE4_WKI_TAG_SAT_TEM_RESP_LEN);
	if (resp_buff == NULL) {
		perror("malloc");
		return -1;
	}

	memset(resp_buff, 0, OCS_DUMP_TYPE4_WKI_TAG_SAT_TEM_RESP_LEN);
	rc = elxu_device_exec(device, "/ocs/driver/lancer_temp", NULL, 0,
			      resp_buff, OCS_DUMP_TYPE4_WKI_TAG_SAT_TEM_RESP_LEN);
	if (rc != 0) {
		printf("Get board temperature failed\n");
		free(resp_buff);
		return -1;
	}

	/*
	 * Following is the format of resp buffer:
	 * Word 0 - curr_temp
	 * Word 1 - crit_temp_thrshld
	 * Word 2 - warn_temp_thrshld
	 * Word 3 - norm_temp_thrshld
	 * Word 4 - fan_off_thrshld
	 * Word 5 - fan_on_thrshld
	 */
	printf("Device %d temperature details - \n", device->deviceIndex);
	printf("\tCurrent temperature:           \t %d degrees\n\n", resp_buff[0]);
	printf("\tCritical temperature threshold:\t %d degrees\n", resp_buff[1]);
	printf("\tWarning temperature threshold: \t %d degrees\n", resp_buff[2]);

	free(resp_buff);
	return rc;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the board temperature.
 *
 * @par Description
 * This function processes the Dump Type 4 (Well Known Item) command for Lancer.
 * WKI selection ID 0x1040 (WKI_TAG_SAT_TEM) to read board temperature data.
 *
 * Command: boardtemp <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Lancer  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_board_temp(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	/* Board temperature supported for Lancer */
	if (!is_lancer(options.device)) {
		printf("boardtemp is only supproted on Lancer\n");
		return -1;
	}

	if (is_uspace(options.device)) {
		printf("boardtemp is not supported with the user space driver\n");
		return -1;
	}

	return elxu_device_get_lancer_temp(options.device);
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the sfp command.
 *
 * @par Description
 * This function processes the sfp command.
 * sfp data returned by the mgmt api is an ASCII string of hex values
 * but it isn't formatted nicely.  This function retrives the string,
 * converts it to binary, then uses dump8() to display it nicely
 * formatted.
 *
 * Command: sfp <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All  <br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_sfp(int argc, char **argv)
{
	uint8_t transceiver_buffer[TRANSCEIVER_INFO_PAGE_SIZE];
	elx_sfp_transceiver_data_A0_t a0_page_info;
	cmd_options_t options;
	char *value;
	char *s;
	uint8_t *d;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (options.device == NULL) {
		fprintf(stderr, "Unable to open device\n");
		return -1;
	}

	value = elxu_device_get_value(options.device, "/ocs/sfp_a0");
	if ((strcmp(value, "no-sfp") == 0)) {
		printf("Warning: No SFP module present on this device.\n");
	}
	if ((strlen(value) != 0) && (strcmp(value, "(unknown)") != 0) && (strcmp(value, "no-sfp") != 0)) {
		d = transceiver_buffer;
		s = value;
		while (isalnum(*s)) {
			*d = (uint8_t) strtoul(s, NULL, 16);
			++d;
			s += 3;
		}

		if (!options.sfp_diag_data && !options.sfp_xceiver_data) {
			dump8("Hex information from page 0xA0 ---\n", transceiver_buffer,
					TRANSCEIVER_INFO_PAGE_SIZE);
			printf("\n");
		}

               if (options.sfp_xceiver_data) {
                       int i = 0;

                       memcpy(&a0_page_info, transceiver_buffer, min(TRANSCEIVER_INFO_PAGE_SIZE, sizeof(a0_page_info)));

                       printf("\n\nSFP Transceiver data\n");
                       printf("==============================================================================\n");
                       printf("Identifier                      : 0x%x(%s)\n", a0_page_info.identifier, elxu_decode_sfp_id(a0_page_info.identifier));
                       printf("Ext Identifier:                 : 0x%x(%s)\n", a0_page_info.ext_identifier,
                               (a0_page_info.ext_identifier == 0x4) ? "non-custom SFP, SFP+ and GBIC module": "Unknown");
                       printf("Connector                       : 0x%x (%s)\n", a0_page_info.connector, elxu_decode_sfp_connector(a0_page_info.connector));
                       printf("Transceiver codes               : 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
                               a0_page_info.transceiver[0], a0_page_info.transceiver[1],a0_page_info.transceiver[2],a0_page_info.transceiver[3],
                               a0_page_info.transceiver[4],a0_page_info.transceiver[5],a0_page_info.transceiver[6],a0_page_info.transceiver[7]);

                       printf("FC Transceiver Speed            : ");
                       for (i = 0; i < 8; i++) {
                               if (a0_page_info.transceiver[7] & (1 << i)) {
                                       switch (i) {
                                       case 0:
                                               printf("100 MBytes/sec  ");
                                               break;
                                       case 1:
                                               printf("Unallocated  ");
                                               break;
                                       case 2:
                                               printf("200 MBytes/sec  ");
                                               break;
                                       case 3:
                                               printf("3200 MBytes/sec  ");
                                               break;
                                       case 4:
                                               printf("400 MBytes/sec  ");
                                               break;
                                       case 5:
                                               printf("1600 MBytes/sec  ");
                                               break;
                                       case 6:
                                               printf("800 MBytes/sec  ");
                                               break;
                                       case 7:
                                               printf("1200 MBytes/sec  ");
                                               break;
                                       default:
                                               printf("Unknown ");
                                       }

                               }
                       }

                       printf("\nEncoding                      : 0x%x (%s)\n", a0_page_info.encoding, elxu_sfp_encoding_info(a0_page_info.encoding));
                       printf("BR, Nominal                     : 0x%x\n", a0_page_info.br_nominal);
                       printf("Rate Id                         : 0x%x (%s)\n", a0_page_info.rate_id, elxu_decode_sfp_rate_id(a0_page_info.rate_id));
                       printf("Length(9um,km)                  : 0x%x\n", a0_page_info.length_9um_km);
                       printf("Length(9um)                     : 0x%x\n", a0_page_info.length_9um);
                       printf("Length(50um)                    : 0x%x\n", a0_page_info.length_50um);
                       printf("Length(62.5)                    : 0x%x\n", a0_page_info.length_62_5_um);
                       printf("Length(Copper)                  : 0x%x\n", a0_page_info.len_copper);
                       printf("Length(OM3)                     : 0x%x\n", a0_page_info.length_om3);
                       printf("Vendor name                     : ");
                       for (i=0; i<16; i++)
                               printf("%c", a0_page_info.vendor_name[i]);
                       printf("\nVendor OUI                    : %x:%x:%x", a0_page_info.vendor_oui[0],a0_page_info.vendor_oui[1],a0_page_info.vendor_oui[2]);
                       printf("\nVendor PN                     : ");
                       for (i = 0; i<16; i++)
                               printf("%c", a0_page_info.vendor_pn[i]);
                       printf("\nVendor Revision                       : ");
                       for (i = 0; i<4; i++)
                               printf("%c", a0_page_info.vendor_rev[i]);
                       printf("\nOption values                 : 0x%x 0x%x\n", a0_page_info.options[0], a0_page_info.options[1]);
                       printf("BR margin, max                  : %d%s\n", a0_page_info.br_max, " %");
                       printf("BR margin, min                  : %d%s\n", a0_page_info.br_min, " %");
                       printf("Vendor SN                       : ");
                       for (i = 0; i<16; i++)
                               printf("%c", a0_page_info.vendor_sn[i]);
                       printf("\nDate code                     : ");
                       for (i = 0; i<8; i++)
                               printf("%c", a0_page_info.date_code[i]);
                       printf("\nOptical diagnostics support   : %s", (a0_page_info.diag_monitor_type & 1 << 6) ? "Yes":"No");
                       printf("\n==============================================================================\n");
               }
	}

	value = elxu_device_get_value(options.device, "/ocs/sfp_a2");
	if ((strlen(value) != 0) && (strcmp(value, "(unknown)") != 0)) {
		d = transceiver_buffer;
		s = value;
		while (isalnum(*s)) {
			*d = (uint8_t) strtoul(s, NULL, 16);
			++d;
			s += 3;
		}

		if (!options.sfp_diag_data && !options.sfp_xceiver_data) {
			dump8("Hex information from page 0xA2 ---\n", transceiver_buffer,
			      TRANSCEIVER_INFO_PAGE_SIZE);
			printf("\n");
		} else {
			float temp_high,temp_low,vcc_high,vcc_low,tx_bias_high,tx_bias_low;
			float tx_power_high,tx_power_low,rx_power_high,rx_power_low;
			float temp_high_warn,temp_low_warn,vcc_high_warn,vcc_low_warn,tx_bias_high_warn,tx_bias_low_warn;
			float tx_power_high_warn,tx_power_low_warn,rx_power_high_warn,rx_power_low_warn;
			float temperature,vcc,tx_bias_current,tx_power,rx_power;

			temp_high = ((transceiver_buffer[0] << 8) | transceiver_buffer[1])/(float)256;
			temp_low = ((transceiver_buffer[2] << 8) | transceiver_buffer[3])/(float)256;
			temp_high_warn = ((transceiver_buffer[4] << 8) | transceiver_buffer[5])/(float)256;
			temp_low_warn = ((transceiver_buffer[6] << 8) | transceiver_buffer[7])/(float)256;

			vcc_high = ((transceiver_buffer[8] << 8) | transceiver_buffer[9]) * (float)100 / 1000000;
			vcc_low = ((transceiver_buffer[10] << 8) | transceiver_buffer[11]) * (float)100 / 1000000;
			vcc_high_warn = ((transceiver_buffer[12] << 8) | transceiver_buffer[13]) * (float)100 / 1000000;
			vcc_low_warn = ((transceiver_buffer[14] << 8) | transceiver_buffer[15]) * (float)100 / 1000000;

			tx_bias_high = ((transceiver_buffer[16] << 8) | transceiver_buffer[17]) * (float)2 / 1000;
			tx_bias_low = ((transceiver_buffer[18] << 8) | transceiver_buffer[19]) * (float)2 / 1000;
			tx_bias_high_warn = ((transceiver_buffer[20] << 8) | transceiver_buffer[21]) * (float)2 / 1000;
			tx_bias_low_warn = ((transceiver_buffer[22] << 8) | transceiver_buffer[23]) * (float)2 / 1000;
			
			tx_power_high = ((transceiver_buffer[24] << 8) | transceiver_buffer[25]) * (float)0.1 / 1000;
			tx_power_low = ((transceiver_buffer[26] << 8) | transceiver_buffer[27]) * (float)0.1 / 1000;
			tx_power_high_warn = ((transceiver_buffer[28] << 8) | transceiver_buffer[29]) * (float)0.1 / 1000;
			tx_power_low_warn = ((transceiver_buffer[30] << 8) | transceiver_buffer[31]) * (float)0.1 / 1000;

			rx_power_high = ((transceiver_buffer[32] << 8) | transceiver_buffer[33]) * (float)0.1 / 1000;
			rx_power_low = ((transceiver_buffer[34] << 8) | transceiver_buffer[35]) * (float)0.1 / 1000;
			rx_power_high_warn = ((transceiver_buffer[36] << 8) | transceiver_buffer[37]) * (float)0.1 / 1000;
			rx_power_low_warn = ((transceiver_buffer[38] << 8) | transceiver_buffer[39]) * (float)0.1 / 1000;

			printf("== Threshold data ==\n");
			printf("Temperature : -%f C(low) - %f C(high)\n", temp_low, temp_high);
			printf("Voltage : %f V(low) - %f V(high)\n", vcc_low, vcc_high);
			printf("TX Bias Current : %f mA(low) - %f mA(high)\n", tx_bias_low, tx_bias_high);
			printf("TX Power : %f mW(low) - %f mW(high)\n", tx_power_low, tx_power_high);
			printf("RX Power : %f mW(low) - %f mW(high)\n\n", rx_power_low, rx_power_high);

			printf("== Threshold warnings data ==\n");
			printf("Temperature : %f (low) - %f (high)\n", temp_low_warn, temp_high_warn);
			printf("Voltage : %f V(low) - %f V(high)\n", vcc_low_warn, vcc_high_warn);
			printf("TX Bias Current : %f mA(low) - %f mA(high)\n", tx_bias_low_warn, tx_bias_high_warn);
			printf("TX Power : %f mW(low) - %f mW(high)\n", tx_power_low_warn, tx_power_high_warn);
			printf("RX Power : %f mW(low) - %f mW(high)\n\n", rx_power_low_warn, rx_power_high_warn);

			temperature = ((transceiver_buffer[96] << 8) | transceiver_buffer[97])/(float)256;
			vcc = ((transceiver_buffer[98] << 8) | transceiver_buffer[99]) * (float)100 / 1000000;
			tx_bias_current = ((transceiver_buffer[100] << 8) | transceiver_buffer[101]) * (float)2 / 1000;
			tx_power = ((transceiver_buffer[102] << 8) | transceiver_buffer[103]) * (float)0.1 / 1000;
			rx_power = ((transceiver_buffer[104] << 8) | transceiver_buffer[105]) * (float)0.1 / 1000;
			printf("== Current SFP diagnostic data ==\n");
			printf("Temperature: %f C \nSupply Voltage: %f V\n", temperature, vcc);
			printf("TX Bias Current: %f mA\nTX Power: %f mW\nRX power: %f mW\n\n",
				tx_bias_current, tx_power, rx_power);	
		}
	}

	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the gendump command.
 *
 * @par Description
 * This function processes the gendump command.
 *
 * Command: gendump <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Lancer  <br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_gendump(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	/* Read Obj only supported for Lancer/Prism */
	if (!is_lancer(options.device) && !is_prism(options.device))
	{
		printf ("gendump is only supported on Lancer/Prism\n");
		return -1;
	}
	return lancer_gen_dump(options.device, options.fdb_dump);
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the fw-diag-log command.
 *
 * @par Description
 * This function processes the fw-diag-log command.
 *
 * Command: fw-diag-log <br>
 * Required Parameters: -d <device> -f <filename> <br>
 * Optional Parameters: None <br>
 * Supported Devices: Lancer G6 and Prism  <br>
 * Supported Protocols: FC <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_fw_diagnostic_log(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_fc(options.device)) {
		fprintf(stderr, "FW diagnostic logging is only supported for FC devices.\n");
		return -1;
	}

	elxu_get_fw_diagnostic_log(options.device, options.file);

        return 0;
}


/**
 * @ingroup cmd_handler
 * @brief Command handler for the dump command.
 *
 * @par Description
 * This function processes the dump command.
 *
 * Command: dump-to-host <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> -f <filename> <br>
 * Supported Devices: Lancer  <br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_dump_to_host(int argc, char **argv)
{
	cmd_options_t options;
	char *pci_dev;
	char *pci_func;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	/* Dump to host only supported for Lancer/Prism */
	if (!is_lancer(options.device) && !is_prism(options.device)) {
		printf ("dump-to-host is only supported on Lancer/Prism\n");
		return -1;
	}

	if (is_uspace(options.device)) {
		printf("dump-to-host is not supported with the user space driver\n");
		return -1;
	}

	pci_dev  = elxu_device_get_value(options.device, "/ocs/businfo");
	pci_func = strrchr(pci_dev, '.') + 1;
	if (!options.fdb_dump && strcmp(pci_func, "0") != 0) {
		printf("dump-to-host is only valid for PCI function 0, ");
		printf("device index %d corresponds to PCI function %s of device %s\n",
				options.device->deviceIndex, pci_func, pci_dev);
		return -1;
	}
	return lancer_dump_to_host(options.device, options.file, options.fdb_dump);
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the read-status command.
 *
 * @par Description
 * This function processes the read-status command.
 *
 * Command: read-status <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> --cc <br>
 * Supported Devices: Lancer  <br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_read_status(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (is_iscsi(options.device)) {
		printf ("iSCSI does not support this command\n");
		return -1;
	}

	return mbox_read_status(options.device, options.cc);
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the read-link-status command.
 *
 * @par Description
 * This function processes the read-link-status command.
 *
 * Command: read-link-status <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Lancer  <br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_read_link_status(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (is_iscsi(options.device)) {
		printf ("iSCSI does not support this command\n");
		return -1;
	}

	return mbox_read_link_status(options.device, options.clof, options.clrc);
}

int elxu_check_sfp_dport_support(elxu_device_t *device)
{
	uint8_t transceiver_buffer[TRANSCEIVER_INFO_PAGE_SIZE];
	elx_sfp_transceiver_data_A0_t *a0_page_info;
	char *value, *s;
	uint8_t *d;
	int i;
	
	/* Explicitily supported SFP table */
	elx_dport_sfp_table1_entry supported_table1[] =
	{
		{"HP-F",             "QW923A",               "",     0x0C }, // Finisar, HP branded
		{"HP-A",             "QW923A",               "",     0	  }, // Avago, HP branded
		{"HP-A",             "E7Y09A",               "",     0	  }, // Avago, HP branded 16G
		{"FINISAR CORP.",    "FTLF8529P3BCV-EM",     "B",    0	  }, // Finisar, Emulex branded
		{"EMULEX",           "AFBR-57F5MZ-ELX",      "",     0	  }, // Avago, Emulex branded
		{"FINISAR CORP.",    "FTLF8532P4BCV-EM",     "",     0	  }, // Finisar, Emulex Branded for 32G SFP
		{"AVAGO",            "AFBR-57G5MZ-ELX",      "",     0	  }, // Avago, Emulex Branded for 32G SFP
		{"HPE-F",            "P9H30A",               "",     0	  }, // Finisar, HP Branded for 32G SFP
		{"HPE-A",            "P9H30A",               "",     0	  }, // Avago(Broadcom)-FIT, HP Branded for 32G SFP
		{"HP-F",             "E7Y10A",               "",     0	  }, // Finisar, HP Branded for 16G SFP
		{"HP-A",             "E7Y10A",               "",     0	  }, // Avago(Broadcom)-FIT, HP Branded for 16G SFP
		{"AVAGO",            "AFCT-57F3TMZ-ELX",     "B",    0    }, // Avago(Broadcom)-FIT, (Downrev of Rev "B"), FIT 16G
	};
	#define DPORT_SFP_TABLE1_LEN (sizeof(supported_table1) / sizeof(elx_dport_sfp_table1_entry))

	/* Implicitily supported SFP table for emulex branded */
	elx_dport_sfp_table2_entry supported_table2[] =
	{
		{"FTLF8529"},    // Finisar, Emulex branded
		{"AFBR-57F"},    // Avago, Emulex branded
		{"AFCT-57F"},    // Avago, Emulex Branded 16G
		{"AFCT-57G"},    // Avago, Emulex Branded 32G
		{"FTLF1429"},    // Finisar, Emulex Branded 16
		{"FTLF1432"},    // Finisar, Emulex Branded 32G
	};
	#define DPORT_SFP_TABLE2_LEN (sizeof(supported_table2) / sizeof(elx_dport_sfp_table2_entry))

	value = elxu_device_get_value(device, "/ocs/sfp_a0");
	if ((strcmp(value, "no-sfp") == 0)) {
		printf("Warning: No SFP module present on this device.\n");
	}

	if ((strlen(value) != 0) && (strcmp(value, "(unknown)") != 0) && (strcmp(value, "no-sfp") != 0)) {
		d = transceiver_buffer;
		s = value;
		while (isalnum(*s)) {
			*d = (uint8_t) strtoul(s, NULL, 16);
			++d;
			s += 3;
		}

		a0_page_info = (elx_sfp_transceiver_data_A0_t *)transceiver_buffer;
		
		/* Validate against first table */
		for (i = 0; i < DPORT_SFP_TABLE1_LEN; i ++) {
			/* Validate vendor name */
			if (strncmp(a0_page_info->vendor_name, supported_table1[i].vendor,
				 strlen(supported_table1[i].vendor)) == 0) {
				
				/* Validate vendor part number */
				if (strncmp(a0_page_info->vendor_pn, supported_table1[i].vendor_pn,
					 strlen(supported_table1[i].vendor_pn)) == 0) {
					
					/* Validate revision number */
					if ((strncmp(a0_page_info->vendor_rev, supported_table1[i].vendor_rev,
						strlen(supported_table1[i].vendor_rev)) == 0) || 
						(a0_page_info->vendor_rev[0] > supported_table1[i].vendor_rev[0])) {
						return 0; /* Supported */
					}	

				}
			}
		}

		/* Validate against second table */
		for (i = 0; i < DPORT_SFP_TABLE2_LEN; i ++) {
			if (strncmp(a0_page_info->vendor_pn, supported_table2[i].vendor_pn,
                                         strlen(supported_table2[i].vendor_pn)) == 0) {
				if ((strncmp((char *)a0_page_info->vendor_specific, "Emulex Certified", strlen("Emulex Certified")) == 0) ||
					(strncmp((char *)a0_page_info->vendor_specific, "Emulex.Certified", strlen("Emulex.Certified")) == 0)) {
						return 0; /* Supported */
				}
			}
		}	
	}

	return -1;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the get-dport-stats command.
 *
 * @par Description
 * This function processes the get-dport-stats command.
 *
 * Command: get-dport-stats <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Lancer  <br>
 * Supported Protocols: FC<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_dport_stats(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (is_iscsi(options.device)) {
		printf ("iSCSI does not support this command\n");
		return -1;
	}

	if (elxu_check_sfp_dport_support(options.device) != 0) {
		printf ("SFP is not supported for Dport tests\n");
		return -1;
	}

	return mbox_get_dport_stats(options.device);
}

int elxu_cmd_set_dport_dynamic_mode(int argc, char **argv)
{
	cmd_options_t options;
	char *value;

	if (argc < 3) {
		fprintf(stderr, "Value (enable or disable) is required\n");
		return -1;
	}

	value = argv[2];

	if ((strcasecmp(value, "enable") != 0) &&
			(strcasecmp(value, "disable") != 0)) {
		fprintf(stderr, "Unexpected value '%s' - should be 'enable' or 'disable'\n", value);
		return -1;
	}

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if(is_iscsi(options.device)) {
		printf("iSCSI does not support this command\n");
		return -1;
	}

	return mbox_set_dynamic_dport(options.device, value);
}

int elxu_cmd_get_dynamic_dport_status(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (is_iscsi(options.device)) {
		printf ("iSCSI does not support this command\n");
		return -1;
	}

	return mbox_query_dynamic_dport_status(options.device);
}

int elxu_cmd_diag_loopback_tests(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}
	if (!is_lancer(options.device) && !is_prism(options.device)) {
		printf (" Command supports only to lancer/Prism\n");
		return -1;
	}
	return mbox_diag_loopback_tests(options.device, options.loopback_type, options.retry_count);
}
/**
 * @ingroup cmd_handler
 * @brief Command handler for the read-rev command.
 *
 * @par Description
 * This function processes the read-rev command.
 *
 * Command: read-rev <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Lancer, Skyhawk  <br>
 * Supported Protocols: N/A<br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_read_rev(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	return mbox_read_rev(options.device);
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the ack-frequency command.
 *
 * @par Description
 * This function processes the ack-frequency command.
 *
 * Command: ack-frequency <br>
 * Required Parameters: <frequency> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_ack_frequency(int argc, char **argv)
{
	uint32_t freq;
	cmd_options_t options;

	if (argc < 3) {
		fprintf(stderr, "ACK frequency is required\n");
		return -1;
	}

	freq = strtoul(argv[2], NULL, 0);

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

        if (!is_skyhawk(options.device)) {
                printf("Setting TCP parameters is only supported on Skyhawk\n");
                return -1;
        }

        return mbox_tcp_parameters(options.device,
        		ISCSI_UPDATE_ACK_FREQUENCY, freq, 0);
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the delayed-ack-timer command.
 *
 * @par Description
 * This function processes the delayed-ack-timer command.
 *
 * Command: delayed-ack-timer <br>
 * Required Parameters: <time> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_delayed_ack_timer(int argc, char **argv)
{
	uint32_t freq;
	cmd_options_t options;

	if (argc < 3) {
		fprintf(stderr, "Delayed ACK timer value is required\n");
		return -1;
	}

	freq = strtoul(argv[2], NULL, 0);

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

        if (!is_skyhawk(options.device)) {
                printf("Setting TCP parameters is only supported on Skyhawk\n");
                return -1;
        }

        return mbox_tcp_parameters(options.device,
        		ISCSI_UPDATE_DELAYED_ACK_TIMER, freq, 0);
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the constrain-window command.
 *
 * @par Description
 * This function processes the constrain-window command.
 *
 * Command: constrain-window <br>
 * Required Parameters: <window_size>, --connection-id <connection_id> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_constrain_window(int argc, char **argv)
{
	uint32_t window_size;
	cmd_options_t options;

	if (argc < 3) {
		fprintf(stderr, "Window size value is required\n");
		return -1;
	}

	window_size = strtoul(argv[2], NULL, 0);

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if (options.connection_id == NULL) {
		fprintf(stderr, "Connection ID is required\n");
		return -1;
	}

        if (!is_skyhawk(options.device)) {
                printf("Setting TCP parameters is only supported on Skyhawk\n");
                return -1;
        }

        return mbox_connection_update(options.device, ISCSI_UPDATE_TCP_WINDOW,
        		strtoul(options.connection_id, NULL, 0), window_size);
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the driver-dump command.
 *
 * @par Description
 * This function processes the driver-dump command.
 *
 * Command: driver-dump <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Any  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_driver_dump(int argc, char **argv)
{
	cmd_options_t options;
	ocs_ioctl_ddump_arg_t args;

	/* by default, get normal ddump */
	memset(&args, 0, sizeof(args));
	args.action = OCS_IOCTL_DDUMP_GET;
	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (options.saved) {
		args.action = OCS_IOCTL_DDUMP_GET_SAVED;
	} else if (options.clr_saved) {
		args.action = OCS_IOCTL_DDUMP_CLR_SAVED;
	}

	if (options.wqes) {
		args.flags |= OCS_IOCTL_DDUMP_FLAGS_WQES;
	}
	if (options.cqes) {
		args.flags |= OCS_IOCTL_DDUMP_FLAGS_CQES;
	}
	if (options.rqes) {
		args.flags |= OCS_IOCTL_DDUMP_FLAGS_RQES;
	}
	if (options.mqes) {
		args.flags |= OCS_IOCTL_DDUMP_FLAGS_MQES;
	}
	if (options.eqes) {
		args.flags |= OCS_IOCTL_DDUMP_FLAGS_EQES;
	}

	/* by default, dump entire queues */
	if (options.qentries == 0) {
		args.q_entries = -1;
	} else {
		args.q_entries = options.qentries;
	}

	if (args.flags == 0) {
		/* by default, dump WQs, CQs, MQ */
		args.flags = (OCS_IOCTL_DDUMP_FLAGS_WQES |
			      OCS_IOCTL_DDUMP_FLAGS_CQES |
			      OCS_IOCTL_DDUMP_FLAGS_MQES);
	}
	elxu_driver_dump(options.device, options.bufsize, &args);

	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the mgmt-info command.
 *
 * @par Description
 * This function processes the mgmt-info command.
 *
 * Command: mgmt-info <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Any  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_mgmt_info(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	elxu_mgmt_info(options.device);

	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the connection-info command.
 *
 * @par Description
 * This function processes the connection-info command.
 *
 * Command: connection-info <br>
 * Required Parameters: None <br>
 * Optional Parameters: --connection-handle <handle>, -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_connection_info(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "connection-info is only supported on iSCSI devices.\n");
		return -1;
	}

	// If we were given a connection ID then we want to use the mbox
	// command to get connection info from the chip.  Without a connection
	// ID we will show a list of connection information from the driver
	if (options.connection_handle != NULL) {
		mbox_get_connection_info(options.device,
				strtoul(options.connection_handle, NULL, 0));
	} else {
		elxu_get_connection_info(options.device);
	}

        return 0;
}

int elxu_cmd_iclusttgt_check_args(int argc, char **argv)
{
	if (argc < 3)
		return -1;

	if (argc == 3 &&
	    (strncmp(argv[2], "show", 4) && strncmp(argv[2], "clear", 5)))
		return -1;

	if (argc == 5 &&
	    (strncmp(argv[2], "add", 3) && strncmp(argv[2], "del", 3)))
		return -1;

	return 0;
}

int elxu_cmd_iclusttgt_show(elxu_device_t *device)
{
	int rval;
	int num_clust_tgts = 0;
	int inx = OCS_CLUST_TARGET_KEY_RETCNT;
	int len;
	char out_buf[512];
	char tgtportal[256];
	char in_buf[32];
	char *slash;
	int num_chars;

	/* Get max max number of cluster targets saved in the list.
	 * Use inx = key, to read the num of cluster targets.
	 */
	len = snprintf(in_buf, sizeof(in_buf), "%d", inx);
	rval = elxu_device_exec(device, "/ocs/iclusttgt_get",
				in_buf, len, NULL, 0);
	if (rval < 0)
		return rval;

	if (rval == 0) {
		printf("iclusttgt list is empty\n");
		return rval;
	}

	num_clust_tgts = rval;

	printf("iclusttgt Show targets %d\n", num_clust_tgts);

	/* Now get and display all the saved targets in cluster */
	printf("INDEX\tTARGET NAME AND ADDRESS\n");
	inx = 0;
	while (inx < num_clust_tgts) {
		memset(out_buf, 0, sizeof(out_buf));
		len = snprintf(in_buf, sizeof(in_buf), "%d", inx);
		rval = elxu_device_exec(device, "/ocs/iclusttgt_get",
					in_buf, len, out_buf, sizeof(out_buf));
		if (rval)
			break;

		slash = strchr(out_buf, '/');
		if (!slash)
			return -1;

		printf("%5d\t", inx+1);

		num_chars = slash - (char *)out_buf;
		memcpy(tgtportal, out_buf, num_chars);
		tgtportal[num_chars] = '\0';
		printf("%s  ", tgtportal);

		num_chars = strlen(out_buf) - (num_chars + 1);
		memcpy(tgtportal, slash + 1, num_chars);
		tgtportal[num_chars] = '\0';
		printf("%s\n", tgtportal);

		inx++;
	}

	return rval;
}

int elxu_cmd_iclusttgt(int argc, char **argv)
{
	int rval = 0;
	char cmd[32];
	cmd_options_t options;
	char ip[32];
	char *portal_portnum;
	char *portal_grptag;
	/* Max of iSCSI target name plus max of target portal-address */
	char parms[512];
	int parmlen;
	int i;
	
	if ((rval = parse_arguments(argc, argv, &options, 1, argc-1))) {
		fprintf(stderr, "Parse arguments failed on %s\n",
			argv[1]);
		return rval;
	}

	if (!is_iscsi(options.device)) {
		printf("iclusttgt is only supported in iSCSI\n");
		return -1;
	}

	/* Device arg in the form of -d <devnum> */
	if (strcmp(argv[1], "-d") == 0) {
		for (i = 1; i < argc-1; i++)
			memcpy((argv+i), (argv+i)+1, sizeof(argv[i+1]));

		argc -= 1;
		argv[argc] = NULL;

		for (i = 1; i < argc-1; i++)
			memcpy((argv+i), (argv+i)+1, sizeof(argv[i+1]));
			
		argc -= 1;
		argv[argc] = NULL;
	} else if (argv[1][0] == '-') {
		/* Device arg in the form of -d<devnum> */
		for (i = 1; i < argc-1; i++)
			memcpy((argv+i), (argv+i)+1, sizeof(argv[i+1]));
		argc -= 1;
		argv[argc] = NULL;
	}

	if ((rval = elxu_cmd_iclusttgt_check_args(argc, argv))) {
		fprintf(stderr, "Invalid number of arguments. "
			"Run %s help %s\n", argv[0], argv[1]);
		return rval;
	}

	
	memset(parms, 0, sizeof(parms));
	if (argc == 5) {
		portal_portnum = strchr(argv[4], ':');
		portal_grptag = strchr(argv[4], ',');

		if (!portal_portnum && portal_grptag) {
			fprintf(stderr, "Invalid number of arguments. "
				"Run %s help %s\n", argv[0], argv[1]);
			return -1;
		}

		strcpy(ip, argv[4]);
		if (portal_portnum && !portal_grptag)
			snprintf(ip, sizeof(ip), "%s,%d", argv[4],
				 OCS_ISCSI_PORTAL_GRPTAG);

		if (!portal_portnum)
			snprintf(ip, sizeof(ip), "%s:%d,%d", argv[4],
				 OCS_ISCSI_TCP_PORT, OCS_ISCSI_PORTAL_GRPTAG);

		parmlen = snprintf(parms, sizeof(parms), "%s/%s",
				   argv[3], ip);
	}

	if (0 == strncmp(argv[2], "show", 4))
		rval = elxu_cmd_iclusttgt_show(options.device);
	else {
		snprintf(cmd, sizeof(cmd), "/ocs/iclusttgt_%s", argv[2]);
		rval = elxu_device_exec(options.device, cmd,
					parms, parmlen, NULL, 0);
	}

	if (rval)
		perror("ioctl-iclusttgt");

	printf("Command %s %s is %s on device %d\n",
	       argv[1], argv[2], (rval ? "failed" : "success"),
	       options.device->deviceIndex);

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the route command.
 *
 * @par Description
 * This function processes the route command.
 *
 * Command: route <br>
 * Required Parameters: <add|del|show>
 * Parameters: <add|del> <netmask> <gateway>, -d <device> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_route(int argc, char **argv)
{
	cmd_options_t options;
	ocs_route_table_t *route_table;
	char cmd_params[256];
	char cmd[32];
	int param_len;
	int rval = -1;
	int inx;
	char *ip_addr;
	char *netmask;
	char *gateway;
	char *action;

	if (argc < 3) {
		fprintf(stderr, "Insufficient parameters\n");
		return rval;
	}

	action = argv[2];
	if ((0 == strcmp(action, "--add")) || (0 == strcmp(action, "--del"))) {
		if (argc < 6) {
			fprintf(stderr, "Insufficient parameters\n");
			return rval;
		}

		ip_addr = argv[3];
		netmask = argv[4];
		gateway = argv[5];
	}

	if (parse_arguments(argc-2, argv+2, &options, 1, 5) == -1) {
		fprintf(stderr, "parse arguments failed\n");
		return rval;
	}

	if (!is_iscsi(options.device)) {
		printf("Route table add/del is only supported in iSCSI\n");
		return rval;
	}


	if ((0 == strcmp(action, "--add")) || (0 == strcmp(action, "--del"))) {
		param_len = snprintf(cmd_params, sizeof(cmd_params), "%s/%s/%s",
				     ip_addr, netmask, gateway);
		snprintf(cmd, sizeof(cmd), "/ocs/route_%s", action+2);
		rval = elxu_device_exec(options.device, cmd,
					&cmd_params, param_len, NULL, 0);
		if (rval == 0) {
			printf("Route %s for IP-%s/%s gateway %s is successful\n",
			       action, ip_addr, netmask, gateway);
		} else {
			printf("Route %s for IP-%s/%s gateway %s is failed\n",
			       action, ip_addr, netmask, gateway);
		}
	} else if (0 == strcmp(action, "--show")) {
		route_table = malloc(sizeof(*route_table));
		if (route_table == NULL) {
			fprintf(stderr, "malloc failed\n");
			return -1;
		}

		snprintf(cmd, sizeof(cmd), "/ocs/route_%s", action+2);
		rval = elxu_device_exec(options.device, cmd,
					NULL, 0, route_table, sizeof(*route_table));
		if (rval) {
			printf("Route %s failed\n", action);
			free(route_table);
			return rval;
		}

		printf("Route table entries %d\n", route_table->entry_count);
		if (route_table->entry_count) {
			printf("%-16s %-16s %-16s\n", "IP", "Subnet", "Gateway");
			for (inx = 0; inx < route_table->entry_count; inx++) {
				printf("%-16s %-16s %-16s\n",
				       route_table->entry[inx].ip_addr,
				       route_table->entry[inx].subnet,
				       route_table->entry[inx].gateway);
			}
		}

		free(route_table);
	} else {
		fprintf(stderr, "Invalid command %s for route\n", action);
		rval = -1;
	}

	return rval;
} 

/**
 * @ingroup cmd_handler
 * @brief Command handler for the vlan command.
 *
 * @par Description
 * This function processes the vlan command.
 *
 * Command: vlan <br>
 * Required Parameters: <add|del|show>
 * Parameters: <add|del> <vlan-id>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_vlan(int argc, char **argv)
{
	cmd_options_t options;
	char cmd[32];
	unsigned int vlan_id;
	char *action;
	char *show_buff = NULL;
	int rval = -1;

	if (argc < 3) {
		fprintf(stderr, "Insufficient parameters\n");
		return rval;
	}

	action = argv[2];
	if ((0 == strcmp(action, "--add")) || (0 == strcmp(action, "--del"))) {
		if (argc < 4) {
			fprintf(stderr, "Insufficient parameters\n");
			return rval;
		}

		vlan_id = atoi(argv[3]);
		if (!(vlan_id >= 2 && vlan_id <= 4096)) {
			fprintf(stderr, "Invalid VLAN id %d\n", vlan_id);
			return rval;
		}
	} else if ((0 == strcmp(action, "--show"))) {
		show_buff = malloc(ELXU_CMD_VLAN_SHOW_BUFFER_SIZE);
		if (!show_buff) {
			fprintf(stderr, "malloc failed\n");
			return rval;
		}
	} else {
		fprintf(stderr, "Invalid parameters\n");
		return rval;
	}

	if (parse_arguments(argc-2, argv+2, &options, 1, 3) == -1) {
		fprintf(stderr, "parse failed\n");
		goto exit_free;
	}

	if(!is_iscsi(options.device)) {
		printf("VLAN config is only supported in iSCSI\n");
		goto exit_free;
	}

	snprintf(cmd, sizeof(cmd), "/ocs/vlan_%s", action+2);
	rval = elxu_device_exec(options.device, cmd,
				&vlan_id, sizeof(vlan_id),
				show_buff,
				(show_buff ? ELXU_CMD_VLAN_SHOW_BUFFER_SIZE : 0));
	if (rval) {
		fprintf(stderr, "iSCSI vlan %s is failed on device %d\n",
		        action, options.device->deviceIndex);
		goto exit_free;
	}

	printf("iSCSI vlan %s is successful on device %d\n",
	       action, options.device->deviceIndex);

exit_free:
	if ((0 == strcmp(action, "--show"))) {
		printf("%s ", show_buff);
		free(show_buff);
	}
	return rval;
}

#define ELXU_IP_GET_ADDRESS_LIST_SIZE (4096 * 2)
int elxu_check_ip_address_exists(cmd_options_t *options, char *ipaddr, int *ip_found)
{ 
	char *ipv4_addrs = NULL;
	char *ipv6_addrs = NULL;
	uint32_t version;
	int rval = 0;

	ipv4_addrs = malloc(ELXU_IP_GET_ADDRESS_LIST_SIZE);
	if (!ipv4_addrs) {
		fprintf(stderr, "IPv4 malloc failed\n");
		return -1;
	}

	// Get current IPs
	version = 4;
	rval = elxu_device_exec(options->device, "/ocs/ip_get", &version,
				sizeof(version), ipv4_addrs, ELXU_IP_GET_ADDRESS_LIST_SIZE);
	if (rval) {
		printf("Failed to read existing IPv4 addresses\n");
		goto exit;
	}

	ipv6_addrs = malloc(ELXU_IP_GET_ADDRESS_LIST_SIZE);
	if (!ipv6_addrs) {
		fprintf(stderr, "IPv6 malloc failed\n");
		goto exit;
	}

	version = 6;
	rval = elxu_device_exec(options->device, "/ocs/ip_get", &version,
				sizeof(version), ipv6_addrs, ELXU_IP_GET_ADDRESS_LIST_SIZE);
	if (rval) {
		printf("Failed to read existing IPv6 addresses\n");
		goto exit;
	}

	if ((strstr(ipv4_addrs, ipaddr) != NULL) ||
	    (strstr(ipv6_addrs, ipaddr) != NULL)) {
		*ip_found = 1;
	}

exit:
	if (ipv4_addrs)
		free(ipv4_addrs);
	if (ipv6_addrs)
		free(ipv6_addrs);

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the add-ip command.
 *
 * @par Description
 * This function processes the add-ip command.
 *
 * Command: add-ip <br>
 * Required Parameters: <ip address> <netmask> <br>
 * Optional Parameters: -d <device> [--vlan-id <vlan_id>] <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_add_ip(int argc, char **argv)
{
	cmd_options_t options;
	char *ipaddr_p;
	char *netmask_p;
	char cmd_parms[128];
	int ip_found = 0;
	int parm_len;
	int rval;

	if (argc < 4) {
		fprintf(stderr, "IP address and netmask is required\n");
		return -1;
	}

	ipaddr_p = argv[2];
	netmask_p = argv[3];
	if (parse_arguments(argc, argv, &options, 1, 3) == -1) {
		return -1;
	}

	if(!is_iscsi(options.device)) {
		printf("Add IP address is only supported in iSCSI\n");
		return -1;
	}

	rval = elxu_check_ip_address_exists(&options, ipaddr_p, &ip_found);
	if (rval) {
		printf("Check IP addresses failed\n");
		return rval;
	}

	if (!ip_found) {
		parm_len = snprintf(cmd_parms, sizeof(cmd_parms), "%s/%s/%d",
				    ipaddr_p, netmask_p, options.vlan_id);
		rval = elxu_device_exec(options.device, "/ocs/ip_add", cmd_parms,
					parm_len, NULL, 0);
		if (rval == 0) {
			printf("IP address %s added to device %d\n",
			       ipaddr_p, options.device->deviceIndex);
		} else {
			printf("Failed to add IP address %s from device %d\n",
			       ipaddr_p, options.device->deviceIndex);
		}
	} else {
		printf("IP address %s is already exists\n", ipaddr_p);
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the remove-ip command.
 *
 * @par Description
 * This function processes the remove-ip command.
 *
 * Command: remove-ip <br>
 * Required Parameters: <ip_address> <br>
 * Optional Parameters: -d <device> [--vlan-id <vlan_id>] <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_remove_ip(int argc, char **argv)
{
	cmd_options_t options;
	char *ipaddr_p;
	int rval;
	int32_t ip_found = 0;
	char cmd_parms[128];
	int parm_len;

	if (argc < 3) {
		fprintf(stderr, "IP address is required\n");
		return -1;
	}

	ipaddr_p  = argv[2];
	if (parse_arguments(argc, argv, &options, 1, 3) == -1) {
		return -1;
	}

	if(!is_iscsi(options.device)) {
		printf("Add IP address is only supported in iSCSI\n");
		return -1;
	}

	rval = elxu_check_ip_address_exists(&options, ipaddr_p, &ip_found);
	if (rval) {
		printf("Check IP addresses failed\n");
		return rval;
	}

	if (ip_found) {
		parm_len = snprintf(cmd_parms, sizeof(cmd_parms), "%s/%d",
				    ipaddr_p, options.vlan_id);
		rval = elxu_device_exec(options.device, "/ocs/ip_remove",
					cmd_parms, parm_len, NULL, 0);
		if (rval == 0) {
			printf("IP address %s removed from device %d\n",
			       ipaddr_p, options.device->deviceIndex);
		} else {
			printf("Failed to remove IP address %s from device %d\n",
			       ipaddr_p, options.device->deviceIndex);
		}
	} else {
		printf("IP address %s is not found\n", ipaddr_p);
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the show-ips command.
 *
 * @par Description
 * This function processes the show-ips command.
 *
 * Command: show-ips <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_show_ips(int argc, char **argv)
{
	cmd_options_t options;
	char *buf;
	uint32_t version;
	int rval;

	if (argc < 3) {
		fprintf(stderr, "IP address version required\n");
		return -1;
	}

	version = strtoul(argv[2], NULL, 10);
	if (version != 4 && version != 6) {
		fprintf(stderr, "Invalid IP version (must be 4 or 6)\n");
		return -1;
	}

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "Show IPs command is only supported on iSCSI\n");
		return -1;
	}

	buf = malloc(ELXU_IP_GET_ADDRESS_LIST_SIZE);
	if (!buf) {
		fprintf(stderr, "malloc failed\n");
		return -1;
	}

	rval = elxu_device_exec(options.device, "/ocs/ip_get", &version,
				sizeof(version), buf, ELXU_IP_GET_ADDRESS_LIST_SIZE);
	if (rval != 0) {
		perror("ioctl");
	} else {
		printf("IP addresses on device %d:\n%s\n",
		       options.device->deviceIndex, buf);
	}

	free(buf);
	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the set-gateway command.
 *
 * @par Description
 * This function processes the set-gateway command.
 *
 * Command: set-gateway <br>
 * Required Parameters: <ip_address> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_set_gateway(int argc, char **argv)
{
	cmd_options_t options;
	char *ipaddr_p;
	int rval;

	if (argc < 3) {
		fprintf(stderr, "IP address is required\n");
		return -1;
	}

	ipaddr_p  = argv[2];

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if(!is_iscsi(options.device)) {
		printf("Set gateway address is only supported in iSCSI\n");
		return -1;
	}

	rval = mgmt_set_value(options.device, "/ocs/gateway", ipaddr_p);
	if (rval == 0) {
		printf("Gateway address set to %s for device %d\n", ipaddr_p, options.device->deviceIndex);
	} else {
		printf("Failed to set gateway on from device %d, rval is %d\n",  options.device->deviceIndex, rval);
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the get-gateway command.
 *
 * @par Description
 * This function processes the get-gateway command.
 *
 * Command: get-gateway <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_gateway(int argc, char **argv)
{
	cmd_options_t options;
	char *result;
	int rval;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if(!is_iscsi(options.device)) {
		printf("Gateway address is only supported in iSCSI\n");
		return -1;
	}

	result = elxu_device_get_value(options.device, "/ocs/gateway");
	if (strlen(result) != 0) {
		printf("Gateway address is %s\n", result);
		rval = 0;
	} else {
		printf("Failed to get gateway from from device %d\n",  options.device->deviceIndex);
		rval = -1;
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the add-chap command
 *
 * @par Description
 * This function processes the add-chap command
 *
 * Command:  add-chap<br>
 * Required Parameters: <name>:<secret> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_add_chap(int argc, char **argv)
{
	cmd_options_t options;
	int rval;
	char *separator;
	int username_len;
	int secret_len;
	ocs_chap_user_buffer_t *chap_user_buff;
	char *name_and_secret;

	if (argc < 3) {
		fprintf(stderr, "Name and secret are required\n");
		return -1;
	}

	name_and_secret = argv[2];
	separator = strchr(argv[2], ':');
	if (separator == NULL) {
		fprintf(stderr, "Name and secret must be in the format name:secret\n");
		return -1;
	}
	username_len = separator - (char *)argv[2];
	secret_len = strlen(argv[2]) - username_len - 1;

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if(!is_iscsi(options.device)) {
		printf("Add CHAP is only supported in iSCSI\n");
		return -1;
	}

	chap_user_buff = malloc(sizeof(ocs_chap_user_buffer_t));
	if (chap_user_buff == NULL) {
		fprintf(stderr, "malloc failed\n");
		return -1;
	}

	strncpy(chap_user_buff->username, name_and_secret, username_len);
	chap_user_buff->username[username_len] = '\0';

	++separator;
	strncpy(chap_user_buff->secret, separator, secret_len);
	chap_user_buff->secret[secret_len] = '\0';

	chap_user_buff->type = options.chap_type;
	chap_user_buff->mode = OCS_CHAP_MODE_TARGET;

	rval = elxu_device_exec(options.device, "/ocs/add_chap_user", chap_user_buff,
				sizeof(*chap_user_buff), NULL, 0);
	if (rval == 0) {
		printf("CHAP user %s:%s added\n", chap_user_buff->username,
		       chap_user_buff->secret);
	} else {
		printf("Failed to add CHAP user %s:%s\n", chap_user_buff->username,
		       chap_user_buff->secret);
	}

	free(chap_user_buff);

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for remove-chap
 *
 * @par Description
 * This function processes the remove-chap command
 *
 * Command:  remove-chap<br>
 * Required Parameters: name <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_remove_chap(int argc, char **argv)
{
	cmd_options_t options;
	int rval;
	ocs_chap_user_buffer_t *chap_user_buff;
	char *username;

	if (argc < 3) {
		fprintf(stderr, "Name is required\n");
		return -1;
	}

	username = argv[2];
	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if(!is_iscsi(options.device)) {
		printf("Remove CHAP is only supported in iSCSI\n");
		return -1;
	}

	chap_user_buff = malloc(sizeof(ocs_chap_user_buffer_t));
	if (chap_user_buff == NULL) {
		fprintf(stderr, "malloc failed\n");
		return -1;
	}

	strcpy(chap_user_buff->username, username);
	/* secret is not required */
	chap_user_buff->secret[0] = '\0';
	chap_user_buff->type = options.chap_type;
	chap_user_buff->mode = OCS_CHAP_MODE_TARGET;

	rval = elxu_device_exec(options.device, "/ocs/remove_chap_user", chap_user_buff,
				sizeof(*chap_user_buff), NULL, 0);
	if (rval == 0) {
		printf("CHAP user %s removed\n", chap_user_buff->username);
	} else {
		printf("Failed to remove CHAP user %s\n", chap_user_buff->username);
	}

	free(chap_user_buff);

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for show-chap
 *
 * @par Description
 * This function retrieves the CHAP users list.
 * At first stage, read the number of entries of ocs_chap_user_buffer_t
 * items by passing arg_in && arg_out buffers as NULL.
 * At second stage, allocate required memory for chap users list.
 *
 * Command:  show-chap<br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_show_chap_list(int argc, char **argv)
{
	cmd_options_t options;
	int rval;
	int cnt;
	int ii;
	char *out_buf;
	int out_buf_size;
	ocs_chap_user_buffer_t *chap_user_buff;
	int offset;

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if(!is_iscsi(options.device)) {
		printf("Show CHAP is only supported in iSCSI\n");
		return -1;
	}

	/*
	 * To read count of CHAP users list, arg_in & arg_out must be NULL.
	 * The return is the count of ocs_chap_user_buffer_t items.
	 */
	rval = elxu_device_exec(options.device, "/ocs/show_chap_list",
				NULL, 0, NULL, 0);
	if (rval < 0)
		return rval;

	if (rval == 0) {
		printf("CHAP users list is empty\n");
		return rval;
	}

	cnt = rval;
	out_buf_size = cnt * sizeof(ocs_chap_user_buffer_t);
	out_buf = malloc(out_buf_size);
	if (out_buf == NULL) {
		fprintf(stderr, "malloc failed\n");
		return -1;
	}

	rval = elxu_device_exec(options.device, "/ocs/show_chap_list",
				NULL, 0, out_buf, out_buf_size);
	if (rval < 0) {
		printf("CHAP show users list failed\n");
		free(out_buf);
		return rval;
	}

	offset = 0;
	printf("%-16s %-16s %-12s\n", "User", "Secret", "Type");
	for (ii = 0; ii < cnt; ii++) {
		if (offset >= out_buf_size) {
			fprintf(stderr, "CHAP user buffer overflowed\n");
			break;
		}

		chap_user_buff = (ocs_chap_user_buffer_t *) (out_buf + offset);
		printf("%-16s %-16s %-12s\n", chap_user_buff->username, chap_user_buff->secret,
		       (chap_user_buff->type == OCS_CHAP_TYPE_INCOMING) ? OCS_CHAP_INCOMING :
			OCS_CHAP_OUTGOING);
		offset += sizeof(ocs_chap_user_buffer_t);
	}

	free(out_buf);
	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for set-require-chap
 *
 * @par Description
 * This function processes the set-require-chap command
 *
 * Command:  set-require-chap<br>
 * Required Parameters: true or false <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_set_require_chap(int argc, char **argv)
{
	cmd_options_t options;
	int rval;
	char *value;

	if (argc < 3) {
		fprintf(stderr, "Value (true or false) is required\n");
		return -1;
	}

	value = argv[2];

	if ((strcasecmp(value, "true") != 0) &&
	    (strcasecmp(value, "false") != 0)) {
		fprintf(stderr, "Unexpected value '%s' - should be 'true' or 'false'\n", value);
		return -1;
	}

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if(!is_iscsi(options.device)) {
		printf("CHAP is only supported in iSCSI\n");
		return -1;
	}

	rval = mgmt_set_value(options.device, "/ocs/require_chap", value);

	if (rval == 0) {
		printf("Require-chap set to %s\n", value);
	} else {
		printf("Failed to set require-chap, rval is %d\n", rval);
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for get-require-chap
 *
 * @par Description
 * This function processes the set-require-chap command
 *
 * Command:  get-require-chap<br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_require_chap(int argc, char **argv)
{
	cmd_options_t options;
	char *result;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if(!is_iscsi(options.device)) {
		printf("CHAP is only supported in iSCSI\n");
		return -1;
	}

	result = elxu_device_get_value(options.device, "/ocs/require_chap");

	if (strlen(result) != 0) {
		printf("Require-chap is %s\n", result);
	} else {
		printf("Failed to get require-chap flag\n");
	}

	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the enable-jumbo command
 *
 * @par Description
 * This function processes the enable-jumbo command
 *
 * Command:  enable-jumbo<br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_enable_jumbo(int argc, char **argv)
{
	cmd_options_t options;
	int rval;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "Jumbo frames are  only supported on iSCSI\n");
		return -1;
	}

	rval = mgmt_set_value(options.device, "/ocs/jumbo_frames", "true");

	if (rval) {
		fprintf(stderr, "Failed to enable jumbo frames, rval is %d\n", rval);
	} else {
		printf("Jumbo frames enabled\n");
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the disable-jumbo command.
 *
 * @par Description
 * This function processes the disable-jumbo command.
 *
 * Command:  disable-jumbo<br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_disable_jumbo(int argc, char **argv)
{
	cmd_options_t options;
	int rval;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "Jumbo frames are only supported on iSCSI\n");
		return -1;
	}

	rval = mgmt_set_value(options.device, "/ocs/jumbo_frames", "false");

	if (rval) {
		fprintf(stderr, "Failed to disable jumbo frames, rval is %d\n", rval);
	} else {
		printf("Jumbo frames disabled\n");
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for enable-header-digest
 *
 * @par Description
 * This function processes the enable-header-digets command.
 *
 * Command:  enable-header-digest<br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_enable_header_digest(int argc, char **argv)
{
	cmd_options_t options;
	int rval;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "Header digests are only supported on iSCSI\n");
		return -1;
	}

	rval = mgmt_set_value(options.device, "/ocs/header_digest", "true");

	if (rval) {
		fprintf(stderr, "Failed to enable header digests, rval is %d\n", rval);
	} else {
		printf("Header digests enabled\n");
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the disable-header-digest comand.
 *
 * @par Description
 * This function processes the disable-header-digest command.
 *
 * Command: disable-header-digest <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_disable_header_digest(int argc, char **argv)
{
	cmd_options_t options;
	int rval;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "Header digests are only supported on iSCSI\n");
		return -1;
	}

	rval = mgmt_set_value(options.device, "/ocs/header_digest", "false");

	if (rval) {
		fprintf(stderr, "Failed to disable header digests, rval is %d\n", rval);
	} else {
		printf("Header digests disabled\n");
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for enable-data-digest
 *
 * @par Description
 * This function processes the enable-data-digest command.
 *
 * Command:  enable-data-digest<br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_enable_data_digest(int argc, char **argv)
{
	cmd_options_t options;
	int rval;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "Data digests are only supported on iSCSI\n");
		return -1;
	}

	rval = mgmt_set_value(options.device, "/ocs/data_digest", "true");

	if (rval) {
		fprintf(stderr, "Failed to enable data digests, rval is %d\n", rval);
	} else {
		printf("Data digests enabled\n");
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the disable-data-digest command.
 *
 * @par Description
 * This function processes the disable-data-digest command.
 *
 * Command:  disable-data-digest<br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_disable_data_digest(int argc, char **argv)
{
	cmd_options_t options;
	int rval;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "Data digests are only supported on iSCSI\n");
		return -1;
	}

	rval = mgmt_set_value(options.device, "/ocs/data_digest", "false");

	if (rval) {
		fprintf(stderr, "Failed to disable data digests, rval is %d\n", rval);
	} else {
		printf("Data digests disabled\n");
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the set-tcp-window-size command.
 *
 * @par Description
 * This function processes the set-tcp-window-size command.
 *
 * Command:  set-tcp-window-size<br>
 * Required Parameters: window_size <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_set_tcp_window_size(int argc, char **argv)
{
	cmd_options_t options;
	uint32_t window_size;
	int rval;

	if (argc < 3) {
		fprintf(stderr, "Window size is required\n");
		return -1;
	}

	window_size = strtoul(argv[2], NULL, 10);
	if ((window_size < 1) || (window_size > 65535)) {
		fprintf(stderr, "Windows size %d invalid.  Valid range is 1 to 65535\n", window_size);
		return -1;
	}

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "Window size command is only supported on iSCSI\n");
		return -1;
	}

	rval = mgmt_set_value(options.device, "/ocs/tcp_window_size", argv[2]);

	if (rval) {
		fprintf(stderr, "Failed to set window size, rval is %d\n", rval);
	} else {
		printf("Window size set\n");
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for get-tcp-window-size
 *
 * @par Description
 * This function processes the get-tcp-window-size command.
 *
 * Command:  get-tcp-window-size<br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_tcp_window_size(int argc, char **argv)
{
	cmd_options_t options;
	int rval;
	char *result;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "Window size command is only supported on iSCSI\n");
		return -1;
	}

	result = elxu_device_get_value(options.device, "/ocs/tcp_window_size");

	if (strlen(result) == 0) {
		fprintf(stderr, "Failed to get window size\n");
		rval = -1;
	} else {
		printf("Current window size is %s\n", result);
		rval = 0;
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for set-tcp-window-scale
 *
 * @par Description
 * This function processes the set-tcp-window-scale command.
 *
 * Command:  set-tcp-window-scale<br>
 * Required Parameters: <window_scale> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_set_tcp_window_scale(int argc, char **argv)
{
	cmd_options_t options;
	uint32_t window_scale;
	int rval;

	if (argc < 3) {
		fprintf(stderr, "Window scale is required\n");
		return -1;
	}

	window_scale = strtoul(argv[2], NULL, 10);
	if (window_scale > 14) {
		fprintf(stderr, "Windows scale %d invalid.  Valid range is 0 to 14\n", window_scale);
		return -1;
	}

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "Window scale command is only supported on iSCSI\n");
		return -1;
	}

	rval = mgmt_set_value(options.device, "/ocs/tcp_window_scale", argv[2]);

	if (rval) {
		fprintf(stderr, "Failed to set window scale, rval is %d\n", rval);
	} else {
		printf("Window scale set\n");
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for get-tcp-window-scale
 *
 * @par Description
 * This function processes the get-tcp-window-scale command.
 *
 * Command:  get-tcp-window-scale<br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_tcp_window_scale(int argc, char **argv)
{
	cmd_options_t options;
	int rval;
	char *result;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "Window scale command is only supported on iSCSI\n");
		return -1;
	}

	result = elxu_device_get_value(options.device, "/ocs/tcp_window_scale");

	if (strlen(result) == 0) {
		fprintf(stderr, "Failed to get window scale\n");
		rval = -1;
	} else {
		printf("Current window scale is %s\n", result);
		rval = 0;
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for set-max-connections
 *
 * @par Description
 * This function processes the set-max-connections command.
 *
 * Command:  set-max-connections<br>
 * Required Parameters: <max_connections_per_session> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_set_max_connections(int argc, char **argv)
{
	cmd_options_t options;
	int rval;

	if (argc < 3) {
		fprintf(stderr, "Max connections is required\n");
		return -1;
	}

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "Max connections command is only supported on iSCSI\n");
		return -1;
	}

	rval = mgmt_set_value(options.device, "/ocs/max_cxns_per_session", argv[2]);

	if (rval) {
		fprintf(stderr, "Failed to set max connections per session, rval is %d\n", rval);
	} else {
		printf("Max connections per session set\n");
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for get-max-connections
 *
 * @par Description
 * This function processes the get-max-connections command.
 *
 * Command:  get-max-connections<br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_max_connections(int argc, char **argv)
{
	cmd_options_t options;
	int rval;
	char *result;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "Max connections command is only supported on iSCSI\n");
		return -1;
	}

	result = elxu_device_get_value(options.device, "/ocs/max_cxns_per_session");

	if (strlen(result) == 0) {
		fprintf(stderr, "Failed to get max connections per session\n");
		rval = -1;
	} else {
		printf("Current max connections per session is %s\n", result);
		rval = 0;
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for start-listen
 *
 * @par Description
 * This function processes the start-listen command.
 *
 * Command:  start-listen<br>
 * Required Parameters: <ip_address> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_start_listen(int argc, char **argv)
{
	cmd_options_t options;
	int rval;
	char *ip_addr;

	if (argc < 3) {
		fprintf(stderr, "IP address is required\n");
		return -1;
	}

	ip_addr = argv[2];

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if(!is_iscsi(options.device)) {
		printf("Start-listen is only supported in iSCSI\n");
		return -1;
	}

	rval = elxu_device_exec(options.device, "/ocs/listen_start", ip_addr, strlen(ip_addr), NULL, 0);

	if (rval == 0) {
		printf("Now listening on IP address %s\n", ip_addr);
	} else {
		printf("Failed to start listening on IP address %s\n", ip_addr);
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for stop-listen
 *
 * @par Description
 * This function processes the stop-listen command.
 *
 * Command:  stop-listen<br>
 * Required Parameters: <ip_address> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_stop_listen(int argc, char **argv)
{
	cmd_options_t options;
	int rval;
	char *ip_addr;

	if (argc < 3) {
		fprintf(stderr, "IP address is required\n");
		return -1;
	}

	ip_addr = argv[2];

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if(!is_iscsi(options.device)) {
		printf("Stop-listen is only supported in iSCSI\n");
		return -1;
	}

	rval = elxu_device_exec(options.device, "/ocs/listen_stop", ip_addr, strlen(ip_addr), NULL, 0);

	if (rval == 0) {
		printf("Stopped listening on IP address %s\n", ip_addr);
	} else {
		printf("Failed to stop listening on IP address %s\n", ip_addr);
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the set-mac command.
 *
 * @par Description
 * This function processes the set-mac command.
 *
 * Command: set-mac <br>
 * Required Parameters: <mac address> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */

/*
 * NOTE:  This function is not currently being use because of issues with
 * setting the MAC address through the OCS driver.
 */
int elxu_cmd_set_mac_ocs(int argc, char **argv)
{
	char *macaddr_p;
	cmd_options_t options;

	if (argc < 3) {
		fprintf(stderr, "MAC address value is required\n");
		return -1;
	}

	macaddr_p = argv[2];

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if(!is_iscsi(options.device)) {
		printf("Soft assigned MAC is only supported in iSCSI\n");
		return -1;
	}

	int macaddr[6];

	sscanf(macaddr_p, "%x:%x:%x:%x:%x:%x",
		&macaddr[0], &macaddr[1], &macaddr[2],
		&macaddr[3], &macaddr[4], &macaddr[5]);

	printf("    soft assigned MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
		macaddr[0], macaddr[1], macaddr[2],
		macaddr[3], macaddr[4], macaddr[5]);

	return mbox_soft_assign_mac(options.device, macaddr);
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the set-nv-mac command.
 *
 * @par Description
 * This function processes the set-nv-mac command.
 *
 * Command: set-nv-mac <br>
 * Required Parameters: <mac address> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_set_nv_mac_pt(int argc, char **argv)
{
	char *macaddr_p;
	cmd_options_t options;
	int rc;

	if (argc < 3) {
		fprintf(stderr, "MAC address value is required\n");
		return -1;
	}

	macaddr_p = argv[2];

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if(!is_iscsi(options.device) && !(is_nic(options.device))) {
		printf("MAC addresses apply only to iSCSI and NIC\n");
		return -1;
	}

	int macaddr[6];

	sscanf(macaddr_p, "%x:%x:%x:%x:%x:%x",
	       &macaddr[0], &macaddr[1], &macaddr[2],
	       &macaddr[3], &macaddr[4], &macaddr[5]);

	rc = mbox_set_nv_mac_pt(options.device, macaddr);

	if (rc == 0) {
		printf("    New MAC address: %02x:%02x:%02x:%02x:%02x:%02x\n",
		       macaddr[0], macaddr[1], macaddr[2],
		       macaddr[3], macaddr[4], macaddr[5]);
	} else {
		printf("    Failed to change MAC address\n");
	}

	return rc;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the show-mac command for the OCS drivers
 *
 * @par Description
 * This function processes the show-mac command
 *
 * Command: show-mac <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_show_mac_ocs(int argc, char **argv)
{
	cmd_options_t options;
	char *mac;
	int i;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device)) {
		fprintf(stderr, "Show MAC command is only supported on iSCSI\n");
		return -1;
	}


	mac = elxu_device_get_value(options.device, "/ocs/domain[0]/sport[0]/mac");


	if (strlen(mac) != 0) {
		printf("    MAC on adapter: ");
		for (i=0; i<strlen(mac); i++) {
			printf("%c", mac[i]);
			if (((i % 2) == 1) && (i != strlen(mac)-1)) {
				printf(":");
			}
		}
		printf("\n");
		return 0;
	} else {
		printf("   Unable to retrieve MAC address\n");
		return -1;
	}
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the show-mac command for the elx_pt driver.
 *
 * @par Description
 * This function processes the show-mac command.
 *
 * Command: show-mac <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: iSCSI <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_show_mac_pt(int argc, char **argv)
{
	cmd_options_t options;
	uint8_t mac[6];

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_iscsi(options.device) && !is_nic(options.device)) {
		fprintf(stderr, "Show MAC command is only supported on iSCSI and NIC\n");
		return -1;
	}

	mbox_get_mac_pt(options.device, mac);

	printf("    MAC on adapter: %s\n", hex_dump(mac, 6));

	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the show-wwn command.
 *
 * @par Description
 * This function processes the show-wwn command.
 *
 * Command: show-wwn <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All  <br>
 * Supported Protocols: FC <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_show_wwn(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_fc(options.device)) {
		fprintf(stderr, "Show WWN command is only supported on FC\n");
		return -1;
	}

	printf("WWNN: %s\n", hex_dump(options.device->wwnn, 8));
	printf("WWPN: %s\n", hex_dump(options.device->wwpn, 8));

	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the set-wwn command.
 *
 * @par Description
 * This function processes the set-wwn command.
 *
 * Command: set-wwn <br>
 * Required Parameters: WWN <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All  <br>
 * Supported Protocols: FC <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_set_wwn(int argc, char **argv)
{
	cmd_options_t options;
	char *wwpn_p;
	char *wwnn_p;
	char *wwn_p;
	int rc = -1;

	if (argc < 3) {
		//Too few arguments
		fprintf(stderr, "WWN value is required\n");
		return -1;
	}

	if (parse_arguments(argc, argv, &options, 1, 2) == -1) {
		return -1;
	}

	if(!is_fc(options.device)) {
		printf("WWN applies only to FC\n");
		return -1;
	}

	wwn_p = zmalloc(80);
	if (wwn_p == NULL) {
		return -1;
	}

	wwpn_p = options.wwpn;
	wwnn_p = options.wwnn;

	if ((wwpn_p == NULL) && (wwnn_p == NULL)) {
		printf("Failed to set WWN. Please provide valid WWNN/WWPN as input.\n");
		zfree(wwn_p);
		return -1;
	}
	/* Prepare wwn_p string which contains wwpn@wwnn */
	if (wwpn_p != NULL) {
		strncpy(wwn_p, wwpn_p, strlen(wwpn_p));
	} else {
		strncat(wwn_p, "NA", 2);
	}
	strncat(wwn_p, "@", 1);

	if (wwnn_p != NULL) {
		strncat(wwn_p, wwnn_p, strlen(wwnn_p));
	} else {
		strncat(wwn_p, "NA", 2);
	}

	if (options.device->driver == DEVICE_DRIVER_PT) {
		rc = mbox_set_nv_wwn_pt(options.device, wwpn_p, wwnn_p);
	} else if (options.device->driver == DEVICE_DRIVER_OCS) {
		rc = mgmt_set_value(options.device, "/ocs/nv_wwn", wwn_p);
	}

	if (rc == 0) {
		if (wwnn_p != NULL) {
			printf("New WWNN: %s\n", wwnn_p);
		}

		if (wwpn_p != NULL) {
			printf("New WWPN: %s\n", wwpn_p);
		}
		printf("Successfully changed WWN. Please reset adapter for changes to take effect.\n");
	} else {
		printf("Failed to change WWN\n");
	}

	zfree(wwn_p);
	return rc;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the driver-info command.
 *
 * @par Description
 * This function processes the driver-info command.
 *
 * Command: driver-info <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_driver_info(int argc, char **argv)
{
	cmd_options_t options;
	mgmt_list_t *status_list;
	mgmt_object_t *obj;
	char *value;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	/* The test team wants driver_version and pm_state first */
	value = elxu_device_get_value(options.device, "/ocs/driver_version");
	if (value && (strlen(value) > 0)) {
		printf("   driver_version: %s\n", value);
	}

	value = elxu_device_get_value(options.device, "/ocs/driver/pm_state");
	if (value && (strlen(value) > 0)) {
		printf("   pm_state: %s\n", value);
	}

	status_list = mgmt_get_all(options.device);

	/* Remove pm_state from the list if it's there */
	obj = mgmt_list_remove(status_list, "/ocs/driver/pm_state");

	/* Sort the remaining list items */
	mgmt_list_sort(status_list);

	/* Report the list items that start with /ocs/driver/ */
	obj = status_list->head;
	while (obj) {
		mgmt_property_t *prop;

		prop = obj->head;
		if (strncmp(prop->name, "/ocs/driver/", 12) == 0) {
			if (strstr(prop->access, "r") && (strlen(prop->value) > 0)) {
				char *s;
				s = strrchr(prop->name, '/') + 1;
				printf("   %s: %s\n", s, prop->value);
			}
		}
		obj = obj->next;
	}

	mgmt_delete_list(status_list);

	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the create-vport command.
 *
 * @par Description
 * This function processes the create-vport command.
 *
 * Command: create-vport <br>
 * Required Parameters: [<wwnn> <wwpn>] ( --target | --initiator ) <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All <br>
 * Supported Protocols: FC  <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_create_vport(int argc, char **argv)
{
	char *wwnn_arg;
	char *wwpn_arg;
	uint64_t wwnn;
	uint64_t wwpn;
	cmd_options_t options;

	/* If wwnn and wwpn are provided they will be argv[2] and argv[3].
	 * They can be omitted, in which case they default to zeroes.
	 * Either --target, --initiator, or both must be specified
	 */
	if (argc < 3) {
		// Too few arguments
		usage();
		return -1;
	}

	if (argv[2][0] == '-') {
		// argv[2] begins with a -, so the wwnn and wwpn were omitted
		wwnn_arg="00:00:00:00:00:00:00:00";
		wwpn_arg="00:00:00:00:00:00:00:00";
	} else {
		wwnn_arg = argv[2];
		wwpn_arg = argv[3];
	}

	if (parse_arguments(argc, argv, &options, 1, 3) == -1) {
		return -1;
	}

	if (!options.target && !options.initiator) {
		fprintf(stderr, "Must specify either --target or --initiator\n");
		return -1;
	}

	if ((!is_fc(options.device)) && (!is_fcoe(options.device))) {
		fprintf(stderr, "Vports are only supported on FC and FCoE\n");
		return -1;
	}

        if (parse_wwn(wwnn_arg, &wwnn) != 0) {
                printf("Invalid WWNN:  %s\n", wwnn_arg);
                return -1;
        }

        if (parse_wwn(wwpn_arg, &wwpn) != 0) {
                printf("Invalid WWPN:  %s\n", wwpn_arg);
                return -1;
        }

        return create_vport(options.device, wwnn, wwpn, options.target, options.initiator);
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the remove-vport command.
 *
 * @par Description
 * This function processes the remove-vport command.
 *
 * Command: remove-vport <br>
 * Required Parameters: <wwn> <wwn> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All <br>
 * Supported Protocols: FC  <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_remove_vport(int argc, char **argv)
{
	char *wwnn_arg;
	char *wwpn_arg;
	uint64_t wwnn;
	uint64_t wwpn;
	cmd_options_t options;

	if (argc < 4) {
		fprintf(stderr, "WWNN and WWPN are required\n");
		return -1;
	}

	wwnn_arg = argv[2];
	wwpn_arg = argv[3];

	if (parse_arguments(argc, argv, &options, 1, 3) == -1) {
		return -1;
	}

	if ((!is_fc(options.device)) && (!is_fcoe(options.device))) {
		fprintf(stderr, "Vports are only supported on FC and FCoE\n");
		return -1;
	}

        if (parse_wwn(wwnn_arg, &wwnn) != 0) {
                printf("Invalid WWNN:  %s\n", wwnn_arg);
                return -1;
        }

        if (parse_wwn(wwpn_arg, &wwpn) != 0) {
                printf("Invalid WWPN:  %s\n", wwpn_arg);
                return -1;
        }

        return remove_vport(options.device, wwnn, wwpn, options.target, options.initiator);
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the linkcfg-get command.
 *
 * @par Description
 * This function processes the linkcfg-get command.
 *
 * Command: linkcfg-get <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device>  <br>
 * Supported Devices: All <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_linkcfg(int argc, char **argv)
{
	cmd_options_t options;
	char *linkcfg = NULL;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (options.device->driver == DEVICE_DRIVER_OCS) {
		/* send IOCTL to get link config; note this will use the generic
		 * "get config" management framework -- no need to add a dedicated
		 * IOCTL
		 */
		linkcfg = elxu_device_get_value(options.device, "/ocs/linkcfg");
	} else if (options.device->driver == DEVICE_DRIVER_PT) {
		linkcfg = mbox_get_linkcfg_pt(options.device);
	}
	if (linkcfg == NULL) {
		printf("Failed to get linkcfg value\n");
		return -1;
	}
	printf("Link config: %s\n", linkcfg);
	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the linkspeed-get command.
 *
 * @par Description
 * This function processes the linkspeed-get command.
 *
 * Command: linkspeed-get <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device>  <br>
 * Supported Devices: All <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_linkspeed(int argc, char **argv)
{
	cmd_options_t options;
	char *linkspeed = NULL;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (options.device->driver == DEVICE_DRIVER_OCS) {
		/* send IOCTL to get link config; note this will use the generic
		 * "get linkspeed" management framework -- no need to add a dedicated
		 * IOCTL
		 */
		linkspeed = elxu_device_get_value(options.device, "/ocs/configured_speed");
	}
	if (linkspeed == NULL) {
		printf("Failed to get linkspeed value\n");
		return -1;
	}
	printf("Link speed: %s\n", linkspeed);
	return 0;
}

/**
* @ingroup cmd_handler
 * @brief Command handler for the linktopology-get command.
 *
 * @par Description
 * This function processes the linktopology-get command.
 *
 * Command: linktopology-get <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device>  <br>
 * Supported Devices: All <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_linktopology(int argc, char **argv)
{
	cmd_options_t options;
	char *linktopology = NULL;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (options.device->driver == DEVICE_DRIVER_OCS) {
		/* send IOCTL to get link config; note this will use the generic
		 * "get linkspeed" management framework -- no need to add a dedicated
		 * IOCTL
		 */
		linktopology = elxu_device_get_value(options.device, "/ocs/configured_topology");
	}
	if (linktopology == NULL) {
		printf("Failed to get linktopology value\n");
		return -1;
	}
	printf("Link topology: %s\n", linktopology);
	return 0;
}
/**
 * @ingroup cmd_handler
 * @brief Command handler for the linkcfg-set command.
 *
 * @par Description
 * This function processes the linkcfg-set command.
 *
 * Command: linkcfg-set <br>
 * Required Parameters: --linkcfg <link configuration> <br>
 * Optional Parameters: -d <device>  <br>
 * Supported Devices: ALl <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_set_linkcfg(int argc, char **argv)
{
	cmd_options_t options;
	uint8_t supported = 0;
	int32_t rval = -1;
	int32_t i;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	/* check to see if this is a supported link configuration */
	for (i = 0; i < ARRAY_SIZE(supported_linkcfgs); i++) {
		if (strcmp(supported_linkcfgs[i], options.linkcfg) == 0) {
			supported = 1;
			break;
		}
	}
	if (!supported) {
		printf("Unsupported link config=%s\n", options.linkcfg);
		return -1;
	}

	if (options.device->driver == DEVICE_DRIVER_OCS) {
		/* send IOCTL to set link config; note this will use the generic
		 * "set config" management framework -- no need to add a dedicated
		 * IOCTL
		 */
		rval = mgmt_set_value(options.device, "/ocs/linkcfg", options.linkcfg);
	} else if (options.device->driver == DEVICE_DRIVER_PT) {
		rval = mbox_set_linkcfg_pt(options.device, options.linkcfg);
	}

	if (rval) {
		printf("Failed to set link config, IOCTL failed status=%d\n", rval);
		return rval;
	}

	printf("Successfully set link config. Please reboot for changes to take effect.\n");
	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the link-speed-set command.
 *
 * @par Description
 * This function processes the link-speed-set command.
 *
 * Command: linkspeed-set <br>
 * Required Parameters: --link-speed <link configuration> <br>
 * Optional Parameters: -d <device>  <br>
 * Supported Devices: ALl <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_set_linkspeed(int argc, char **argv)
{
	cmd_options_t options;
	uint8_t supported = 0;
	int32_t rval = -1;
	int32_t i;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	/* check to see if this is a supported link speed */
	for (i = 0; i < ARRAY_SIZE(supported_linkspeed); i++) {
		if (strcmp(supported_linkspeed[i], options.linkspeed) == 0) {
			supported = 1;
			break;
		}
	}
	if (!supported) {
		printf("Unsupported link config=%s\n", options.linkspeed);
		return -1;
	}

	if (options.device->driver == DEVICE_DRIVER_OCS) {
		/* send IOCTL to set link config; note this will use the generic
		 * "set config" management framework -- no need to add a dedicated
		 * IOCTL
		 */
		rval = mgmt_set_value(options.device, "/ocs/configured_speed", options.linkspeed);
	} else {
		printf("link speed is not supported for this driver\n");
		return -1;
	}

	if (rval) {
		printf("Failed to set link speed, IOCTL failed status=%d\n", rval);
		return rval;
	}

	printf("Successfully set link speed.\n");
	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the linktopology-set command.
 *
 * @par Description
 * This function processes the linktopology-set command.
 *
 * Command: linktopology-set <br>
 * Required Parameters: --link-topology <link configuration> <br>
 * Optional Parameters: -d <device>  <br>
 * Supported Devices: ALl <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_set_linktopology(int argc, char **argv)
{
	cmd_options_t options;
	uint8_t supported = 0;
	int32_t rval = -1;
	int32_t i;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	/* check to see if this is a supported link topology */
	for (i = 0; i < ARRAY_SIZE(supported_linktopology); i++) {
		if (strcmp(supported_linktopology[i], options.linktopology) == 0) {
	
			/* restrict LOOP only for g5 */		
			if ((strcmp(options.linktopology, LOOP) == 0) &&
			     !is_lancer_g5(options.device))
				break;

			supported = 1;
			break;
		}
	}
	if (!supported) {
		printf("Unsupported link topology=%s\n", options.linktopology);
		return -1;
	}

	if (options.device->driver == DEVICE_DRIVER_OCS) {
		/* send IOCTL to set link config; note this will use the generic
		 * "set link topology" management framework -- no need to add a dedicated
		 * IOCTL
		 */
		rval = mgmt_set_value(options.device, "/ocs/configured_topology", options.linktopology);
	} else {
		printf("link topology is not supported for this driver\n");
		return -1;
	}

	if (rval) {
		printf("Failed to set link topology, IOCTL failed status=%d\n", rval);
		return rval;
	}

	printf("Successfully set link topology.\n");
	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the get-profile-list command.
 *
 * @par Description
 * This function processes the get-profile-list command.
 *
 * Command: get-profile-list <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_profile_list(int argc, char **argv)
{
	cmd_options_t options;
	char *response;
	int rc;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_skyhawk(options.device)) {
		fprintf(stderr, "Profiles are only supported on Skyhawk\n");
		return -1;
	}

	response = elxu_device_get_value(options.device, "/ocs/profile_list");

	if (strlen(response) == 0) {
		printf("Failed to get supported profile list\n");
		rc = -1;
	} else {
		printf("Supported profiles:\n");
		printf("%s\n", response);
		rc = 0;
	}

	return rc;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the get-active-profile command.
 *
 * @par Description
 * This function processes the get-active-profile command.
 *
 * Command: get-active-profile <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_active_profile(int argc, char **argv)
{
	cmd_options_t options;
	char *response;
	int rc = -1;
	char profile_description[80];

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		goto exit_get_active_profile;
	}

	if (!is_skyhawk(options.device)) {
		fprintf(stderr, "Profiles are only supported on Skyhawk\n");
		goto exit_get_active_profile;
	}

	response = elxu_device_get_value(options.device, "/ocs/active_profile");

	if (strlen(response)== 0) {
		printf("Failed to get active profile\n");
	} else {
		int profile;
		profile = strtol(response, NULL, 0);

		/* Got the profile ID, get the list to get a description */
		strcpy(profile_description, "(Description not available)");

		response = elxu_device_get_value(options.device, "/ocs/profile_list");
		if (strlen(response) != 0) {
			char *line;
			char *tokptr1;
			char *tokptr2;
			char *id;
			char *description;

			/* Break the response into lines */
			line = strtok_r(response, "\n", &tokptr1);
			while (line) {
				/* Break the line into fields */
				id = strtok_r(line, ":", &tokptr2);
				description = strtok_r(NULL, "\n", &tokptr2);
				if (strtol(id, NULL, 0) == profile) {
					if (strlen(description) < 80) {
						strncpy(profile_description, description, strlen(description));
						rc = 0;
					}
					break;
				}
				line = strtok_r(NULL, "\n", &tokptr1);
			}

			printf("Active profile:\n");
			printf("0x%02x: %s\n", profile, profile_description);
		}

	}

exit_get_active_profile:
	return rc;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the set-active-profile command.
 *
 * @par Description
 * This function processes the set-active-profile command.
 *
 * Command: set-active-profile <br>
 * Required Parameters: <profile_id> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_set_active_profile(int argc, char **argv)
{
	cmd_options_t options;
	char *new_profile_id;
	int rc;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_skyhawk(options.device)) {
		fprintf(stderr, "Profiles are only supported on Skyhawk\n");
		return -1;
	}

	new_profile_id = options.profile_id;

	rc = mgmt_set_value(options.device, "/ocs/active_profile", new_profile_id);

	if (rc) {
		printf("Set active profile failed.\n");
	} else {
                printf("Active profile set to %s\n",new_profile_id);
                printf("New profile will be in effect after reboot\n");
	}

	return rc;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the get-profile-list command for the elx_pt driver.
 *
 * @par Description
 * This function processes the get-profile-list command.
 *
 * Command: get-profile-list <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_profile_list_pt(int argc, char **argv)
{
	cmd_options_t options;
	int rc = -1;
	char result[5*1024];

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	rc = mbox_get_profile_list_pt(options.device, result, sizeof(result));
	if (rc == 0) {
		printf("Supported profiles:\n");
		printf("%s\n", result);
	} else {
		printf("Failed to get list of supported profiles\n");
	}

	return rc;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the get-active-profile command for the elx_pt driver.
 *
 * @par Description
 * This function processes the get-active-profile command.
 *
 * Command: get-active-profile <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_active_profile_pt(int argc, char **argv)
{
	cmd_options_t options;
	int rc = -1;
	char result[256];

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	rc = mbox_get_active_profile_pt(options.device, result, sizeof(result));
	if (rc == 0) {
		printf("Active profile:\n");
		printf("%s\n", result);
	} else {
		printf("Failed to get active profile\n");
	}

	return rc;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the set-active-profile command for the elx_pt driver.
 *
 * @par Description
 * This function processes the set-active-profile command.
 *
 * Command: set-active-profile <br>
 * Required Parameters: <profile_id> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_set_active_profile_pt(int argc, char **argv)
{
	cmd_options_t options;
	int rc = -1;
	char *new_profile_id;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	new_profile_id = options.profile_id;

	rc = mbox_set_active_profile_pt(options.device, new_profile_id);

	if (rc) {
		printf("Set active profile failed.\n");
	} else {
                printf("Active profile set to %s\n",new_profile_id);
                printf("New profile will be in effect after reboot\n");
	}

	return rc;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the get-port-protocol command.
 *
 * @par Description
 * This function processes the get-port-protocol command.
 *
 * Command: get-port-protocol <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_port_protocol(int argc, char **argv)
{
	cmd_options_t options;
	char *response;
	int rc;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_skyhawk(options.device)) {
		fprintf(stderr, "Port protocols are only supported on Skyhawk\n");
		return -1;
	}

	response = elxu_device_get_value(options.device, "/ocs/port_protocol");

	if (strlen(response)== 0) {
		printf("Failed to get port protocol\n");
		rc = -1;
	} else {
		printf("Port protocol:\n");
		printf("%s\n", response);
		rc = 0;
	}

	return rc;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the set-port-protocol command.
 *
 * @par Description
 * This function processes the set-port-protocol command.
 *
 * Command: set-port-protocol <br>
 * Required Parameters: --protocol <protocol_name> <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: Skyhawk  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_set_port_protocol(int argc, char **argv)
{
	cmd_options_t options;
	char *new_protocol_name;
	int rc;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_skyhawk(options.device)) {
		fprintf(stderr, "Port protocols are only supported on Skyhawk\n");
		return -1;
	}

	new_protocol_name = options.protocol_name;

	rc = mgmt_set_value(options.device, "/ocs/port_protocol", new_protocol_name);

	if (rc) {
		printf("Set port protocol failed.\n");
	} else {
		printf("Port protocol set\n");
	}

	return rc;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the firmware-reset command.
 *
 * @par Description
 * This function processes the firmware-reset command.
 *
 * Command: firmware-reset <br>
 * Required Parameters: none <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_firmware_reset(int argc, char **argv)
{
	int rval;
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	rval = elxu_device_exec(options.device, "/ocs/firmware_reset", NULL, 0, NULL, 0);

	if (rval == 0) {
		printf("Firmware reset successful, driver must now be reloaded\n");
	} else {
		perror("ioctl");
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the elxu_cmd_get_fdmi_hba_list command.
 *
 * @par Description
 * This function processes the elxu_cmd_get_fdmi_hba_list command.
 *
 * Command: elxu_cmd_get_fdmi_hba_list <br>
 * Required Parameters: none <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_fdmi_hba_list(int argc, char **argv)
{
	int rval;
	cmd_options_t options;
	ocs_fdmi_hba_list_info_t *hba_list_info = NULL;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		rval = -1;
		goto done;
	}

	hba_list_info = malloc(sizeof(*hba_list_info));
	if (hba_list_info == NULL) {
		perror("malloc");
		rval = -1;
		goto done;
	}

	rval = elxu_device_exec(options.device, "/ocs/domain[0]/sport[0]/get_fdmi_hba_list",
				NULL, 0, hba_list_info, sizeof(*hba_list_info));
	if (rval == 0) {
		uint32_t i;

		printf("FDMI HBA list:\n");
		printf("    Number of HBA entries: %d\n", hba_list_info->entry_count);

		for (i = 0; i < hba_list_info->entry_count; i++)
			printf("        0x%lx\n", hba_list_info->hba_identifier[i]);

		printf("\n");
		
	} else {
		perror("ioctl");
	}

done:
	if (hba_list_info)
		free(hba_list_info);

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the elxu_cmd_get_fdmi_port_list command.
 *
 * @par Description
 * This function processes the elxu_cmd_get_fdmi_port_list command.
 *
 * Command: elxu_cmd_get_fdmi_port_list <br>
 * Required Parameters: none <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_fdmi_port_list(int argc, char **argv)
{
	int rval = 0;
	cmd_options_t options;
	ocs_fdmi_port_list_info_t *port_list_info = NULL;
	char hba_id[128] = {0,};
	uint32_t hba_id_len;

        if (argc < 3) { 
                //Too few arguments
                fprintf(stderr, "HBA identifier is required\n");
                goto done;
	}

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		rval = -1;
		goto done;
	}

	if (options.hba_identifier == NULL) {
		rval = -1;
		printf("Please provide valid HBA identifier as input\n");
		goto done;
	}

	port_list_info = malloc(sizeof(*port_list_info));
	if (port_list_info == NULL) {
		perror("malloc");
		rval = -1;
		goto done;
	}


	hba_id_len = snprintf(hba_id, sizeof(hba_id), "%s", options.hba_identifier);
	rval = elxu_device_exec(options.device, "/ocs/domain[0]/sport[0]/get_fdmi_port_list",
				hba_id, hba_id_len, port_list_info, sizeof(*port_list_info));
	if (rval == 0) {
		uint32_t i;

		printf("FDMI Port list:\n");
		printf("    Number of Port entries: %d\n", port_list_info->entry_count);

		for (i = 0; i < port_list_info->entry_count; i++)
			printf("        0x%lx\n", port_list_info->port_identifier[i]);

		printf("\n");
		
	} else {
		perror("ioctl");
	}

done:
	if (port_list_info)
		free(port_list_info);

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the elxu_cmd_get_fdmi_hba_info command.
 *
 * @par Description
 * This function processes the elxu_cmd_get_fdmi_hba_info command.
 *
 * Command: elxu_cmd_get_fdmi_hba_list <br>
 * Required Parameters: none <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_fdmi_hba_info(int argc, char **argv)
{
	int rval = -1;
	cmd_options_t options;
	ocs_fdmi_hba_attr_info_t *hba_info = NULL;
	char hba_id[128] = {0,};
	uint32_t hba_id_len;

        if (argc < 3) { 
                //Too few arguments
                fprintf(stderr, "HBA identifier is required\n");
                goto done;
	}

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		rval = -1;
		goto done;
	}

	if (options.hba_identifier == NULL) {
		rval = -1;
		printf("Please provide valid HBA identifier as input\n");
		goto done;
	}

	hba_info = malloc(sizeof(*hba_info));
	if (hba_info == NULL) {
		perror("malloc");
		rval = -1;
		goto done;
	}


	hba_id_len = snprintf(hba_id, sizeof(hba_id), "%s", options.hba_identifier);
	rval = elxu_device_exec(options.device, "/ocs/domain[0]/sport[0]/get_fdmi_hba_info",
				hba_id, hba_id_len, hba_info, sizeof(*hba_info));
	if (rval == 0) {
		uint32_t i;

		printf("FDMI HBA info:\n");
		printf("    Number of Port entries: %d\n", hba_info->num_port_entries);

		for (i = 0; i < hba_info->num_port_entries; i++)
			printf("        0x%lx\n", hba_info->port_identifier[i]);

		if (hba_info->node_name_valid)
			printf("         Node name: 0x%lx\n", hba_info->node_name);

		if (hba_info->manufacturer_valid)
			printf("         Manufacturer name: %s\n", hba_info->manufacturer);

		if (hba_info->serial_num_valid)
			printf("         Serial Number: %s\n", hba_info->serial_num);

		if (hba_info->model_name_valid)
			printf("         Model name: %s\n", hba_info->model_name);

		if (hba_info->model_desc_valid)
			printf("         Model Description: %s\n", hba_info->model_desc);
		
		if (hba_info->hw_ver_valid)
			printf("         Hardware Version: %s\n", hba_info->hw_ver);

		if (hba_info->driver_ver_valid)
			printf("         Driver Version: %s\n", hba_info->driver_ver);

		if (hba_info->opt_rom_ver_valid)
			printf("         Optional ROM Version: %s\n", hba_info->opt_rom_ver);
			
		if (hba_info->fw_ver_valid)
			printf("         Firmware Version: %s\n", hba_info->fw_ver);

		if (hba_info->os_name_ver_valid)
			printf("         OS Name and Version: %s\n", hba_info->os_name_ver);

		if (hba_info->max_ct_payload_valid)
			printf("         MAX CT Payload length: %d\n", hba_info->max_ct_payload_len);

		if (hba_info->node_symb_name_valid)
			printf("         Node Symbolic Name: %s\n", hba_info->node_symb_name);

		if (hba_info->vendor_info_valid)
			printf("         Vendor Info: 0x%x\n", hba_info->vendor_info);
			
		if (hba_info->num_ports_valid)
			printf("         No of Ports: %d\n", hba_info->num_ports);
			
		if (hba_info->fabric_name_valid)
			printf("         Fabric Name: 0x%lx\n", hba_info->fabric_name);
			
		if (hba_info->bios_ver_valid)
			printf("         BIOS version: %s\n", hba_info->bios_ver);
			
		if (hba_info->boot_state_valid)
			printf("         BOOT state: %d\n", hba_info->boot_state);
			
		if (hba_info->vendor_id_valid)
			printf("         Vendor ID: %s\n", hba_info->vendor_id);
	} else {
		perror("ioctl");
	}

done:
	if (hba_info)
		free(hba_info);

	return rval;
}

void elxu_decode_port_speed(uint32_t port_speed, char *buf)
{
	char port_speed_str[256] = {0,};

	if (port_speed & PORTSPEED_1GFC) {
		strcat(port_speed_str, "1 ");
	}
	if (port_speed & PORTSPEED_2GFC) {
		strcat(port_speed_str, "2 ");
	}
	if (port_speed & PORTSPEED_4GFC) {
		strcat(port_speed_str, "4 ");
	}
	if (port_speed & PORTSPEED_8GFC) {
		strcat(port_speed_str, "8 ");
	}
	if (port_speed & PORTSPEED_16GFC) {
		strcat(port_speed_str, "16 ");
	}
	if (port_speed & PORTSPEED_32GFC) {
		strcat(port_speed_str, "32 ");
	}
	if (port_speed & PORTSPEED_64GFC) {
		strcat(port_speed_str, "64 ");
	}
	if (port_speed & PORTSPEED_128GFC) {
		strcat(port_speed_str, "128 ");
	}
	strcat(port_speed_str, "Gb/s");
	strncpy(buf, port_speed_str, 256);

	return;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the elxu_cmd_get_fdmi_port_info command.
 *
 * @par Description
 * This function processes the elxu_cmd_get_fdmi_port_info command.
 *
 * Command: elxu_cmd_get_fdmi_port_info <br>
 * Required Parameters: none <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_fdmi_port_info(int argc, char **argv)
{
	int rval;
	cmd_options_t options;
	ocs_fdmi_port_attr_info_t *port_info = NULL;
	char port_id[128] = {0,};
	uint32_t port_id_len;

        if (argc < 3) { 
                //Too few arguments
                fprintf(stderr, "Port identifier is required\n");
                goto done;
	}

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		rval = -1;
		goto done;
	}

	if (options.port_identifier == NULL) {
		rval = -1;
		printf("Please provide valid port identifier as input\n");
		goto done;
	}

	port_info = malloc(sizeof(*port_info));
	if (port_info == NULL) {
		perror("malloc");
		rval = -1;
		goto done;
	}


	port_id_len = snprintf(port_id, sizeof(port_id), "%s", options.port_identifier);
	rval = elxu_device_exec(options.device, "/ocs/domain[0]/sport[0]/get_fdmi_port_info",
				port_id, port_id_len, port_info, sizeof(*port_info));
	if (rval == 0) {
		printf("FDMI Port info:\n");
		printf("    Number of Port attributes: %d\n", port_info->num_port_attr_entries);

		if (port_info->supported_fc_types_valid) {
			int byte = 0;

			printf("         Supported FC-4 types: ");
			for (byte = 0; byte < sizeof(port_info->supported_fc4_types); byte++)
				printf("0x%x ", port_info->supported_fc4_types[byte]);
			printf("\n");
			
		}
		if (port_info->supported_speed_valid) {
			char port_speed_str[256] = {0,};

			elxu_decode_port_speed(port_info->supported_speed, port_speed_str);
			printf("         Supported speed: %s\n", port_speed_str);
		}

		if (port_info->current_speed_valid) {
			char port_speed_str[256] = {0,};

			elxu_decode_port_speed(port_info->current_port_speed, port_speed_str);
			printf("         Port Current speed: %s\n", port_speed_str);
		}

		if (port_info->max_frame_size_valid)
			printf("         Maximum frame size: 0x%x\n", port_info->max_frame_size);

		if (port_info->os_dev_name_valid)
			printf("         OS Device Name: %s\n", port_info->os_dev_name);

		if (port_info->host_name_valid)
			printf("         Host Name: %s\n", port_info->host_name);
		
		if (port_info->node_name_valid)
			printf("         Node Name: 0x%lx\n", port_info->node_name);
		
		if (port_info->port_name_valid)
			printf("         Port Name: 0x%lx\n", port_info->port_name);

		if (port_info->port_symb_name_valid)
			printf("         Port symbolic name: %s\n", port_info->port_symb_name);

		if (port_info->port_type_valid) {
			printf("         Port type: ");
			switch (port_info->port_type) {
			case 0x1:
				printf("N_Port\n");
				break;
			case 0x2:
				printf("NL_Port\n");
				break;
			case 0x3:
				printf("F/NL_Port\n");
				break;
			case 0x81:
				printf("F_Port\n");
				break;
			case 0x82:
				printf("FL_Port\n");
				break;
			default:
				printf("Undefined\n");
			}
		}
		if (port_info->supported_cos_valid) {
			printf("         Supported Class of service: %d\n",
				port_info->supported_class_of_service);
		}

		if (port_info->port_fabric_name_valid)
			printf("         Port fabric name: 0x%lx\n", port_info->port_fabric_name);

		if (port_info->port_state_valid)
			printf("         Port state: %d\n", port_info->port_state);
			
		if (port_info->num_disc_ports_valid)
			printf("         Number of Discovered Ports: %d\n", port_info->num_disc_ports);

		if (port_info->port_id_valid)
			printf("         Port identifier: 0x%x\n", port_info->port_identifier);

		if (port_info->active_fc_types_valid) {
			int byte = 0;
			
			printf("         Active FC-4 types: ");
			for (byte = 0; byte < sizeof(port_info->active_fc4_types); byte++)
				printf("0x%x ", port_info->active_fc4_types[byte]);
			printf("\n");
		}
	} else {
		perror("ioctl");
	}

done:
	if (port_info)
		free(port_info);

	return 0;
}


/**
 * @ingroup cmd_handler
 * @brief Command handler for elxu_cmd_set_trunk_mode command.
 *
 * @par Description
 * This function processes the elxu_cmd_set_trunk_mode command.
 *
 * Command: elxu_cmd_set_trunk_mode <br>
 * Required Parameters: -d <device> --mode <trunk mode> <br>
 * Optional Parameters: None <br>
 * Supported Devices: Prism <br>
 * Supported Protocols: FC <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_set_trunk_mode(int argc, char **argv)
{
	cmd_options_t options;
	int rc;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if(!is_prism(options.device)) {
		fprintf(stderr, "Trunking is only supported on Prism adapters.\n");
		return -1;
	}

	rc = elxu_device_exec(options.device, "/ocs/driver/trunk_mode", &options.trunk_mode, sizeof(options.trunk_mode), NULL, 0);
	if (rc < 0) {
		printf("Set trunk mode failed, rc %d.\n", rc);
	} else {
		printf("Device configured to (%d) trunk mode. Host reboot is required for new trunk mode to take effect.\n", options.trunk_mode);
	}

	return rc;
}

static void
ocs_fc_report_trunk_links(uint8_t ports_active, char *active_ports_str, size_t max_str_len)
{
	char tmp[8];
	char *ptr = active_ports_str;
	int i;

	memset(active_ports_str, 0x0, max_str_len);
	for (i = 0; i < OCS_MAX_SLI_PORTS_PER_DEVICE; i++) {
		if (!(ports_active & (1 << i)))
			continue;
		if (!strlen(active_ports_str)) {
			snprintf(tmp, sizeof(tmp), "%d", i);
		} else {
			snprintf(tmp, sizeof(tmp), ",%d", i);
		}
		if (strlen(active_ports_str) + strlen(tmp) > max_str_len)
			break;
		strcpy(ptr, tmp);
		ptr += strlen(tmp);
	}

	if (!strlen(active_ports_str)) {
		strcpy(active_ports_str, "None");
	}
}


/**
 * @ingroup cmd_handler
 * @brief Command handler for elxu_cmd_get_trunk_config command.
 *
 * @par Description
 * This function processes the elxu_cmd_get_trunk_config command.
 *
 * Command: elxu_cmd_get_trunk_config <br>
 * Required Parameters: -d <device> <br>
 * Optional Parameters: None <br>
 * Supported Devices: Prism <br>
 * Supported Protocols: FC <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_trunk_config(int argc, char **argv)
{
	cmd_options_t options;
	uint32_t trunk_info;
	char *logical_link_speed;
	char active_ports_str[16];
	int rc;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if(!is_prism(options.device)) {
		fprintf(stderr, "Trunking is only supported on Prism adapters.\n");
		return -1;
	}

	rc = elxu_device_exec(options.device, "/ocs/driver/trunk_info",
			      NULL, 0, &trunk_info, sizeof(trunk_info));
	if (rc < 0) {
		printf("Get trunk mode failed, rc %d.\n", rc);
		return rc;
	}

	ocs_fc_report_trunk_links(trunk_info & OCS_FC_TRUNK_LINK_STATE_MASK,
				  active_ports_str, sizeof(active_ports_str));
	switch (trunk_info & OCS_FC_TRUNK_CONFIG_MASK) {
	case 0:
		printf("SLI port is a single physical FC link\n");
		break;
	case OCS_FC_TRUNK_2_PORT_CONFIG:
		/* 2 links per trunk config, trunk incorporates either,
		 *   1) port 0/1 of a 4-port device
		 *   2) Both ports of a 2-port device
		 */
		printf("FC Trunk Configuration:\n\tLinks=2\n\tMember ports={ 0,1 }\n\tActive ports={ %s }\n", active_ports_str);
		break;
	case OCS_FC_TRUNK_2_PORT_HI_CONFIG:
		/* 2 links per trunk config that incorporates port 2/3 of a 4-port device. */
		printf("FC Trunk Configuration:\n\tLinks=2\n\tMember ports={ 2,3 }\n\tActive ports={ %s }\n", active_ports_str);
		break;
	case OCS_FC_TRUNK_4_PORT_CONFIG:
		/* 4 links per trunk config that incorporates all ports of a 4-port device. */
		printf("FC Trunk Configuration:\n\tLinks=4\n\tMember ports={ 0,1,2,3 }\n\tActive ports={ %s }\n", active_ports_str);
		break;
	default:
		printf("Invalid FC link topology\n");
	}

	logical_link_speed = elxu_device_get_value(options.device, "/ocs/logical_link_speed");
	if (strlen(logical_link_speed) == 0) {
		printf("Failed to get logical link speed from device %d\n",
		       options.device->deviceIndex);
		return -1;
	}
	printf("\n Logical Link Speed: %ld Gbps\n", strtoul(logical_link_speed, NULL, 0)/1000);
	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the port-migration command.
 *
 * @par Description
 * This function processes the port-migration command.
 *
 * Command: port-migration <br>
 * Required Parameters: none <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_port_migration(int argc, char **argv)
{
	int rval;
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	rval = elxu_device_exec(options.device, "/ocs/port_migration", NULL, 0, NULL, 0);

	if (rval == 0) {
		printf("Port migration operation is successed\n");
	} else {
		perror("ioctl");
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the get-parity-stats command.
 *
 * @par Description
 * This function processes the get-parity-stats command.
 *
 * Command: get-parity-stats <br>
 * Required Parameters: none <br>
 * Optional Parameters: -d <device> --cc <br>
 * Supported Devices: All  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_get_parity_stats(int argc, char **argv)
{
	int i, rval;
	cmd_options_t options;
	int arg_in_len, arg_out_len;
	char *arg_in = NULL;
	void *arg_out = NULL;
	ocs_parity_err_count_t *counter = NULL;

	rval = parse_arguments(argc, argv, &options, 1, 1);
	if (rval)
		return -1;

	if (options.cc) {
		/* Clear the stats */
		arg_in = "clear";
		arg_in_len = strlen("clear") + 1;
	}

	arg_out_len = (OCS_MAX_SLI4_ULP * sizeof(ocs_parity_err_count_t));
	arg_out = (void *)malloc(arg_out_len);
	if (!arg_out)
		return -1;

	memset(arg_out, 0, arg_out_len);
	rval = elxu_device_exec(options.device, "/ocs/get_parity_stats", arg_in, arg_in_len, arg_out, arg_out_len);
	if (rval) {
		perror("ioctl");
	} else {
		counter = (ocs_parity_err_count_t *)arg_out;
		printf("ITCM Parity Stats:\n");
		printf("==================\n");
		for (i = 0; i < OCS_MAX_SLI4_ULP; i++) {
			printf("parity_bit_error_count[%d] = %d, total_parity_error_count[%d] = %d\n",
				i, counter[i].pbec, i, counter[i].tpec);
		}
	}

	free(arg_out);
	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Send a firmware reset via the elx_pt driver
 *
 * @par Description
 * This function sends a firmware reset via the elx_pt driver.
 *
 * Command: firmware-reset <br>
 * Required Parameters: none <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_firmware_reset_pt(int argc, char **argv)
{
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (mbox_fw_reset_pt(options.device, 0)) {
		printf("Firmware reset failed\n");
		return -1;
	}

	printf("Firmware reset successful, driver must now be reloaded\n");
	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for user space driver unload
 *
 * @par Description
 * This function processes the unload command.
 *
 * Command: unload <br>
 * Required Parameters: none <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_unload(int argc, char **argv)
{
	int rval;
	cmd_options_t options;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_uspace(options.device)) {
		fprintf(stderr, "Unload command is only supported on user space drivers\n");
		return -1;
	}
	rval = elxu_ioctl_device(options.device, OCS_IOCTL_CMD_UNLOAD, NULL);
	if (rval) {
		fprintf(stderr, "elxu_iocl_device CMD_UNLOAD failed: %d\n", rval);
	}

	return rval;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the node-abort-cnt command.
 *
 * @par Description
 * This function processes the node-abort-cnt command.
 *
 * Command: get-node-abort-cnt <br>
 * Required Parameters: None <br>
 * Optional Parameters: -d <device> <br>
 * Supported Devices: All <br>
 * Supported Protocols: FC and FCoE <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_node_abort_cnt(int argc, char **argv)
{
	cmd_options_t options;
	char *value;

	if (parse_arguments(argc, argv, &options, 1, 1) == -1) {
		return -1;
	}

	if (!is_fc(options.device) && !is_fcoe(options.device)) {
		fprintf(stderr, "Node aborts are applicable only on FC or FCoE\n");
		return -1;
        }

	value = elxu_device_get_value(options.device, "/ocs/node_abort_cnt");
	if (strlen(value) == 0) {
		printf("Failed to get sum of nodes abort count from device %d\n",
		       options.device->deviceIndex);
		return -1;
	}

	printf("Sum of all nodes abort_cnt = %s\n", value);

	return 0;
}

/**
 * @ingroup cmd_handler
 * @brief Command handler for the help command.
 *
 * @par Description
 * This function processes the help command.
 *
 * Command: help <br>
 * Required Parameters: None <br>
 * Optional Parameters: <command> <br>
 * Supported Devices: N/A  <br>
 * Supported Protocols: N/A <br>
 *
 * @param argc The number of command line arguments.
 * @param argv An array of pointers to the command line arguments.
 *
 * @return Returns 0 on success; or a non-zero error code value on failure.
 */
int elxu_cmd_help(int argc, char **argv)
{
	int i;

	if (argc > 2) {
		if (strcmp(argv[2], "examples") == 0) {
			show_examples();
			return 0;
		}
		for (i=0; i<ARRAY_SIZE(cmd_table); i++) {
			if (strcmp(argv[2],cmd_table[i].name) == 0) {
				printf("Command: %s\n", cmd_table[i].syntax);
				printf("Usage: %s\n", cmd_table[i].help_text);
				/*
				 * Check for per-driver command support.  Currently there
				 * are only three cases we care about:  OCS only, elx_pt
				 * only, or both.
				 */
				if (cmd_table[i].ocs_handler == NULL) {
					if (cmd_table[i].pt_handler != NULL) {
						printf("This command is supported only with the elx_pt driver.\n");
					}
				} else {
					if (cmd_table[i].pt_handler == NULL) {
						printf("This command is not supported with the elx_pt driver.\n");
					}
				}
				return 0;
			}
		}
	}

	printf("Type 'elxsdkutil help <command>' for help on a specific command.\n");
	printf("Type 'elxsdkutil help examples' for usage examples.\n\n");

	printf("Available commands:\n");
	for (i=0; i<ARRAY_SIZE(cmd_table); i++) {
		printf("  %s", cmd_table[i].name);
		if ((cmd_table[i].pt_handler == NULL) && (cmd_table[i].ocs_handler != NULL)) {
			/* OCS driver only */
			printf(" (1)\n");
		} else if ((cmd_table[i].pt_handler != NULL) && (cmd_table[i].ocs_handler == NULL)) {
			/* elx_pt only */
			printf(" (2)\n");
		} else {
			printf("\n");
		}
	}
	printf(" (1) indicates a command supported by the OneCoreStorage drivers but not the elx_pt driver.\n");
	printf(" (2) indicates a command supported by the elx_pt driver but not the OneCoreStorage drivers.\n");

	return 0;
}

/**
 * @brief  Show program usage.
 *
 * @par Description
 * Displays program help text.
 */
void usage()
{
	elxu_cmd_help(0, NULL);
}

/**
 * @brief  Parse command line arguments.
 *
 * @par Description
 * Given the argc and argv parameters from the main program,
 * function parses the command line arguments and stores the results
 * in the cmd_options_t structure.
 *
 *
 * @param argc Count of arguments.
 * @param argv Array of pointers to argument strings.
 * @param options Pointer to array into which the results will be stored.
 * @param openflag If TRUE the device specified by the options should be opened.
 * @param expected_nonargs Expected number of extra arguments.
 *
 * @return Returns 0 on success; non-zero on failure.
 */
int parse_arguments(int argc, char**argv, cmd_options_t *options, int openflag, int expected_nonargs)
{
	int ch;
	elxu_device_name_t devname = {0, NULL};

	static struct option opts[] = {
			/* Options */
			{"device",  required_argument, NULL, 'd'},
			{"path",  required_argument, NULL, 'p'},
			{"host",    required_argument, NULL,  CMD_HOSTNAME},
			{"file",    required_argument, NULL, 'f'},
			{"cc",      no_argument,       NULL,  CLEAR_COUNTER},
			{"clof",    no_argument,       NULL,  CLEAR_OVERFLOW_FLAG},
			{"clrc",    no_argument,       NULL,  CLEAR_ALL_COUNTER},
			{"wwnn", required_argument, NULL, WWNN},
			{"wwpn", required_argument, NULL, WWPN},
			{"initiator", no_argument, NULL, INITIATOR},
			{"target", no_argument, NULL, TARGET},
			{"fat", no_argument, NULL, FAT_DUMP},
			{"efd", no_argument, NULL, EFD_DUMP},
			{"ecd", no_argument, NULL, ECD_DUMP},
			{"fdb_dump", no_argument, NULL, FDB_DUMP},
			{"ecdtest", no_argument, NULL, TEST_DUMP},
			{"connection-handle", required_argument, NULL, CONNECTION_HANDLE},
			{"connection-id", required_argument, NULL, CONNECTION_ID},
			{"linkcfg", required_argument, NULL, LINKCFG},
			{"linkspeed", required_argument, NULL, LINKSPEED},
			{"linktopology", required_argument, NULL, LINKTOPOLOGY},
			{"bufsize", required_argument, NULL, BUFSIZE},
			{"saved",  no_argument, NULL,  SAVED},
			{"clrsaved",  no_argument, NULL,  CLRSAVED},
			{"profile-id",  required_argument, NULL,  PROFILE_ID},
			{"protocol", required_argument, NULL, PROTOCOL_NAME},
			{"wqes",  no_argument, NULL,  WQES},
			{"cqes",  no_argument, NULL,  CQES},
			{"rqes",  no_argument, NULL,  RQES},
			{"mqes",  no_argument, NULL,  MQES},
			{"eqes",  no_argument, NULL,  EQES},
			{"qentries",  required_argument, NULL,  QENTRIES},
			{"firmware-reset", no_argument, NULL, FIRMWARE_RESET},
			{"port-migration", no_argument, NULL, PORT_MIGRATION},
			{"sfp_diag_data", no_argument, NULL, SFP_DIAG_DATA},
			{"sfp_xceiver_data", no_argument, NULL, SFP_TRANSCEIVER},
			{"loopback_type", required_argument, NULL, LOOPBACK_TYPE},
			{"retry_count", required_argument, NULL, RETRY_COUNT},
			{"chap-type", required_argument, NULL, CHAP_TYPE},
			{"vlan-id", required_argument, NULL, VLAN_ID},
			{"hba_identifier", required_argument, NULL, HBA_ID},
			{"port_identifier", required_argument, NULL, PORT_ID},
			{"mode", required_argument, NULL, TRUNK_MODE},

			/* End of list marker */
			{0,0,0,0}
	};

	memset(options, 0, sizeof(*options));
	options->chap_type = OCS_CHAP_TYPE_INCOMING;
	options->vlan_id = 0;

	// Set defaults
	options->bufsize = 16 * 1024 * 1024;

	while ((ch = getopt_long(argc, argv, "f:d:", opts, NULL)) != -1) {

		switch (ch) {
		case 'f':
			options->file = strdup(optarg);
			break;
		case 'd':
			if (!isdigit(*optarg)) {
				fprintf(stderr, "Invalid device '%s': not a number\n", optarg);
				return -1;
			}
			devname.devidx = atoi(optarg);
			break;
		case CMD_HOSTNAME:
			options->hostname = strdup(optarg);
			devname.hostname = strdup(optarg);
			break;
		case 'p':
			break;
		case CLEAR_COUNTER:
			options->cc = 1;
			break;
		case SAVED:
			options->saved = 1;
			break;
		case WQES:
			options->wqes = 1;
			break;
		case CQES:
			options->cqes = 1;
			break;
		case MQES:
			options->mqes = 1;
			break;
		case RQES:
			options->rqes = 1;
			break;
		case EQES:
			options->eqes = 1;
			break;
		case QENTRIES:
			options->qentries = atoi(optarg);
			break;
		case CLRSAVED:
			options->clr_saved = 1;
			break;
		case CLEAR_OVERFLOW_FLAG:
			options->clof = 1;
			break;
		case CLEAR_ALL_COUNTER:
			options->clrc = 1;
			break;
		case WWNN:
			options->wwnn = strdup(optarg);
			break;
		case WWPN:
			options->wwpn = strdup(optarg);
			break;
		case INITIATOR:
			options->initiator = 1;
			break;
		case TARGET:
			options->target = 1;
			break;
		case CONNECTION_HANDLE:
			options->connection_handle = strdup(optarg);
			break;
		case CONNECTION_ID:
			options->connection_id = strdup(optarg);
			break;
		case TEST_DUMP:
			options->ecd_test = 1;
			break;
		case FAT_DUMP:
			options->fat = 1;
			break;
		case EFD_DUMP:
			options->efd = 1;
			break;
		case ECD_DUMP:
			options->ecd = 1;
			break;
		case FDB_DUMP:
			options->fdb_dump = 1;
			break;
		case SFP_DIAG_DATA:
			options->sfp_diag_data = 1;
			break;
		case SFP_TRANSCEIVER:
			options->sfp_xceiver_data = 1;
			break;
		case LINKCFG:
			strncpy(options->linkcfg, optarg, (sizeof(options->linkcfg) - 1));
			break;
		case LINKSPEED:
			strncpy(options->linkspeed, optarg, (sizeof(options->linkspeed) - 1));
			break;
		case LINKTOPOLOGY:
			strncpy(options->linktopology, optarg, (sizeof(options->linktopology) - 1));
			break;
		 case LOOPBACK_TYPE:
			options->loopback_type = atoi(optarg);
			break;
		 case RETRY_COUNT:
			options->retry_count = atoi(optarg);
			break;
		case PROFILE_ID:
			options->profile_id = strdup(optarg);
			break;
		case PROTOCOL_NAME:
			options->protocol_name = strdup(optarg);
			break;
		case BUFSIZE:
			{
				int optlen;
				char suffix;

				optlen = strlen(optarg);
				suffix = optarg[optlen-1];

				options->bufsize = atoi(optarg);
				if (toupper(suffix) == 'K') {
					options->bufsize *= 1024;
				}
				if (toupper(suffix) == 'M') {
					options->bufsize *= (1024 * 1024);
				}
			}
			break;
		case CHAP_TYPE:
			{
				if (0 == strncmp(optarg, OCS_CHAP_INCOMING, strlen(optarg))) {
					options->chap_type = OCS_CHAP_TYPE_INCOMING;
				} else if (0 == strncmp(optarg, OCS_CHAP_OUTGOING, strlen(optarg))) {
					options->chap_type = OCS_CHAP_TYPE_OUTGOING;
				} else {
					fprintf(stderr, "Invalid argument: chap type %s\n", optarg);
					return -1;
				}
			} 
			break;
		case VLAN_ID:
			{
				options->vlan_id = atoi(optarg);
			}
			break;
		case HBA_ID:
			options->hba_identifier = strdup(optarg);
			break;
		case PORT_ID:
			options->port_identifier = strdup(optarg);
			break;
		case TRUNK_MODE:
			options->trunk_mode = atoi(optarg);
			break;
		default:
			return -1;
		}
	}

	if ((argc - optind) > expected_nonargs) {
		fprintf(stderr, "Unexpected argument: %s\n", argv[optind + expected_nonargs]);
		return -1;
	}

	if (openflag) {
		options->device = elxu_open_device(&devname);

		if (options->device == NULL) {
			fprintf(stderr, "Unable to open device %d\n", devname.devidx);
			return -1;
		}
	}

	return 0;
}

/**
 * @brief  Print examples of commands.
 *
 * @par Description
 * This function is called as part of the "help" command.  It displays
 * examples of command usage.
 *
 * @return Returns nothing.
 *
 */
static void show_examples()
{
	printf ("Where <device> is an integer 0..n indicating which HBA to use.\n");
	printf ("If <device> is not specified it defaults to 0\n");
	printf ("\n");
	printf ("Examples:\n");
	printf ("Compare file data with  data stored in device 0 flash:\n");
	printf ("elxsdkutil cmp myfile -d 0\n");
	printf ("\n");
	printf ("Display device 0 EFD capabilities:\n");
	printf ("elxsdkutil efdc -d 0\n");
	printf ("\n");
	printf ("Generate dump on device 0 to be read by --efd command:\n");
	printf ("elxsdkutil gendump -d 0\n");
	printf ("\n");
	printf ("Save device 0 EFD data in the file myfile:\n");
	printf ("elxsdkutil efd -d 0 -f myfile\n");
	printf ("\n");
	printf ("Save device 0 FAT content in the file myfile:\n");
	printf ("elxsdkutil fat -d 0 -f myfile\n");
	printf ("\n");
	printf ("Display UFI file and image information for the file myfile:\n");
	printf ("elxsdkutil info myfile\n");
	printf ("\n");
	printf ("List HBA devices:\n");
	printf ("elxsdkutil list\n");
	printf ("\n");
	printf ("List device filesystem objects on device 0:\n");
	printf ("elxsdkutil objenum -d 0\n");
	printf ("\n");
	printf ("Copy an object instance \"/obj/inst\" into file the specified file:\n");
	printf ("elxsdkutil read /obj/inst -d 0 -f myfile\n");
	printf ("\n");
	printf ("Write firmware image to device 0:\n");
	printf ("elxsdkutil write myfile -d 0\n");
	printf ("\n");
	printf ("Print hexadecimal diagnostic information from the Transceiver:\n");
	printf ("elxsdkutil sfp -d 0\n");
	printf ("\n");
	printf ("Retrieve Core Dump image to file:\n");
	printf ("elxsdkutil ecd -d 0 -f myfile\n");
	printf ("\n");
	printf ("Create a vport on device 0:\n");
	printf ("elxsdkutil create-vport 20:00:00:00:c9:01:02:03 10:00:00:00:c9:01:02:03  --target\n");
	printf ("\n");
	printf ("Remove a vport from device 0:\n");
	printf ("elxsdkutil remove-vport 20:00:00:00:c9:01:02:03 10:00:00:00:c9:01:02:03\n");
	printf ("\n");
	printf ("List devices user space driver\n");
	printf ("elxsdkutil list --host localhost\n\n");

	printf ("\nVersion: %s\n", ELXU_VERSION);
}

/**
* @page cmd_line_parsing Command Line Parsing and Execution
*
* Command parsing and execution in the elxsdkutil is table driven. The
* elxu_commands.h file contains an array (cmd_table[]), which describes the available
* commands. Each entry in this table has the name of the command, a pointer to a
* command handler function, and help text that describes the function.
*
* @ref cmd_handler are located in elxu_commands.c. Each of these functions parses
* additional options as needed, validates the options given, then calls the appropriate
* function to execute the command.
*
* The main() function simply compares the first command line argument to each of the
* commands in the command table. If a match is found, then the corresponding handler
* function is called. If no match is found, then an error message is displayed.
*
* @section commands_list List of Commands with Associated Command Handlers
*
* <table class="dashboard">
* <tr><th>Command</th><th>Name</th><th>Command Handler</th></tr>
* <tr><td>@ref cmd_add_ip "add-ip"</td><td>Add IP</td><td>elxu_cmd_add_ip()</td></tr>
* <tr><td>@ref cmd_compare "cmp"</td><td>Compare</td><td>elxu_cmd_cmp()</td></tr>
* <tr><td>@ref cmd_connection_info "connection-info"</td><td>Connection Information</td><td>elxu_cmd_connection_info()</td></tr>
* <tr><td>@ref cmd_create_vport "create-vport"</td><td>Create VPort</td><td>elxu_cmd_create_vport()</td></tr>
* <tr><td>@ref cmd_driver_dump "driver-dump"</td><td>Driver Dump</td><td>elxu_cmd_driver_dump()</td></tr>
* <tr><td>@ref cmd_driver_info "driver-info"</td><td>Driver Information</td><td>elxu_cmd_driver_info()</td></tr>
* <tr><td>@ref cmd_dump "dump"</td><td>Firmware Dump</td><td>elxu_cmd_dump()</td></tr>
* <tr><td>@ref cmd_dump_to_host "dump-to-host"</td><td>Generate Dump to Host</td><td>elxu_cmd_dump_to_host()</td></tr>
* <tr><td>@ref cmd_efdc "efdc"</td><td>EFD Capabilities</td><td>elxu_cmd_efdc()</td></tr>
* <tr><td>@ref cmd_file_info "file-info"</td><td>File Information of UFI</td><td>elxu_cmd_file_info()</td></tr>
* <tr><td>@ref cmd_gendump "gendump"</td><td>Generate Dump</td><td>elxu_cmd_gendump()</td></tr>
* <tr><td>@ref cmd_help "help"</td><td>Help</td><td>elxu_cmd_help()</td></tr>
* <tr><td>@ref cmd_linkcfg_get "linkcfg-get"</td><td>Get Link Configuration</td><td>elxu_cmd_linkcfg_get()</td></tr>
* <tr><td>@ref cmd_linkcfg_set "linkcfg-get"</td><td>Set Link Configuration</td><td>elxu_cmd_linkcfg_set()</td></tr>
* <tr><td>@ref cmd_list "list"</td><td>List Adapters</td><td>elxu_cmd_list()</td></tr>
* <tr><td>@ref cmd_mgmt_info "mgmt-info"</td><td>Management Information</td><td>elxu_cmd_mgmt_info()</td></tr>
* <tr><td>@ref cmd_objenum "objenum"</td><td>Objects Enumerate</td><td>elxu_cmd_objenum()</td></tr>
* <tr><td>@ref cmd_read_link_status "read-link-status"</td><td>Read Link Status</td><td>elxu_cmd_read_link_status()</td></tr>
* <tr><td>@ref cmd_read_rev "read-rev"</td><td>Read Adapter Version</td><td>elxu_cmd_read_rev()</td>></tr>
* <tr><td>@ref cmd_read_status "read-status"</td><td>Read Device Status</td><td>elxu_cmd_read_status()</td></tr>
* <tr><td>@ref cmd_read "read"</td><td>Read Object File</td><td>elxu_cmd_read()</td></tr>
* <tr><td>@ref cmd_remove_vport "remove-vport"</td><td>Remove VPort</td><td>elxu_cmd_remove_vport()</td></tr>
* <tr><td>@ref cmd_set_mac "set-mac"</td><td>Set MAC Address</td><td>elxu_cmd_set_mac()</td></tr>
* <tr><td>@ref cmd_sfp "sfp"</td><td>SFP EEPROM Data</td><td>elxu_cmd_sfp()</td></tr>
* <tr><td>@ref cmd_show_ips "show-ips"</td><td>Show IPs</td><td>elxu_cmd_show_ips()</td></tr>
* <tr><td>@ref cmd_show_mac "show-mac"</td><td>Show MAC</td><td>elxu_cmd_show_mac()</td></tr>
* <tr><td>@ref cmd_version "version"</td><td>Version of Program</td><td>elxu_cmd_version()</td></tr>
* <tr><td>@ref cmd_write "write"</td><td>Write Firmware Image</td><td>elxu_cmd_write()</td></tr>
* </table><br>
*/