elxu_commands.c

Go to the documentation of this file.

/*
 * 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>
*/