uaputl.c

/** @file  uaputl.c
 *
 *  @brief Program to send AP commands to the driver/firmware of the uAP
 *         driver.
 * 
 * Copyright (C) 2008-2009, Marvell International Ltd. 
 *
 * This software file (the "File") is distributed by Marvell International 
 * Ltd. under the terms of the GNU General Public License Version 2, June 1991 
 * (the "License").  You may use, redistribute and/or modify this File in 
 * accordance with the terms and conditions of the License, a copy of which 
 * is available along with the File in the gpl.txt file or by writing to 
 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
 * 02111-1307 or on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
 *
 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE 
 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE 
 * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about 
 * this warranty disclaimer.
 *
 */
/****************************************************************************
Change log:
    03/01/08: Initial creation
****************************************************************************/

/****************************************************************************
        Header files
****************************************************************************/
#include <stdarg.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <stdio.h>
#include <getopt.h>
#include <netinet/in.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <linux/if.h>
#include <sys/ioctl.h>
#include <errno.h>
#include "uaputl.h"
#include "uapcmd.h"

/****************************************************************************
        Definitions
****************************************************************************/
/** Default debug level */
int debug_level = MSG_NONE;

/** Enable or disable debug outputs */
#define DEBUG   1

/** Convert character to integer */
#define CHAR2INT(x) (((x) >= 'A') ? ((x) - 'A' + 10) : ((x) - '0'))

/** Default 80211d domain configuration file */
#define DEFAULT_80211D_CONF_FILE "/usr/share/uaputl/80211d_domain.conf"

/****************************************************************************
        Global variables
****************************************************************************/
/** Device name */
static char dev_name[IFNAMSIZ + 1];
/** option for cmd */
struct option cmd_options[] = {
    {"help", 0, 0, 'h'},
    {0, 0, 0, 0}
};

/****************************************************************************
        Local functions
****************************************************************************/
/**
 *    @brief convert char to hex integer
 *   
 *    @param chr          char
 *    @return             hex integer
 */
unsigned char
hexc2bin(char chr)
{
    if (chr >= '0' && chr <= '9')
        chr -= '0';
    else if (chr >= 'A' && chr <= 'F')
        chr -= ('A' - 10);
    else if (chr >= 'a' && chr <= 'f')
        chr -= ('a' - 10);

    return chr;
}

/** 
 *  @brief check protocol is valid or not
 *
 *  @param protocol    	     protocol
 *
 *  @return         UAP_SUCCESS or UAP_FAILURE
 */
int
is_protocol_valid(int protocol)
{
    int ret = UAP_FAILURE;
    switch (protocol) {
    case PROTOCOL_NO_SECURITY:
    case PROTOCOL_STATIC_WEP:
    case PROTOCOL_WPA:
    case PROTOCOL_WPA2:
    case PROTOCOL_WPA2_MIXED:
        ret = UAP_SUCCESS;
        break;
    default:
        printf("ERR: Invalid Protocol: %d\n", protocol);
        break;
    }
    return ret;
}

/**
 *  @brief Function to check valid rate
 *
 *                  
 *  @param  rate    rate to verify
 *
 *  return 	    UAP_SUCCESS or UAP_FAILURE	
 **/
int
is_rate_valid(int rate)
{
    int ret = UAP_SUCCESS;
    switch (rate) {
    case 2:
    case 4:
    case 11:
    case 22:
    case 12:
    case 18:
    case 24:
    case 48:
    case 72:
    case 96:
    case 108:
    case 36:
        break;
    default:
        ret = UAP_FAILURE;
        break;
    }
    return ret;
}

/**
 *  @brief  detects duplicates rate in array of strings
 *          Note that 0x82 and 0x2 are same for rate
 *
 *  @param  argc    number of elements
 *  @param  argv    array of strings
 *  @return UAP_FAILURE or UAP_SUCCESS
 */
inline int
has_dup_rate(int argc, char *argv[])
{
    int i, j;
    /* Check for duplicate */
    for (i = 0; i < (argc - 1); i++) {
        for (j = i + 1; j < argc; j++) {
            if ((A2HEXDECIMAL(argv[i]) & ~BASIC_RATE_SET_BIT) ==
                (A2HEXDECIMAL(argv[j]) & ~BASIC_RATE_SET_BIT)) {
                return UAP_FAILURE;
            }
        }
    }
    return UAP_SUCCESS;
}

/**
 *  @brief Check for mandatory rates
 *
 *
 * 2, 4, 11, 22 must be present 
 *
 * 6 12 and 24 must be present for ofdm
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         UAP_FAILURE or UAP_SUCCESS
 *
 */
int
check_mandatory_rates(int argc, char **argv)
{
    int i;
    int tmp;
    u32 rate_bitmap = 0;
    int ofdm_enable = 0;
#define BITMAP_RATE_1M         0x01
#define BITMAP_RATE_2M         0x02
#define BITMAP_RATE_5_5M       0x04
#define BITMAP_RATE_11M        0x8
#define B_RATE_MANDATORY       0x0f
#define BITMAP_RATE_6M         0x10
#define BITMAP_RATE_12M        0x20
#define BITMAP_RATE_24M        0x40
#define G_RATE_MANDATORY        0x70
    for (i = 0; i < argc; i++) {
        tmp = (A2HEXDECIMAL(argv[i]) & ~BASIC_RATE_SET_BIT);
        switch (tmp) {
        case 2:
            rate_bitmap |= BITMAP_RATE_1M;
            break;
        case 4:
            rate_bitmap |= BITMAP_RATE_2M;
            break;
        case 11:
            rate_bitmap |= BITMAP_RATE_5_5M;
            break;
        case 22:
            rate_bitmap |= BITMAP_RATE_11M;
            break;
        case 12:
            ofdm_enable = 1;
            rate_bitmap |= BITMAP_RATE_6M;
            break;
        case 24:
            ofdm_enable = 1;
            rate_bitmap |= BITMAP_RATE_12M;
            break;
        case 48:
            ofdm_enable = 1;
            rate_bitmap |= BITMAP_RATE_24M;
            break;
        case 18:
        case 36:
        case 72:
        case 96:
        case 108:
            ofdm_enable = 1;
            break;
        }
    }
    if ((rate_bitmap & B_RATE_MANDATORY) != B_RATE_MANDATORY) {
        printf("Basic Rates 2, 4, 11 and 22 (500K units) \n"
               "must be present in basic or non-basic rates\n");
        return UAP_FAILURE;
    }
    if (ofdm_enable && ((rate_bitmap & G_RATE_MANDATORY) != G_RATE_MANDATORY)) {
        printf("OFDM Rates 12, 24 and 48 ( 500Kb units)\n"
               "must be present in basic or non-basic rates\n");
        return UAP_FAILURE;
    }
    return UAP_SUCCESS;
}

/**
 *  @brief  detects duplicates channel in array of strings
 *          
 *  @param  argc    number of elements
 *  @param  argv    array of strings
 *  @return UAP_FAILURE or UAP_SUCCESS
 */
inline int
has_dup_channel(int argc, char *argv[])
{
    int i, j;
    /* Check for duplicate */
    for (i = 0; i < (argc - 1); i++) {
        for (j = i + 1; j < argc; j++) {
            if (atoi(argv[i]) == atoi(argv[j])) {
                return UAP_FAILURE;
            }
        }
    }
    return UAP_SUCCESS;
}

/** 
 *    @brief convert string to hex integer
 *  
 *    @param s            A pointer string buffer
 *    @return             hex integer
 */
unsigned int
a2hex(char *s)
{
    unsigned int val = 0;
    if (!strncasecmp("0x", s, 2)) {
        s += 2;
    }
    while (*s && isxdigit(*s)) {
        val = (val << 4) + hexc2bin(*s++);
    }
    return val;
}

/** 
 *  @brief Dump hex data
 *
 *  @param prompt	A pointer prompt buffer
 *  @param p		A pointer to data buffer
 *  @param len		the len of data buffer
 *  @param delim	delim char
 *  @return            	None
 */
void
hexdump_data(char *prompt, void *p, int len, char delim)
{
    int i;
    unsigned char *s = p;

    if (prompt) {
        printf("%s: len=%d\n", prompt, (int) len);
    }
    for (i = 0; i < len; i++) {
        if (i != len - 1)
            printf("%02x%c", *s++, delim);
        else
            printf("%02x\n", *s);
        if ((i + 1) % 16 == 0)
            printf("\n");
    }
    printf("\n");
}

#if DEBUG
/** 
 * @brief           conditional printf
 *
 * @param level     severity level of the message
 * @param fmt       printf format string, followed by optional arguments
 */
void
uap_printf(int level, char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    if (level <= debug_level) {
        vprintf(fmt, ap);
    }
    va_end(ap);
}

/** 
 *  @brief Dump hex data
 *
 *  @param prompt	A pointer prompt buffer
 *  @param p		A pointer to data buffer
 *  @param len		the len of data buffer
 *  @param delim	delim char
 *  @return            	None
 */
void
hexdump(char *prompt, void *p, int len, char delim)
{
    if (debug_level < MSG_ALL)
        return;
    hexdump_data(prompt, p, len, delim);
}
#endif

/** 
 *  @brief      Hex to number 
 *
 *  @param c    Hex value
 *  @return     Integer value or -1
 */
int
hex2num(char c)
{
    if (c >= '0' && c <= '9')
        return c - '0';
    if (c >= 'a' && c <= 'f')
        return c - 'a' + 10;
    if (c >= 'A' && c <= 'F')
        return c - 'A' + 10;

    return -1;
}

/**
 *  @brief Show usage information for the sys_info command
 *
 *  $return         N/A
 */
void
print_sys_info_usage(void)
{
    printf("\nUsage : sys_info\n");
    return;
}

/**
 *  @brief Parse domain file for country information
 *
 *  @param country  Country name
 *  @param sub_bands band information 
 *  @return number of band/ UAP_FAILURE 
 */
u8
parse_domain_file(char *country, IEEEtypes_SubbandSet_t * sub_bands)
{
    FILE *fp;
    char str[64];
    char domain_name[40];
    int cflag = 0;
    int dflag = 0;
    int found = 0;
    int j = -1, reset_j = 0;
    u8 no_of_sub_band = 0;
    char third;
    char country2[3];

    fp = fopen(DEFAULT_80211D_CONF_FILE, "r");
    if (fp == NULL) {
        printf("File opening Error\n");
        return UAP_FAILURE;
    }

    strncpy((char *) country2, country, 2);
    country2[2] = '\0';
    third = country[2];

    /** 
     * Search specific domain name
     */
    while (!feof(fp)) {
        fscanf(fp, "%s", str);
        if (cflag) {
            strcpy(domain_name, str);
            cflag = 0;
        }
        if (!strcmp(str, "COUNTRY:")) {
            /** store next string to domain_name */
            cflag = 1;
        }

        if (!strcmp(str, country2)) {
            /** Country is matched ;)*/
            if (third && !((third == 'I') || (third == 'O') || (third == ' ')))
                found = 0;
            else
                found = 1;
            break;
        }
    }

    if (!found) {
        printf("No match found for Country = %s in the "DEFAULT_80211D_CONF_FILE "\n",
               country);
        fclose(fp);
        found = 0;
        return UAP_FAILURE;
    }

    /**
     * Search domain specific information
     */
    while (!feof(fp)) {
        fscanf(fp, "%s", str);

        if (feof(fp) || (dflag && !strcmp(str, "DOMAIN:"))) {
            break;
        }

        if (dflag) {
            j++;
            if (strchr(str, ','))
                reset_j = 1;

            strcpy(str, strtok(str, ", "));

            if (str == NULL) {
                if (reset_j) {
                    j = -1;
                    reset_j = 0;
                }
                continue;
            }

            if (IS_HEX_OR_DIGIT(str) == UAP_FAILURE) {
                printf("ERR: Only Number values are allowed\n");
                fclose(fp);
                return UAP_FAILURE;
            }

            switch (j) {
            case 0:
                sub_bands[no_of_sub_band].FirstChan = (u8) A2HEXDECIMAL(str);
                break;
            case 1:
                sub_bands[no_of_sub_band].NoOfChan = (u8) A2HEXDECIMAL(str);
                break;
            case 2:
                sub_bands[no_of_sub_band++].MaxTxPwr = (u8) A2HEXDECIMAL(str);
                break;
            default:
                printf("ERR: Incorrect " DEFAULT_80211D_CONF_FILE " file\n");
                fclose(fp);
                return UAP_FAILURE;
            }

            if (reset_j) {
                j = -1;
                reset_j = 0;
            }
        }

        if (cflag && !strcmp(str, domain_name)) {
            /* Followed will be the band details */
            cflag = 0;
            dflag = 1;
        }
        if (!dflag && !strcmp(str, "DOMAIN:")) {
            cflag = 1;
        }
    }
    fclose(fp);
    return (no_of_sub_band);

}

/** 
 *
 *  @brief Set/Get SNMP MIB
 *
 *  @param action 0-GET 1-SET
 *  @param oid    oid
 *  @param size   size of oid value
 *  @param oid_buf  oid value
 *  @return UAP_FAILURE or UAP_SUCCESS
 *
 */
int
sg_snmp_mib(u16 action, u16 oid, u16 size, u8 * oid_buf)
{
    APCMDBUF_SNMP_MIB *cmd_buf = NULL;
    TLVBUF_HEADER *tlv = NULL;
    int ret = UAP_FAILURE;
    u8 *buf = NULL;
    u16 buf_len;
    u16 cmd_len;
    int i;

    buf_len = sizeof(APCMDBUF_SNMP_MIB) + sizeof(TLVBUF_HEADER) + size;
    buf = (u8 *) malloc(buf_len);
    if (!buf) {
        printf("ERR:Cannot allocate buffer from command!\n");
        return ret;
    }
    bzero((char *) buf, buf_len);

    /* Locate Headers */
    cmd_buf = (APCMDBUF_SNMP_MIB *) buf;
    tlv = (TLVBUF_HEADER *) (buf + sizeof(APCMDBUF_SNMP_MIB));
    cmd_buf->Size = buf_len - BUF_HEADER_SIZE;
    cmd_buf->Result = 0;
    cmd_buf->SeqNum = 0;
    cmd_buf->CmdCode = HostCmd_SNMP_MIB;

    tlv->Type = uap_cpu_to_le16(oid);
    tlv->Len = uap_cpu_to_le16(size);
    for (i = 0; action && (i < size); i++) {
        tlv->Data[i] = oid_buf[i];
    }

    cmd_buf->Action = uap_cpu_to_le16(action);
    cmd_len = buf_len;
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, buf_len);
    if (ret == UAP_SUCCESS) {
        if (cmd_buf->Result == CMD_SUCCESS) {
            if (!action) {
                /** Reloacte the headers */
                tlv =
                    (TLVBUF_HEADER *) ((u8 *) cmd_buf +
                                       sizeof(APCMDBUF_SNMP_MIB));
                for (i = 0; i < MIN(uap_le16_to_cpu(tlv->Len), size); i++) {
                    oid_buf[i] = tlv->Data[i];
                }
            }
            ret = UAP_SUCCESS;
        } else {
            printf("ERR:Command Response incorrect!\n");
            ret = UAP_FAILURE;
        }
    } else {
        printf("ERR:Command sending failed!\n");
    }
    free(buf);
    return ret;
}

/** 
 *  @brief Creates a sys_info request and sends to the driver
 *
 *  Usage: "sys_info"
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         N/A
 */
void
apcmd_sys_info(int argc, char *argv[])
{
    APCMDBUF_SYS_INFO_REQUEST *cmd_buf = NULL;
    APCMDBUF_SYS_INFO_RESPONSE *response_buf = NULL;
    u8 *buf = NULL;
    u16 cmd_len;
    u16 buf_len;
    int ret = UAP_FAILURE;
    int opt;

    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_sys_info_usage();
            return;
        }
    }
    argc -= optind;
    argv += optind;

    /* Check arguments */
    if (argc != 0) {
        printf("ERR:Too many arguments.\n");
        print_sys_info_usage();
        return;
    }

    buf_len =
        (sizeof(APCMDBUF_SYS_INFO_REQUEST) >=
         sizeof(APCMDBUF_SYS_INFO_RESPONSE)) ? sizeof(APCMDBUF_SYS_INFO_REQUEST)
        : sizeof(APCMDBUF_SYS_INFO_RESPONSE);

    /* alloc buf for command */
    buf = (u8 *) malloc(buf_len);

    if (!buf) {
        printf("ERR:Cannot allocate buffer from command!\n");
        return;
    }
    bzero((char *) buf, buf_len);

    /* Locate headers */
    cmd_len = sizeof(APCMDBUF_SYS_INFO_REQUEST);
    cmd_buf = (APCMDBUF_SYS_INFO_REQUEST *) buf;
    response_buf = (APCMDBUF_SYS_INFO_RESPONSE *) buf;

    /* Fill the command buffer */
    cmd_buf->CmdCode = APCMD_SYS_INFO;
    cmd_buf->Size = cmd_len;
    cmd_buf->SeqNum = 0;
    cmd_buf->Result = 0;

    /* Send the command */
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, buf_len);

    /* Process response */
    if (ret == UAP_SUCCESS) {
        /* Verify response */
        if (response_buf->CmdCode != (APCMD_SYS_INFO | APCMD_RESP_CHECK)) {
            printf("ERR:Corrupted response!\n");
            free(buf);
            return;
        }
        /* Print response */
        if (response_buf->Result == CMD_SUCCESS) {
            printf("System information = %s\n", response_buf->SysInfo);
        } else {
            printf("ERR:Could not retrieve system information!\n");
        }
    } else {
        printf("ERR:Command sending failed!\n");
    }

    free(buf);
    return;
}

/**
 *  @brief Show usage information for the powermode command
 *
 *  $return         N/A
 */
void
print_power_mode_usage(void)
{
    printf
        ("\nUsage : powermode [MODE] [SLEEP_PARAM=1 CTRL MIN_SLEEP MAX_SLEEP]");
    printf("\n                  [INACT_PARAM=2 INACTTO MIN_AWAKE MAX_AWAKE]");
    printf("\nOptions: MODE :     0 - disable power mode");
    printf("\n                    1 - periodic DTIM power save mode");
    printf("\n                    2 - inactivity based power save mode");
    printf("\n   SLEEP_PARAM:");
    printf
        ("\n        CTRL:  0 - disable CTS2Self protection frame Tx before PS");
    printf
        ("\n               1 - enable CTS2Self protection frame Tx before PS");
    printf("\n        MIN_SLEEP: Minimum sleep duration in microseconds");
    printf("\n        MAX_SLEEP: Maximum sleep duration in miroseconds");
    printf("\n   INACT_PARAM: (only for inactivity based power save mode)");
    printf("\n          INACTTO: Inactivity timeout in miroseconds");
    printf("\n        MIN_AWAKE: Minimum awake duration in microseconds");
    printf("\n        MAX_AWAKE: Maximum awake duration in microseconds");
    printf("\n          empty - get current power mode\n");
    return;
}

/** 
 *  @brief Set/get power mode 
 *
 *  @param pm      A pointer to ps_mgmt structure
 *  @return         N/A
 */
void
send_power_mode_ioctl(ps_mgmt * pm)
{
    struct ifreq ifr;
    s32 sockfd;

    /* Open socket */
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        printf("ERR:Cannot open socket\n");
        return;
    }
    /* Initialize the ifr structure */
    memset(&ifr, 0, sizeof(ifr));
    strncpy(ifr.ifr_ifrn.ifrn_name, dev_name, strlen(dev_name));
    ifr.ifr_ifru.ifru_data = (void *) pm;
    /* Perform ioctl */
    errno = 0;
    if (ioctl(sockfd, UAP_POWER_MODE, &ifr)) {
        perror("");
        printf("ERR:UAP_POWER_MODE is not supported by %s\n", dev_name);
        return;
    }
    switch (pm->ps_mode) {
    case 0:
        printf("power mode = Disabled\n");
        break;
    case 1:
        printf("power mode = Periodic DTIM PS\n");
        break;
    case 2:
        printf("power mode = Inactivity based PS \n");
        break;
    }
    if (pm->flags & PS_FLAG_SLEEP_PARAM) {
        printf("Sleep param:\n");
        printf("\tctrl_bitmap=%d\n", (int) pm->sleep_param.ctrl_bitmap);
        printf("\tmin_sleep=%d us\n", (int) pm->sleep_param.min_sleep);
        printf("\tmax_sleep=%d us\n", (int) pm->sleep_param.max_sleep);
    }
    if (pm->flags & PS_FLAG_INACT_SLEEP_PARAM) {
        printf("Inactivity sleep param:\n");
        printf("\tinactivity_to=%d us\n", (int) pm->inact_param.inactivity_to);
        printf("\tmin_awake=%d us\n", (int) pm->inact_param.min_awake);
        printf("\tmax_awake=%d us\n", (int) pm->inact_param.max_awake);
    }
    /* Close socket */
    close(sockfd);
    return;
}

/** 
 *  @brief Creates power mode request and send to driver
 *   and sends to the driver
 *
 *   Usage: "Usage : powermode [MODE]"
 *
 *   Options: MODE :     0 - disable power mode
 *                       1 - enable power mode
 *            		 2 - get current power mode                         
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         N/A
 */
void
apcmd_power_mode(int argc, char *argv[])
{
    int opt;
    ps_mgmt pm;
    int type = 0;
    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_power_mode_usage();
            return;
        }
    }
    argc -= optind;
    argv += optind;

    memset(&pm, 0, sizeof(ps_mgmt));
    /* Check arguments */
    if ((argc > 9) ||
        ((argc != 0) && (argc != 1) && (argc != 5) && (argc != 9))) {
        printf("ERR:wrong arguments.\n");
        print_power_mode_usage();
        return;
    }

    if (argc) {
        if ((ISDIGIT(argv[0]) == 0) || (atoi(argv[0]) < 0) ||
            (atoi(argv[0]) > 2)) {
            printf
                ("ERR:Illegal power mode %s. Must be either '0' '1' or '2'.\n",
                 argv[0]);
            print_power_mode_usage();
            return;
        }
        pm.flags = PS_FLAG_PS_MODE;
        pm.ps_mode = atoi(argv[0]);
        if ((pm.ps_mode == PS_MODE_DISABLE) && (argc > 1)) {
            printf("ERR: Illegal parameter for disable power mode\n");
            print_power_mode_usage();
            return;
        }
        if ((pm.ps_mode != PS_MODE_INACTIVITY) && (argc > 5)) {
            printf("ERR: Illegal parameter\n");
            print_power_mode_usage();
            return;
        }
        if (argc >= 5) {
            if ((ISDIGIT(argv[1]) == 0) || (atoi(argv[1]) < 1) ||
                (atoi(argv[1]) > 2)) {
                printf
                    ("ERR:Illegal parameter type %s. Must be either '1' or '2'.\n",
                     argv[1]);
                print_power_mode_usage();
                return;
            }
            type = atoi(argv[1]);
            if ((type == INACTIVITY_SLEEP_PARAMETER) &&
                (pm.ps_mode != PS_MODE_INACTIVITY)) {
                printf
                    ("ERR: inactivity sleep parameter only valid for inactivity power save mode\n");
                print_power_mode_usage();
                return;
            }
            if (type == SLEEP_PARAMETER) {
                if ((ISDIGIT(argv[2]) == 0) || (atoi(argv[2]) < 0) ||
                    (atoi(argv[2]) > 1)) {
                    printf
                        ("ERR:Illegal ctrl bitmap = %s. Must be either '0' or '1'.\n",
                         argv[2]);
                    print_power_mode_usage();
                    return;
                }
                pm.flags |= PS_FLAG_SLEEP_PARAM;
                pm.sleep_param.ctrl_bitmap = atoi(argv[2]);
                if ((ISDIGIT(argv[3]) == 0) || (ISDIGIT(argv[4]) == 0)) {
                    printf("ERR:Illegal parameter\n");
                    print_power_mode_usage();
                    return;
                }
                pm.sleep_param.min_sleep = atoi(argv[3]);
                pm.sleep_param.max_sleep = atoi(argv[4]);
                if (pm.sleep_param.min_sleep > pm.sleep_param.max_sleep) {
                    printf
                        ("ERR: MIN_SLEEP value should be less than or equal to MAX_SLEEP\n");
                    return;
                }
                if (pm.sleep_param.min_sleep < PS_SLEEP_PARAM_MIN ||
                    ((pm.sleep_param.max_sleep > PS_SLEEP_PARAM_MAX) &&
                     pm.sleep_param.ctrl_bitmap)) {
                    printf
                        ("ERR: Incorrect value of sleep period. Please check README\n");
                    return;
                }
            } else {
                if ((ISDIGIT(argv[2]) == 0) || (ISDIGIT(argv[3]) == 0) ||
                    (ISDIGIT(argv[4]) == 0)) {
                    printf("ERR:Illegal parameter\n");
                    print_power_mode_usage();
                    return;
                }
                pm.flags |= PS_FLAG_INACT_SLEEP_PARAM;
                pm.inact_param.inactivity_to = atoi(argv[2]);
                pm.inact_param.min_awake = atoi(argv[3]);
                pm.inact_param.max_awake = atoi(argv[4]);
                if (pm.inact_param.min_awake > pm.inact_param.max_awake) {
                    printf
                        ("ERR: MIN_AWAKE value should be less than or equal to MAX_AWAKE\n");
                    return;
                }
                if (pm.inact_param.min_awake < PS_AWAKE_PERIOD_MIN) {
                    printf("ERR: Incorrect value of MIN_AWAKE period.\n");
                    return;
                }
            }
        }
        if (argc == 9) {
            if ((ISDIGIT(argv[5]) == 0) || (atoi(argv[5]) < 1) ||
                (atoi(argv[5]) > 2)) {
                printf
                    ("ERR:Illegal parameter type %s. Must be either '1' or '2'.\n",
                     argv[5]);
                print_power_mode_usage();
                return;
            }
            if (type == atoi(argv[5])) {
                printf("ERR: Duplicate parameter type %s.\n", argv[5]);
                print_power_mode_usage();
                return;
            }
            type = atoi(argv[5]);
            if (type == SLEEP_PARAMETER) {
                if ((ISDIGIT(argv[6]) == 0) || (atoi(argv[6]) < 0) ||
                    (atoi(argv[6]) > 1)) {
                    printf
                        ("ERR:Illegal ctrl bitmap = %s. Must be either '0' or '1'.\n",
                         argv[6]);
                    print_power_mode_usage();
                    return;
                }
                pm.flags |= PS_FLAG_SLEEP_PARAM;
                pm.sleep_param.ctrl_bitmap = atoi(argv[6]);
                if ((ISDIGIT(argv[7]) == 0) || (ISDIGIT(argv[8]) == 0)) {
                    printf("ERR:Illegal parameter\n");
                    print_power_mode_usage();
                    return;
                }
                pm.sleep_param.min_sleep = atoi(argv[7]);
                pm.sleep_param.max_sleep = atoi(argv[8]);
                if (pm.sleep_param.min_sleep > pm.sleep_param.max_sleep) {
                    printf
                        ("ERR: MIN_SLEEP value should be less than or equal to MAX_SLEEP\n");
                    return;
                }
                if (pm.sleep_param.min_sleep < PS_SLEEP_PARAM_MIN ||
                    ((pm.sleep_param.max_sleep > PS_SLEEP_PARAM_MAX) &&
                     pm.sleep_param.ctrl_bitmap)) {
                    printf
                        ("ERR: Incorrect value of sleep period. Please check README\n");
                    return;
                }
            } else {
                if ((ISDIGIT(argv[6]) == 0) || (ISDIGIT(argv[7]) == 0) ||
                    (ISDIGIT(argv[8]) == 0)) {
                    printf("ERR:Illegal parameter\n");
                    print_power_mode_usage();
                    return;
                }
                pm.flags |= PS_FLAG_INACT_SLEEP_PARAM;
                pm.inact_param.inactivity_to = atoi(argv[6]);
                pm.inact_param.min_awake = atoi(argv[7]);
                pm.inact_param.max_awake = atoi(argv[8]);
                if (pm.inact_param.min_awake > pm.inact_param.max_awake) {
                    printf
                        ("ERR: MIN_AWAKE value should be less than or equal to MAX_AWAKE\n");
                    return;
                }
                if (pm.inact_param.min_awake < PS_AWAKE_PERIOD_MIN) {
                    printf("ERR: Incorrect value of MIN_AWAKE period.\n");
                    return;
                }
            }
        }
    }
    send_power_mode_ioctl(&pm);
    return;
}

/**
 *  @brief Show usage information for the sys_reset command
 *
 *  $return         N/A
 */
void
print_sys_reset_usage(void)
{
    printf("\nUsage : sys_reset\n");
    return;
}

/** 
 *  @brief Creates a sys_reset request and sends to the driver
 *
 *  Usage: "sys_reset"
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         N/A
 */
void
apcmd_sys_reset(int argc, char *argv[])
{
    APCMDBUF_SYS_RESET *cmd_buf = NULL;
    u8 *buffer = NULL;
    u16 cmd_len;
    int ret = UAP_FAILURE;
    int opt;
    ps_mgmt pm;

    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_sys_reset_usage();
            return;
        }
    }
    argc -= optind;
    argv += optind;

    /* Check arguments */
    if (argc != 0) {
        printf("ERR:Too many arguments.\n");
        print_sys_reset_usage();
        return;
    }

    memset(&pm, 0, sizeof(ps_mgmt));
    pm.flags = PS_FLAG_PS_MODE;
    pm.ps_mode = PS_MODE_DISABLE;
    send_power_mode_ioctl(&pm);

    /* Initialize the command length */
    cmd_len = sizeof(APCMDBUF_SYS_RESET);

    /* Initialize the command buffer */
    buffer = (u8 *) malloc(cmd_len);

    if (!buffer) {
        printf("ERR:Cannot allocate buffer for command!\n");
        return;
    }
    bzero((char *) buffer, cmd_len);

    /* Locate headers */
    cmd_buf = (APCMDBUF_SYS_RESET *) buffer;

    /* Fill the command buffer */
    cmd_buf->CmdCode = APCMD_SYS_RESET;
    cmd_buf->Size = cmd_len;
    cmd_buf->SeqNum = 0;
    cmd_buf->Result = 0;

    /* Send the command */
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, cmd_len);

    /* Process response */
    if (ret == UAP_SUCCESS) {
        /* Verify response */
        if (cmd_buf->CmdCode != (APCMD_SYS_RESET | APCMD_RESP_CHECK)) {
            printf("ERR:Corrupted response!\n");
            free(buffer);
            return;
        }
        /* Print response */
        if (cmd_buf->Result == CMD_SUCCESS) {
            printf("System reset successful!\n");
        } else {
            printf("ERR:Could not reset system!\n");
        }
    } else {
        printf("ERR:Command sending failed!\n");
    }
    if (buffer)
        free(buffer);
    return;
}

/**
 *  @brief Show usage information for the bss_start command
 *
 *  $return         N/A
 */
void
print_bss_start_usage(void)
{
    printf("\nUsage : bss_start\n");
    return;
}

/** 
 *  @brief Creates a BSS start request and sends to the driver
 *
 *   Usage: "bss_start"
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         N/A
 */
void
apcmd_bss_start(int argc, char *argv[])
{
    APCMDBUF_BSS_START *cmd_buf = NULL;
    u8 *buffer = NULL;
    u16 cmd_len;
    int ret = UAP_FAILURE;
    int opt;

    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_bss_start_usage();
            return;
        }
    }
    argc -= optind;
    argv += optind;

    /* Check arguments */
    if (argc != 0) {
        printf("ERR:Too many arguments.\n");
        print_bss_start_usage();
        return;
    }

    /* Initialize the command length */
    cmd_len = sizeof(APCMDBUF_BSS_START);

    /* Initialize the command buffer */
    buffer = (u8 *) malloc(cmd_len);

    if (!buffer) {
        printf("ERR:Cannot allocate buffer for command!\n");
        return;
    }
    bzero((char *) buffer, cmd_len);

    /* Locate headers */
    cmd_buf = (APCMDBUF_BSS_START *) buffer;

    /* Fill the command buffer */
    cmd_buf->CmdCode = APCMD_BSS_START;
    cmd_buf->Size = cmd_len;
    cmd_buf->SeqNum = 0;
    cmd_buf->Result = 0;

    /* Send the command */
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, cmd_len);

    /* Process response */
    if (ret == UAP_SUCCESS) {
        /* Verify response */
        if (cmd_buf->CmdCode != (APCMD_BSS_START | APCMD_RESP_CHECK)) {
            printf("ERR:Corrupted response!\n");
            free(buffer);
            return;
        }

        /* Print response */
        if (cmd_buf->Result == CMD_SUCCESS) {
            printf("BSS started!\n");
        } else if (cmd_buf->Result == BSS_FAILURE_START_INVAL) {
            printf("ERR:Could not start BSS! Invalid BSS parameters.\n");
        } else if (cmd_buf->Result == BSS_FAILURE_START_REDUNDANT) {
            printf("ERR:Could not start BSS! BSS already started.\n");
        } else {
            printf("ERR:Could not start BSS!\n");
        }
    } else {
        printf("ERR:Command sending failed!\n");
    }
    if (buffer)
        free(buffer);
    return;
}

/**
 *  @brief Show usage information for the bss_stop command
 *
 *  $return         N/A
 */
void
print_bss_stop_usage(void)
{
    printf("\nUsage : bss_stop\n");
    return;
}

/** 
 *  @brief Creates a BSS stop request and sends to the driver
 *
 *   Usage: "bss_stop"
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         N/A
 */
void
apcmd_bss_stop(int argc, char *argv[])
{
    APCMDBUF_BSS_STOP *cmd_buf = NULL;
    u8 *buffer = NULL;
    u16 cmd_len;
    int ret = UAP_FAILURE;
    int opt;

    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_bss_stop_usage();
            return;
        }
    }
    argc -= optind;
    argv += optind;             /* Check arguments */

    if (argc != 0) {
        printf("ERR:Too many arguments.\n");
        print_bss_stop_usage();
    }

    /* Initialize the command length */
    cmd_len = sizeof(APCMDBUF_BSS_STOP);

    /* Initialize the command buffer */
    buffer = (u8 *) malloc(cmd_len);

    if (!buffer) {
        printf("ERR:Cannot allocate buffer for command!\n");
        return;
    }
    bzero((char *) buffer, cmd_len);

    /* Locate headers */
    cmd_buf = (APCMDBUF_BSS_STOP *) buffer;

    /* Fill the command buffer */
    cmd_buf->CmdCode = APCMD_BSS_STOP;
    cmd_buf->Size = cmd_len;
    cmd_buf->SeqNum = 0;
    cmd_buf->Result = 0;

    /* Send the command */
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, cmd_len);

    /* Process response */
    if (ret == UAP_SUCCESS) {
        /* Verify response */
        if (cmd_buf->CmdCode != (APCMD_BSS_STOP | APCMD_RESP_CHECK)) {
            printf("ERR:Corrupted response!\n");
            free(buffer);
            return;
        }

        /* Print response */
        if (cmd_buf->Result == CMD_SUCCESS) {
            printf("BSS stopped!\n");
        } else if (cmd_buf->Result == BSS_FAILURE_STOP_REDUNDANT) {
            printf("ERR:Could not stop BSS! BSS already stopped.\n");
        } else if (cmd_buf->Result == BSS_FAILURE_STOP_INVAL) {
            printf("ERR:Could not stop BSS! No active BSS.\n");
        } else {
            printf("ERR:Could not stop BSS!\n");
        }
    } else {
        printf("ERR:Command sending failed!\n");
    }
    if (buffer)
        free(buffer);
    return;
}

/**
 *  @brief Show usage information for the sta_list command
 *
 *  $return         N/A
 */
void
print_sta_list_usage(void)
{
    printf("\nUsage : sta_list\n");
    return;
}

/** 
 *  @brief Creates a STA list request and sends to the driver
 *
 *   Usage: "sta_list"
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         N/A
 */
void
apcmd_sta_list(int argc, char *argv[])
{
    APCMDBUF_STA_LIST_REQUEST *cmd_buf = NULL;
    APCMDBUF_STA_LIST_RESPONSE *response_buf = NULL;
    u8 *buf = NULL;
    u16 buf_len;
    TLVBUF_STA_INFO *tlv = NULL;
    u16 cmd_len;
    u16 response_len;
    int ret = UAP_FAILURE;
    int i = 0;
    int opt;
    int rssi = 0;

    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_sta_list_usage();
            return;
        }
    }
    argc -= optind;
    argv += optind;

    /* Check arguments */
    if (argc != 0) {
        printf("ERR:Too many arguments.\n");
        print_sta_list_usage();
        return;
    }
    response_len =
        sizeof(APCMDBUF_STA_LIST_RESPONSE) +
        (MAX_NUM_CLIENTS * sizeof(TLVBUF_STA_INFO));
    if (response_len > sizeof(APCMDBUF_STA_LIST_REQUEST))
        buf_len = response_len;
    else
        buf_len = sizeof(APCMDBUF_STA_LIST_REQUEST);

    /* Initialize the command length */
    cmd_len = sizeof(APCMDBUF_STA_LIST_REQUEST);

    /* Initialize the command buffer */
    buf = (u8 *) malloc(buf_len);

    if (!buf) {
        printf("ERR:Cannot allocate buffer from command!\n");
        return;
    }
    bzero((char *) buf, buf_len);

    /* Locate headers */
    cmd_buf = (APCMDBUF_STA_LIST_REQUEST *) buf;
    response_buf = (APCMDBUF_STA_LIST_RESPONSE *) buf;

    /* Fill the command buffer */
    cmd_buf->CmdCode = APCMD_STA_LIST;
    cmd_buf->Size = cmd_len;
    cmd_buf->SeqNum = 0;
    cmd_buf->Result = 0;

    /* Send the command */
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, buf_len);
    response_buf->StaCount = uap_le16_to_cpu(response_buf->StaCount);

    /* Process response */
    if (ret == UAP_SUCCESS) {
        /* Verify response */
        if (response_buf->CmdCode != (APCMD_STA_LIST | APCMD_RESP_CHECK)) {
            printf("ERR:Corrupted response!\n");
            free(buf);
            return;
        }

        /* Print response */
        if (response_buf->Result == CMD_SUCCESS) {
            printf("Number of STA = %d\n\n", response_buf->StaCount);
            for (i = 0; i < response_buf->StaCount; i++) {
                tlv = (TLVBUF_STA_INFO *) (&response_buf->StaList[i]);
                endian_convert_tlv_header_in(tlv);
                if (tlv) {
                    if (tlv->Tag != MRVL_STA_INFO_TLV_ID) {
                        printf("STA %d information corrupted.\n", i + 1);
                        continue;
                    }
                    printf("STA %d information:\n", i + 1);
                    printf("=====================\n");
                    printf("MAC Address: ");
                    print_mac(tlv->MacAddress);
                    printf("\nPower mfg status: %s\n",
                           (tlv->PowerMfgStatus ==
                            0) ? "active" : "power save");
                                        /** On some platform, s8 is same as unsigned char*/
                    rssi = (int) tlv->Rssi;
                    if (rssi > 0x7f)
                        rssi = -(256 - rssi);
                    printf("Rssi : %d dBm\n\n", rssi);
                } else {
                    printf("ERR:Unable to find information for STA %d\n\n",
                           i + 1);
                }
            }
        } else {
            printf("ERR:Could not get STA list!\n");
        }
    } else {
        printf("ERR:Command sending failed!\n");
    }
    free(buf);
    return;
}

/**
 *  @brief Show usage information for the sta_deauth command
 *
 *  $return         N/A
 */
void
print_sta_deauth_usage(void)
{
    printf("\nUsage : sta_deauth <STA_MAC_ADDRESS> [REASON_CODE]\n");
    return;
}

/** 
 *  @brief Creates a STA deauth request and sends to the driver
 *
 *   Usage: "sta_deauth <STA_MAC_ADDRESS>"
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         N/A
 */
void
apcmd_sta_deauth(int argc, char *argv[])
{
    APCMDBUF_STA_DEAUTH *cmd_buf = NULL;
    u8 *buffer = NULL;
    u16 cmd_len;
    int ret = UAP_FAILURE;
    int opt;

    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_sta_deauth_usage();
            return;
        }
    }
    argc -= optind;
    argv += optind;

    /* Check arguments */
    if (argc != 1 && argc != 2) {
        printf("ERR:wrong arguments! Must provide STA_MAC_ADDRESS.\n");
        printf("\t\t with optional REASON_CODE.\n");
        print_sta_deauth_usage();
        return;
    }

    /* Check Reason Code */
    if (argc == 2) {
        if (IS_HEX_OR_DIGIT(argv[1]) == UAP_FAILURE) {
            printf("ERR: Invalid input for reason code\n");
            print_sta_deauth_usage();
            return;
        }
    }

    /* Initialize the command length */
    cmd_len = sizeof(APCMDBUF_STA_DEAUTH);

    /* Initialize the command buffer */
    buffer = (u8 *) malloc(cmd_len);
    if (!buffer) {
        printf("ERR:Cannot allocate buffer for command!\n");
        return;
    }
    bzero((char *) buffer, cmd_len);

    /* Locate headers */
    cmd_buf = (APCMDBUF_STA_DEAUTH *) buffer;

    /* Fill the command buffer */
    cmd_buf->CmdCode = APCMD_STA_DEAUTH;
    cmd_buf->Size = cmd_len - BUF_HEADER_SIZE;
    cmd_buf->SeqNum = 0;
    cmd_buf->Result = 0;
    if ((ret = mac2raw(argv[0], cmd_buf->StaMacAddress)) != UAP_SUCCESS) {
        printf("ERR: %s Address\n", ret == UAP_FAILURE ? "Invalid MAC" :
               ret == UAP_RET_MAC_BROADCAST ? "Broadcast" : "Multicast");
        free(buffer);
        return;
    }
    if (argc == 2) {
        cmd_buf->ReasonCode = uap_cpu_to_le16((u16) A2HEXDECIMAL(argv[1]));
    }

    /* Send the command */
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, cmd_len);

    /* Process response */
    if (ret == UAP_SUCCESS) {
        /* Verify response */
        if (cmd_buf->CmdCode != (APCMD_STA_DEAUTH | APCMD_RESP_CHECK)) {
            printf("ERR:Corrupted response!\n");
            free(buffer);
            return;
        }

        /* Print response */
        if (cmd_buf->Result == CMD_SUCCESS) {
            printf("Deauthentication successful!\n");
        } else {
            printf("ERR:Deauthentication unsuccessful!\n");
        }
    } else {
        printf("ERR:Command sending failed!\n");
    }
    if (buffer)
        free(buffer);
    return;
}

/**
 *  @brief Show usage information for the coex_config command
 *
 *  $return         N/A
 */
void
print_coex_config_usage(void)
{
    printf("\nUsage : coex_config [CONFIG_FILE]\n");
    printf
        ("\nIf CONFIG_FILE is provided, a 'set' is performed, else a 'get' is performed.\n");
    return;
}

/** 
 *  @brief Creates a coex_config request and sends to the driver
 *
 *  Usage: "Usage : coex_config [CONFIG_FILE]"
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         UAP_SUCCESS or UAP_FAILURE
 */
void
apcmd_coex_config(int argc, char *argv[])
{
    apcmdbuf_coex_config *cmd_buf = NULL;
    tlvbuf_coex_common_cfg *coex_common_tlv;
    tlvbuf_coex_sco_cfg *coex_sco_tlv;
    tlvbuf_coex_acl_cfg *coex_acl_tlv;
    tlvbuf_coex_stats *coex_stats_tlv;
    u8 *buf = NULL;
    u16 cmd_len;
    int ret = UAP_FAILURE;
    int opt;

    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_coex_config_usage();
            return;
        }
    }
    argc -= optind;
    argv += optind;

    /* Check arguments */
    if (argc > 1) {
        printf("ERR:Too many arguments.\n");
        print_coex_config_usage();
        return;
    }
    if (argc == 1) {
        /* Read profile and send command to firmware */
        apcmd_coex_config_profile(argc, argv);
        return;
    }

    /* fixed command length */
    cmd_len = sizeof(apcmdbuf_coex_config) + sizeof(tlvbuf_coex_common_cfg)
        + sizeof(tlvbuf_coex_sco_cfg) + sizeof(tlvbuf_coex_acl_cfg)
        + sizeof(tlvbuf_coex_stats);
    /* alloc buf for command */
    buf = (u8 *) malloc(cmd_len);
    if (!buf) {
        printf("ERR:Cannot allocate buffer from command!\n");
        return;
    }
    bzero((char *) buf, cmd_len);

    cmd_buf = (apcmdbuf_coex_config *) buf;

    coex_common_tlv = (tlvbuf_coex_common_cfg *) cmd_buf->tlv_buffer;
    coex_common_tlv->Tag = MRVL_BT_COEX_COMMON_CFG_TLV_ID;
    coex_common_tlv->Length =
        sizeof(tlvbuf_coex_common_cfg) - sizeof(TLVBUF_HEADER);
    endian_convert_tlv_header_out(coex_common_tlv);

    coex_sco_tlv = (tlvbuf_coex_sco_cfg *) (cmd_buf->tlv_buffer +
                                            sizeof(tlvbuf_coex_common_cfg));
    coex_sco_tlv->Tag = MRVL_BT_COEX_SCO_CFG_TLV_ID;
    coex_sco_tlv->Length = sizeof(tlvbuf_coex_sco_cfg) - sizeof(TLVBUF_HEADER);
    endian_convert_tlv_header_out(coex_sco_tlv);

    coex_acl_tlv = (tlvbuf_coex_acl_cfg *) (cmd_buf->tlv_buffer +
                                            sizeof(tlvbuf_coex_common_cfg) +
                                            sizeof(tlvbuf_coex_sco_cfg));
    coex_acl_tlv->Tag = MRVL_BT_COEX_ACL_CFG_TLV_ID;
    coex_acl_tlv->Length = sizeof(tlvbuf_coex_acl_cfg) - sizeof(TLVBUF_HEADER);
    endian_convert_tlv_header_out(coex_acl_tlv);

    coex_stats_tlv = (tlvbuf_coex_stats *) (cmd_buf->tlv_buffer +
                                            sizeof(tlvbuf_coex_common_cfg) +
                                            sizeof(tlvbuf_coex_sco_cfg)
                                            + sizeof(tlvbuf_coex_acl_cfg));
    coex_stats_tlv->Tag = MRVL_BT_COEX_STATS_TLV_ID;
    coex_stats_tlv->Length = sizeof(tlvbuf_coex_stats) - sizeof(TLVBUF_HEADER);
    endian_convert_tlv_header_out(coex_stats_tlv);

    /* Fill the command buffer */
    cmd_buf->CmdCode = HostCmd_ROBUST_COEX;
    cmd_buf->Size = cmd_len - BUF_HEADER_SIZE;
    cmd_buf->SeqNum = 0;
    cmd_buf->Result = 0;
    cmd_buf->action = uap_cpu_to_le16(ACTION_GET);

    /* Send the command */
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, cmd_len);

    /* Process response */
    if (ret == UAP_SUCCESS) {
        /* Verify response */
        if (cmd_buf->CmdCode != (HostCmd_ROBUST_COEX | APCMD_RESP_CHECK)) {
            printf("ERR:Corrupted response!\n");
            free(buf);
            return;
        }
        /* Print response */
        if (cmd_buf->Result == CMD_SUCCESS) {
            printf("BT Coex settings:\n");
            print_tlv(buf + sizeof(apcmdbuf_coex_config),
                      cmd_buf->Size - sizeof(apcmdbuf_coex_config) +
                      BUF_HEADER_SIZE);
        } else {
            printf("ERR:Could not retrieve coex configuration.\n");
        }
    } else {
        printf("ERR:Command sending failed!\n");
    }
    free(buf);
    return;
}

/**
 *  @brief Show usage information for the sys_config command
 *
 *  $return         N/A
 */
void
print_sys_config_usage(void)
{
    printf("\nUsage : sys_config [CONFIG_FILE]\n");
    printf
        ("\nIf CONFIG_FILE is provided, a 'set' is performed, else a 'get' is performed.\n");
    printf("CONFIG_FILE is file contain all the Micro AP settings.\n");
    return;
}

/**
 *  @brief Show usage information for the rdeeprom command
 *
 *  $return         N/A
 */
void
print_apcmd_read_eeprom_usage(void)
{
    printf("\nUsage: rdeeprom <offset> <bytecount>\n");
    printf("    offset    : 0,4,8,..., multiple of 4\n");
    printf("    bytecount : 4-20, multiple of 4\n");
    return;
}

/**
 *  @brief Show protocol tlv 
 *
 *  @param tlv     Poniter to protocol tlv
 *  
 *  $return         N/A
 */
void
print_protocol(TLVBUF_PROTOCOL * tlv)
{
    switch (tlv->Protocol) {
    case 0:
    case PROTOCOL_NO_SECURITY:
        printf("PROTOCOL = No security\n");
        break;
    case PROTOCOL_STATIC_WEP:
        printf("PROTOCOL = Static WEP\n");
        break;
    case PROTOCOL_WPA:
        printf("PROTOCOL = WPA \n");
        break;
    case PROTOCOL_WPA2:
        printf("PROTOCOL = WPA2 \n");
        break;
    case PROTOCOL_WPA | PROTOCOL_WPA2:
        printf("PROTOCOL = WPA/WPA2 \n");
        break;
    default:
        printf("Unknown PROTOCOL: 0x%x \n", tlv->Protocol);
        break;
    }
}

/**
 *  @brief Show wep tlv 
 *
 *  @param tlv     Poniter to wep tlv
 *  
 *  $return         N/A
 */
void
print_wep_key(TLVBUF_WEP_KEY * tlv)
{
    int i;
    if (tlv->Length <= 2) {
        printf("wrong wep_key tlv: length=%d\n", tlv->Length);
        return;
    }
    printf("WEP KEY_%d = ", tlv->KeyIndex);
    for (i = 0; i < tlv->Length - 2; i++)
        printf("%02x ", tlv->Key[i]);
    if (tlv->IsDefault)
        printf("\nDefault WEP Key = %d\n", tlv->KeyIndex);
    else
        printf("\n");
}

/** 
 *  @brief Parses a command line
 *
 *  @param line     The line to parse
 *  @param args     Pointer to the argument buffer to be filled in
 *  @return         Number of arguments in the line or EOF
 */
static int
parse_line(char *line, char *args[])
{
    int arg_num = 0;
    int is_start = 0;
    int is_quote = 0;
    int length = 0;
    int i = 0;

    arg_num = 0;
    length = strlen(line);
    /* Process line */

    /* Find number of arguments */
    is_start = 0;
    is_quote = 0;
    for (i = 0; i < length; i++) {
        /* Ignore leading spaces */
        if (is_start == 0) {
            if (line[i] == ' ') {
                continue;
            } else if (line[i] == '\t') {
                continue;
            } else if (line[i] == '\n') {
                break;
            } else {
                is_start = 1;
                args[arg_num] = &line[i];
                arg_num++;
            }
        }
        if (is_start == 1) {
            /* Ignore comments */
            if (line[i] == '#') {
                line[i] = '\0';
                arg_num--;
                break;
            }
            /* Separate by '=' */
            if (line[i] == '=') {
                line[i] = '\0';
                is_start = 0;
                continue;
            }
            /* Separate by ',' */
            if (line[i] == ',') {
                line[i] = '\0';
                is_start = 0;
                continue;
            }
            /* Change ',' to ' ', but not inside quotes */
            if ((line[i] == ',') && (is_quote == 0)) {
                line[i] = ' ';
                continue;
            }
        }
        /* Remove newlines */
        if (line[i] == '\n') {
            line[i] = '\0';
        }
        /* Check for quotes */
        if (line[i] == '"') {
            is_quote = (is_quote == 1) ? 0 : 1;
            continue;
        }
        if (((line[i] == ' ') || (line[i] == '\t')) && (is_quote == 0)) {
            line[i] = '\0';
            is_start = 0;
            continue;
        }
    }
    return arg_num;
}

/** 
 *  @brief      Parse function for a configuration line  
 *
 *  @param s        Storage buffer for data
 *  @param size     Maximum size of data
 *  @param stream   File stream pointer
 *  @param line     Pointer to current line within the file
 *  @param _pos     Output string or NULL
 *  @return     String or NULL
 */
static char *
config_get_line(char *s, int size, FILE * stream, int *line, char **_pos)
{
    char *pos, *end, *sstart;
    while (fgets(s, size, stream)) {
        (*line)++;
        s[size - 1] = '\0';
        pos = s;
        /* Skip white space from the beginning of line. */
        while (*pos == ' ' || *pos == '\t' || *pos == '\r')
            pos++;
        /* Skip comment lines and empty lines */
        if (*pos == '#' || *pos == '\n' || *pos == '\0')
            continue;
        /* 
         * Remove # comments unless they are within a double quoted
         * string.
         */
        sstart = strchr(pos, '"');
        if (sstart)
            sstart = strrchr(sstart + 1, '"');
        if (!sstart)
            sstart = pos;
        end = strchr(sstart, '#');
        if (end)
            *end-- = '\0';
        else
            end = pos + strlen(pos) - 1;
        /* Remove trailing white space. */
        while (end > pos &&
               (*end == '\n' || *end == ' ' || *end == '\t' || *end == '\r'))
            *end-- = '\0';
        if (*pos == '\0')
            continue;
        if (_pos)
            *_pos = pos;
        return pos;
    }

    if (_pos)
        *_pos = NULL;
    return NULL;
}

/** 
 *  @brief Read the profile and sends to the driver
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         UAP_SUCCESS or UAP_FAILURE
 */
void
apcmd_coex_config_profile(int argc, char *argv[])
{
    FILE *config_file = NULL;
    char *line = NULL;
    int i, ret, index, li = 0;
    char *pos = NULL;
    int arg_num = 0;
    char *args[30];
    int is_coex_config = 0;
    int is_coex_common_config = 0;
    int is_coex_sco_config = 0;
    int is_coex_acl_config = 0;
    u8 *buf = NULL;
    apcmdbuf_coex_config *cmd_buf = NULL;
    tlvbuf_coex_common_cfg *coex_common_tlv;
    tlvbuf_coex_sco_cfg *coex_sco_tlv;
    tlvbuf_coex_acl_cfg *coex_acl_tlv;
    u16 acl_enabled = 0;
    u32 conf_bitmap = 0;
    u16 cmd_len = 0, tlv_len = 0;
    u16 sco_prot_qtime[4] = { 0, 0, 0, 0 }, sco_prot_rate = 0, sco_acl_freq = 0;
    u16 acl_bt_time = 0, acl_wlan_time = 0, acl_prot_rate = 0;

    /* Check if file exists */
    config_file = fopen(argv[0], "r");
    if (config_file == NULL) {
        printf("\nERR:Config file can not open.\n");
        return;
    }
    line = (char *) malloc(MAX_CONFIG_LINE);
    if (!line) {
        printf("ERR:Cannot allocate memory for line\n");
        goto done;
    }
    bzero(line, MAX_CONFIG_LINE);

    /* fixed command length */
    cmd_len = sizeof(apcmdbuf_coex_config) + sizeof(tlvbuf_coex_common_cfg)
        + sizeof(tlvbuf_coex_sco_cfg) + sizeof(tlvbuf_coex_acl_cfg);
    /* alloc buf for command */
    buf = (u8 *) malloc(cmd_len);
    if (!buf) {
        printf("ERR:Cannot allocate buffer from command!\n");
        goto done;
    }
    bzero((char *) buf, cmd_len);

    cmd_buf = (apcmdbuf_coex_config *) buf;

    /* Fill the command buffer */
    cmd_buf->CmdCode = HostCmd_ROBUST_COEX;
    cmd_buf->Size = cmd_len - BUF_HEADER_SIZE;
    cmd_buf->SeqNum = 0;
    cmd_buf->Result = 0;
    cmd_buf->action = uap_cpu_to_le16(ACTION_SET);

    /* Parse file and process */
    while (config_get_line(line, MAX_CONFIG_LINE, config_file, &li, &pos)) {
#if DEBUG
        uap_printf(MSG_DEBUG, "DBG:Received config line (%d) = %s\n", li, line);
#endif
        arg_num = parse_line(line, args);
#if DEBUG
        uap_printf(MSG_DEBUG, "DBG:Number of arguments = %d\n", arg_num);
        for (i = 0; i < arg_num; i++) {
            uap_printf(MSG_DEBUG, "\tDBG:Argument %d. %s\n", i + 1, args[i]);
        }
#endif
        /* Check for end of Coex configurations */
        if (is_coex_acl_config == 1) {
            if (strcmp(args[0], "}") == 0) {
                coex_acl_tlv =
                    (tlvbuf_coex_acl_cfg *) (cmd_buf->tlv_buffer + tlv_len);
                coex_acl_tlv->Tag = MRVL_BT_COEX_ACL_CFG_TLV_ID;
                coex_acl_tlv->Length =
                    sizeof(tlvbuf_coex_acl_cfg) - sizeof(TLVBUF_HEADER);
                endian_convert_tlv_header_out(coex_acl_tlv);
                coex_acl_tlv->enabled = uap_cpu_to_le16(acl_enabled);
                coex_acl_tlv->bt_time = uap_cpu_to_le16(acl_bt_time);
                coex_acl_tlv->wlan_time = uap_cpu_to_le16(acl_wlan_time);
                coex_acl_tlv->protection_rate = uap_cpu_to_le16(acl_prot_rate);
                tlv_len += sizeof(tlvbuf_coex_acl_cfg);
                is_coex_acl_config = 0;
            }
        } else if (is_coex_sco_config == 1) {
            if (strcmp(args[0], "}") == 0) {
                coex_sco_tlv =
                    (tlvbuf_coex_sco_cfg *) (cmd_buf->tlv_buffer + tlv_len);
                coex_sco_tlv->Tag = MRVL_BT_COEX_SCO_CFG_TLV_ID;
                coex_sco_tlv->Length =
                    sizeof(tlvbuf_coex_sco_cfg) - sizeof(TLVBUF_HEADER);
                endian_convert_tlv_header_out(coex_sco_tlv);
                for (i = 0; i < 4; i++)
                    coex_sco_tlv->protection_qtime[i] =
                        uap_cpu_to_le16(sco_prot_qtime[i]);
                coex_sco_tlv->protection_rate = uap_cpu_to_le16(sco_prot_rate);
                coex_sco_tlv->acl_frequency = uap_cpu_to_le16(sco_acl_freq);
                tlv_len += sizeof(tlvbuf_coex_sco_cfg);
                is_coex_sco_config = 0;
            }
        } else if (is_coex_common_config == 1) {
            if (strcmp(args[0], "}") == 0) {
                coex_common_tlv =
                    (tlvbuf_coex_common_cfg *) (cmd_buf->tlv_buffer + tlv_len);
                coex_common_tlv->Tag = MRVL_BT_COEX_COMMON_CFG_TLV_ID;
                coex_common_tlv->Length =
                    sizeof(tlvbuf_coex_common_cfg) - sizeof(TLVBUF_HEADER);
                endian_convert_tlv_header_out(coex_common_tlv);
                coex_common_tlv->config_bitmap = uap_cpu_to_le32(conf_bitmap);
                tlv_len += sizeof(tlvbuf_coex_common_cfg);
                is_coex_common_config = 0;
            }
        } else if (is_coex_config == 1) {
            if (strcmp(args[0], "}") == 0)
                is_coex_config = 0;
        }
        if (strcmp(args[0], "coex_config") == 0) {
            is_coex_config = 1;
        } else if (strcmp(args[0], "common_config") == 0) {
            is_coex_common_config = 1;
        } else if (strcmp(args[0], "sco_config") == 0) {
            is_coex_sco_config = 1;
        } else if (strcmp(args[0], "acl_config") == 0) {
            is_coex_acl_config = 1;
        }
        if ((strcmp(args[0], "bitmap") == 0) && is_coex_common_config) {
            if (is_input_valid(COEX_COMM_BITMAP, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            conf_bitmap = (u32) A2HEXDECIMAL(args[1]);
        } else if ((strncmp(args[0], "protectionFromQTime", 19) == 0) &&
                   is_coex_sco_config) {
            index = atoi(args[0] + strlen("protectionFromQTime"));
            if (index < 0 || index > 3) {
                printf("ERR:Incorrect index %d.\n", index);
                goto done;
            }
            if (is_input_valid(COEX_PROTECTION, arg_num, args) != UAP_SUCCESS) {
                goto done;
            }
            sco_prot_qtime[index] = (u16) atoi(args[1]);
        } else if ((strcmp(args[0], "scoProtectionFromRate") == 0) &&
                   is_coex_sco_config) {
            if (is_input_valid(COEX_PROTECTION, arg_num, args) != UAP_SUCCESS) {
                goto done;
            }
            sco_prot_rate = (u16) atoi(args[1]);
        } else if ((strcmp(args[0], "aclFrequency") == 0) && is_coex_sco_config) {
            if (is_input_valid(COEX_SCO_ACL_FREQ, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            sco_acl_freq = (u16) atoi(args[1]);
        } else if ((strcmp(args[0], "enabled") == 0) && is_coex_acl_config) {
            if (is_input_valid(COEX_ACL_ENABLED, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            acl_enabled = (u16) atoi(args[1]);
        } else if ((strcmp(args[0], "btTime") == 0) && is_coex_acl_config) {
            if (is_input_valid(COEX_ACL_BT_TIME, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            acl_bt_time = (u16) atoi(args[1]);
        } else if ((strcmp(args[0], "wlanTime") == 0) && is_coex_acl_config) {
            if (is_input_valid(COEX_ACL_WLAN_TIME, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            acl_wlan_time = (u16) atoi(args[1]);
        } else if ((strcmp(args[0], "aclProtectionFromRate") == 0) &&
                   is_coex_acl_config) {
            if (is_input_valid(COEX_PROTECTION, arg_num, args) != UAP_SUCCESS) {
                goto done;
            }
            acl_prot_rate = (u16) atoi(args[1]);
        }
    }
    /* Send the command */
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, cmd_len);

    /* Process response */
    if (ret == UAP_SUCCESS) {
        /* Verify response */
        if (cmd_buf->CmdCode != (HostCmd_ROBUST_COEX | APCMD_RESP_CHECK)) {
            printf("ERR:Corrupted response!\n");
            goto done;
        }
        /* Print response */
        if (cmd_buf->Result == CMD_SUCCESS) {
            printf("BT Coex settings sucessfully set.\n");
        } else {
            printf("ERR:Could not set coex configuration.\n");
        }
    } else {
        printf("ERR:Command sending failed!\n");
    }
  done:
    fclose(config_file);
    if (buf)
        free(buf);
    if (line)
        free(line);
}

/** 
 *  @brief Read the profile and sends to the driver
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         UAP_SUCCESS or UAP_FAILURE
 */
void
apcmd_sys_config_profile(int argc, char *argv[])
{
    FILE *config_file = NULL;
    char *line = NULL;
    int li = 0;
    char *pos = NULL;
    int arg_num = 0;
    char *args[30];
    int i;
    int is_ap_config = 0;
    int is_custom_ie_config = 0;
    int is_ap_mac_filter = 0;
    APCMDBUF_SYS_CONFIGURE *cmd_buf = NULL;
    u8 *buffer = NULL;
    u16 cmd_len = 0;
    u16 tlv_len = 0;
    u16 ie_len = 0;
    u16 ie_buf_len = 0;
    u16 mask_ie_index = 0;
    int keyindex = -1;
    int pairwisecipher = -1;
    int groupcipher = -1;
    TLVBUF_STA_MAC_ADDR_FILTER *filter_tlv = NULL;
    tlvbuf_custom_ie *custom_ie_tlv_head = NULL;
    tlvbuf_custom_ie *custom_ie_tlv = NULL;
    custom_ie *custom_ie_ptr = NULL;
    int custom_ie_tlv_len = 0;
    int custom_mask_count = 0;
    int custom_buf_count = 0;
    int filter_mac_count = -1;
    int tx_data_rate = -1;
    int mcbc_data_rate = -1;
    u8 rate[MAX_RATES];
    int found = 0;
    char country_80211d[4];
    u8 state_80211d;
    int flag_80211d = 0;

    memset(rate, 0, MAX_RATES);
    /* Check if file exists */
    config_file = fopen(argv[0], "r");
    if (config_file == NULL) {
        printf("\nERR:Config file can not open.\n");
        return;
    }
    line = (char *) malloc(MAX_CONFIG_LINE);
    if (!line) {
        printf("ERR:Cannot allocate memory for line\n");
        goto done;
    }
    bzero(line, MAX_CONFIG_LINE);

    /* Parse file and process */
    while (config_get_line(line, MAX_CONFIG_LINE, config_file, &li, &pos)) {
#if DEBUG
        uap_printf(MSG_DEBUG, "DBG:Received config line (%d) = %s\n", li, line);
#endif
        arg_num = parse_line(line, args);
#if DEBUG
        uap_printf(MSG_DEBUG, "DBG:Number of arguments = %d\n", arg_num);
        for (i = 0; i < arg_num; i++) {
            uap_printf(MSG_DEBUG, "\tDBG:Argument %d. %s\n", i + 1, args[i]);
        }
#endif
        /* Check for end of AP configurations */
        if (is_ap_config == 1) {
            if (strcmp(args[0], "}") == 0) {
                is_ap_config = 0;
                if (tx_data_rate != -1) {
                    if ((!rate[0]) && (tx_data_rate) &&
                        (is_tx_rate_valid((u8) tx_data_rate) != UAP_SUCCESS)) {
                        printf("ERR: Invalid Tx Data Rate \n");
                        goto done;
                    }
                    if (rate[0] && tx_data_rate) {
                        for (i = 0; rate[i] != 0; i++) {
                            if ((rate[i] & ~BASIC_RATE_SET_BIT) == tx_data_rate) {
                                found = 1;
                                break;
                            }
                        }
                        if (!found) {
                            printf("ERR: Invalid Tx Data Rate \n");
                            goto done;
                        }
                    }

                    /* Append a new TLV */
                    TLVBUF_TX_DATA_RATE *tlv = NULL;
                    tlv_len = sizeof(TLVBUF_TX_DATA_RATE);
                    buffer = realloc(buffer, cmd_len + tlv_len);
                    if (!buffer) {
                        printf("ERR:Cannot append tx data rate TLV!\n");
                        goto done;
                    }
                    cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
                    tlv = (TLVBUF_TX_DATA_RATE *) (buffer + cmd_len);
                    cmd_len += tlv_len;
                    /* Set TLV fields */
                    tlv->Tag = MRVL_TX_DATA_RATE_TLV_ID;
                    tlv->Length = 2;
                    tlv->TxDataRate = tx_data_rate;
                    endian_convert_tlv_header_out(tlv);
                    tlv->TxDataRate = uap_cpu_to_le16(tlv->TxDataRate);
                }
                if (mcbc_data_rate != -1) {
                    if ((!rate[0]) && (mcbc_data_rate) &&
                        (is_mcbc_rate_valid((u8) mcbc_data_rate) !=
                         UAP_SUCCESS)) {
                        printf("ERR: Invalid Tx Data Rate \n");
                        goto done;
                    }
                    if (rate[0] && mcbc_data_rate) {
                        for (i = 0; rate[i] != 0; i++) {
                            if (rate[i] & BASIC_RATE_SET_BIT) {
                                if ((rate[i] & ~BASIC_RATE_SET_BIT) ==
                                    mcbc_data_rate) {
                                    found = 1;
                                    break;
                                }
                            }
                        }
                        if (!found) {
                            printf("ERR: Invalid MCBC Data Rate \n");
                            goto done;
                        }
                    }

                    /* Append a new TLV */
                    TLVBUF_MCBC_DATA_RATE *tlv = NULL;
                    tlv_len = sizeof(TLVBUF_MCBC_DATA_RATE);
                    buffer = realloc(buffer, cmd_len + tlv_len);
                    if (!buffer) {
                        printf("ERR:Cannot append tx data rate TLV!\n");
                        goto done;
                    }
                    cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
                    tlv = (TLVBUF_MCBC_DATA_RATE *) (buffer + cmd_len);
                    cmd_len += tlv_len;
                    /* Set TLV fields */
                    tlv->Tag = MRVL_MCBC_DATA_RATE_TLV_ID;
                    tlv->Length = 2;
                    tlv->MCBCdatarate = mcbc_data_rate;
                    endian_convert_tlv_header_out(tlv);
                    tlv->MCBCdatarate = uap_cpu_to_le16(tlv->MCBCdatarate);
                }

                if ((pairwisecipher >= 0) && (groupcipher >= 0)) {
                    if (is_cipher_valid(pairwisecipher, groupcipher) !=
                        UAP_SUCCESS) {
                        printf
                            ("ERR:Wrong group and pair cipher combination!\n");
                        goto done;
                    }
                    TLVBUF_CIPHER *tlv = NULL;
                    /* Append a new TLV */
                    tlv_len = sizeof(TLVBUF_CIPHER);
                    buffer = realloc(buffer, cmd_len + tlv_len);
                    if (!buffer) {
                        printf("ERR:Cannot append cipher TLV!\n");
                        goto done;
                    }
                    cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
                    tlv = (TLVBUF_CIPHER *) (buffer + cmd_len);
                    bzero((char *) tlv, tlv_len);
                    cmd_len += tlv_len;
                    /* Set TLV fields */
                    tlv->Tag = MRVL_CIPHER_TLV_ID;
                    tlv->Length = 2;
                    tlv->PairwiseCipher = pairwisecipher;
                    tlv->GroupCipher = groupcipher;
                    endian_convert_tlv_header_out(tlv);
                }
                cmd_buf->Size = cmd_len;
                /* Send collective command */
                uap_ioctl((u8 *) cmd_buf, &cmd_len, cmd_len);
                cmd_len = 0;
                if (buffer) {
                    free(buffer);
                    buffer = NULL;
                }
                continue;
            }
        }

        /* Check for beginning of AP configurations */
        if (strcmp(args[0], "ap_config") == 0) {
            is_ap_config = 1;
            cmd_len = sizeof(APCMDBUF_SYS_CONFIGURE);
            if (buffer) {
                free(buffer);
                buffer = NULL;
            }
            buffer = (u8 *) malloc(cmd_len);
            if (!buffer) {
                printf("ERR:Cannot allocate memory!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            cmd_buf->CmdCode = APCMD_SYS_CONFIGURE;
            cmd_buf->Size = cmd_len;
            cmd_buf->SeqNum = 0;
            cmd_buf->Result = 0;
            cmd_buf->Action = ACTION_SET;
            continue;
        }

        /* Check for end of AP MAC address filter configurations */
        if (is_ap_mac_filter == 1) {
            if (strcmp(args[0], "}") == 0) {
                is_ap_mac_filter = 0;
                if (filter_tlv->Count != filter_mac_count) {
                    printf
                        ("ERR:Number of MAC address provided does not match 'Count'\n");
                    goto done;
                }
                if (filter_tlv->FilterMode && (filter_tlv->Count == 0)) {
                    printf
                        ("ERR:Filter list can not be empty for %s Filter mode\n",
                         (filter_tlv->FilterMode == 1) ? "'Allow'" : "'Block'");
                    goto done;
                }
                filter_tlv->Length = (filter_tlv->Count * ETH_ALEN) + 2;
                cmd_len -=
                    (MAX_MAC_ONESHOT_FILTER - filter_mac_count) * ETH_ALEN;
                cmd_buf->Size = cmd_len;
                endian_convert_tlv_header_out(filter_tlv);
                uap_ioctl((u8 *) cmd_buf, &cmd_len, cmd_len);
                cmd_len = 0;
                if (buffer) {
                    free(buffer);
                    buffer = NULL;
                }
                continue;
            }
        }

        /* Check for end of custom IE configurations */
        if (is_custom_ie_config == 1) {
            if (strcmp(args[0], "}") == 0) {
                if (custom_mask_count != custom_buf_count) {
                    printf
                        ("ERR:custom IE mask count and buffer count does not match\n");
                    goto done;
                }
                is_custom_ie_config = 0;
                custom_ie_tlv_head->Length = custom_ie_tlv_len;
                cmd_len -=
                    (MAX_IE_BUFFER_LEN * MAX_CUSTOM_IE_COUNT) -
                    custom_ie_tlv_len;
                cmd_len -= sizeof(custom_ie) * MAX_CUSTOM_IE_COUNT;
                cmd_buf->Size = cmd_len;
                endian_convert_tlv_header_out(custom_ie_tlv_head);
                uap_ioctl((u8 *) cmd_buf, &cmd_len, cmd_len);
                cmd_len = 0;
                if (buffer) {
                    free(buffer);
                    buffer = NULL;
                }
                continue;
            }
        }

        if (flag_80211d && (strcmp(args[0], "11d_enable") == 0)) {
            if (IS_HEX_OR_DIGIT(args[1]) == UAP_FAILURE) {
                printf("ERR: valid input for state are 0 or 1\n");
                goto done;
            }
            state_80211d = (u8) A2HEXDECIMAL(args[1]);

            if ((state_80211d != 0) && (state_80211d != 1)) {
                printf("ERR: valid input for state are 0 or 1 \n");
                goto done;
            }
            if (sg_snmp_mib
                (ACTION_SET, OID_80211D_ENABLE, sizeof(state_80211d),
                 &state_80211d)
                == UAP_FAILURE) {
                goto done;
            }
        }

        if (strcmp(args[0], "country") == 0) {
            APCMDBUF_CFG_80211D *cmd_buf = NULL;
            IEEEtypes_SubbandSet_t sub_bands[MAX_SUB_BANDS];
            u8 no_of_sub_band = 0;
            u16 buf_len;
            u16 cmdlen;
            u8 *buf = NULL;

            if ((strlen(args[1]) > 3) || (strlen(args[1]) < 0)) {
                printf("In-correct country input\n");
                goto done;
            }
            strcpy(country_80211d, args[1]);
            for (i = 0; i < strlen(country_80211d); i++) {
                if ((country_80211d[i] < 'A') || (country_80211d[i] > 'z')) {
                    printf("Invalid Country Code\n");
                    goto done;
                }
                if (country_80211d[i] > 'Z')
                    country_80211d[i] = country_80211d[i] - 'a' + 'A';
            }
            no_of_sub_band = parse_domain_file(country_80211d, sub_bands);
            if (no_of_sub_band == UAP_FAILURE) {
                printf("Parsing Failed\n");
                goto done;
            }
            buf_len = sizeof(APCMDBUF_CFG_80211D);
            buf_len += no_of_sub_band * sizeof(IEEEtypes_SubbandSet_t);
            buf = (u8 *) malloc(buf_len);
            if (!buf) {
                printf("ERR:Cannot allocate buffer from command!\n");
                goto done;
            }
            bzero((char *) buf, buf_len);
            cmd_buf = (APCMDBUF_CFG_80211D *) buf;
            cmdlen = buf_len;
            cmd_buf->Size = cmdlen - BUF_HEADER_SIZE;
            cmd_buf->Result = 0;
            cmd_buf->SeqNum = 0;
            cmd_buf->Action = uap_cpu_to_le16(ACTION_SET);
            cmd_buf->CmdCode = HostCmd_CMD_802_11D_DOMAIN_INFO;
            cmd_buf->Domain.Tag = uap_cpu_to_le16(TLV_TYPE_DOMAIN);
            cmd_buf->Domain.Length = uap_cpu_to_le16(sizeof(domain_param_t)
                                                     - BUF_HEADER_SIZE
                                                     +
                                                     (no_of_sub_band *
                                                      sizeof
                                                      (IEEEtypes_SubbandSet_t)));

            memset(cmd_buf->Domain.CountryCode, ' ',
                   sizeof(cmd_buf->Domain.CountryCode));
            memcpy(cmd_buf->Domain.CountryCode, country_80211d,
                   strlen(country_80211d));
            memcpy(cmd_buf->Domain.Subband, sub_bands,
                   no_of_sub_band * sizeof(IEEEtypes_SubbandSet_t));

            /* Send the command */
            uap_ioctl((u8 *) cmd_buf, &cmdlen, buf_len);
            if (buf)
                free(buf);
        }

        /* Check for beginning of AP MAC address filter configurations */
        if (strcmp(args[0], "ap_mac_filter") == 0) {
            is_ap_mac_filter = 1;
            cmd_len =
                sizeof(APCMDBUF_SYS_CONFIGURE) +
                sizeof(TLVBUF_STA_MAC_ADDR_FILTER) +
                (MAX_MAC_ONESHOT_FILTER * ETH_ALEN);
            if (buffer) {
                free(buffer);
                buffer = NULL;
            }
            buffer = (u8 *) malloc(cmd_len);
            if (!buffer) {
                printf("ERR:Cannot allocate memory!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            cmd_buf->CmdCode = APCMD_SYS_CONFIGURE;
            cmd_buf->Size = cmd_len;
            cmd_buf->SeqNum = 0;
            cmd_buf->Result = 0;
            cmd_buf->Action = ACTION_SET;
            filter_tlv =
                (TLVBUF_STA_MAC_ADDR_FILTER *) (buffer +
                                                sizeof(APCMDBUF_SYS_CONFIGURE));
            filter_tlv->Tag = MRVL_STA_MAC_ADDR_FILTER_TLV_ID;
            filter_tlv->Length = 2;
            filter_tlv->Count = 0;
            filter_mac_count = 0;
            continue;
        }

        /* Check for beginning of custom IE configurations */
        if (strcmp(args[0], "custom_ie_config") == 0) {
            is_custom_ie_config = 1;
            cmd_len = sizeof(APCMDBUF_SYS_CONFIGURE) + sizeof(tlvbuf_custom_ie)
                +
                ((MAX_IE_BUFFER_LEN + sizeof(custom_ie)) * MAX_CUSTOM_IE_COUNT);
            if (buffer) {
                free(buffer);
                buffer = NULL;
            }
            buffer = (u8 *) malloc(cmd_len);
            if (!buffer) {
                printf("ERR:Cannot allocate memory!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            cmd_buf->CmdCode = APCMD_SYS_CONFIGURE;
            cmd_buf->Size = cmd_len;
            cmd_buf->SeqNum = 0;
            cmd_buf->Result = 0;
            cmd_buf->Action = ACTION_SET;
            custom_ie_tlv =
                (tlvbuf_custom_ie *) (buffer + sizeof(APCMDBUF_SYS_CONFIGURE));
            custom_ie_ptr = (custom_ie *) (custom_ie_tlv->ie_data);
            custom_ie_tlv_head = custom_ie_tlv;
            custom_ie_tlv_head->Tag = MRVL_MGMT_IE_LIST_TLV_ID;
            continue;
        }

        if ((strcmp(args[0], "FilterMode") == 0) && is_ap_mac_filter) {
            if ((ISDIGIT(args[1]) == 0) || (atoi(args[1]) < 0) ||
                (atoi(args[1]) > 2)) {
                printf
                    ("ERR:Illegal FilterMode paramter %d. Must be either '0', '1', or '2'.\n",
                     atoi(args[1]));
                goto done;
            }
            filter_tlv->FilterMode = atoi(args[1]);
            continue;
        }
        if ((strcmp(args[0], "Count") == 0) && is_ap_mac_filter) {
            filter_tlv->Count = atoi(args[1]);
            if ((ISDIGIT(args[1]) == 0) ||
                (filter_tlv->Count > MAX_MAC_ONESHOT_FILTER)) {
                printf("ERR: Illegal Count parameter.\n");
                goto done;
            }
        }
        if ((strncmp(args[0], "mac_", 4) == 0) && is_ap_mac_filter) {
            if (filter_mac_count < MAX_MAC_ONESHOT_FILTER) {
                if (mac2raw
                    (args[1],
                     &filter_tlv->MacAddress[filter_mac_count * ETH_ALEN]) !=
                    UAP_SUCCESS) {
                    printf("ERR: Invalid MAC address %s \n", args[1]);
                    goto done;
                }
                filter_mac_count++;
            } else {
                printf
                    ("ERR: Filter table can not have more than %d MAC addresses\n",
                     MAX_MAC_ONESHOT_FILTER);
                goto done;
            }
        }

        /* custom ie configuration parameters */
        if ((strncmp(args[0], "MgmtSubtypeMask_", 16) == 0) &&
            is_custom_ie_config) {
            if (UAP_FAILURE == ishexstring(args[1])) {
                printf("ERR:Illegal MgmtSubtypeMask %s.\n", args[1]);
                goto done;
            }
            mask_ie_index = (u16) atoi(args[0] + strlen("MgmtSubtypeMask_"));
            if (mask_ie_index > 3) {
                printf("ERR:Incorrect index %d.\n", mask_ie_index);
                goto done;
            }
            custom_ie_ptr->ie_index = uap_cpu_to_le16(mask_ie_index);
            custom_ie_ptr->mgmt_subtype_mask = (u16) A2HEXDECIMAL(args[1]);
            custom_ie_ptr->mgmt_subtype_mask = uap_cpu_to_le16
                (custom_ie_ptr->mgmt_subtype_mask);
            custom_mask_count++;
            continue;
        }
        if ((strncmp(args[0], "IEBuffer_", 9) == 0) && is_custom_ie_config) {
            if (UAP_FAILURE == ishexstring(args[1])) {
                printf("ERR:Only hex digits are allowed\n");
                goto done;
            }
            ie_buf_len = strlen(args[1]);
            if (!strncasecmp("0x", args[1], 2)) {
                ie_len = (ie_buf_len - 2 + 1) / 2;
                args[1] += 2;
            } else
                ie_len = (ie_buf_len + 1) / 2;

            if (ie_len > MAX_IE_BUFFER_LEN) {
                printf("ERR:Incorrect IE length %d\n", ie_buf_len);
                goto done;
            }

            custom_ie_ptr->ie_index = (u16) atoi(args[0] + strlen("IEBuffer_"));
            if (custom_ie_ptr->ie_index != mask_ie_index) {
                printf("ERR:IE buffer%d should follow MgmtSubtypeMask%d\n",
                       mask_ie_index, mask_ie_index);
                goto done;
            }
            custom_ie_ptr->ie_index = uap_cpu_to_le16(custom_ie_ptr->ie_index);
            string2raw(args[1], custom_ie_ptr->ie_buffer);
            custom_ie_ptr->ie_length = uap_cpu_to_le16(ie_len);
            custom_ie_tlv_len += sizeof(custom_ie) + ie_len;
            custom_ie_tlv = (tlvbuf_custom_ie *) ((u8 *) custom_ie_tlv
                                                  + sizeof(custom_ie) + ie_len);
            custom_ie_ptr = (custom_ie *) (custom_ie_tlv->ie_data);
            custom_buf_count++;
            continue;
        }
        if (strcmp(args[0], "SSID") == 0) {
            if (arg_num == 1) {
                printf("ERR:SSID field is blank!\n");
                goto done;
            } else {
                TLVBUF_SSID *tlv = NULL;
                if (args[1][0] == '"') {
                    args[1]++;
                }
                if (args[1][strlen(args[1]) - 1] == '"') {
                    args[1][strlen(args[1]) - 1] = '\0';
                }
                if ((strlen(args[1]) > MAX_SSID_LENGTH) ||
                    (strlen(args[1]) == 0)) {
                    printf("ERR:SSID length out of range (%d to %d).\n",
                           MIN_SSID_LENGTH, MAX_SSID_LENGTH);
                    goto done;
                }
                /* Append a new TLV */
                tlv_len = sizeof(TLVBUF_SSID) + strlen(args[1]);
                buffer = realloc(buffer, cmd_len + tlv_len);
                if (!buffer) {
                    printf("ERR:Cannot realloc SSID TLV!\n");
                    goto done;
                }
                cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
                tlv = (TLVBUF_SSID *) (buffer + cmd_len);
                cmd_len += tlv_len;
                /* Set TLV fields */
                tlv->Tag = MRVL_SSID_TLV_ID;
                tlv->Length = strlen(args[1]);
                memcpy(tlv->Ssid, args[1], tlv->Length);
                endian_convert_tlv_header_out(tlv);
            }
        }
        if (strcmp(args[0], "BeaconPeriod") == 0) {
            if (is_input_valid(BEACONPERIOD, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            TLVBUF_BEACON_PERIOD *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_BEACON_PERIOD);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot realloc beacon period TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_BEACON_PERIOD *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_BEACON_PERIOD_TLV_ID;
            tlv->Length = 2;
            tlv->BeaconPeriod_ms = (u16) atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
            tlv->BeaconPeriod_ms = uap_cpu_to_le16(tlv->BeaconPeriod_ms);
        }
        if (strcmp(args[0], "ChanList") == 0) {
            if (is_input_valid(SCANCHANNELS, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }

            TLVBUF_CHANNEL_LIST *tlv = NULL;
            CHANNEL_LIST *pChanList = NULL;
            /* Append a new TLV */
            tlv_len =
                sizeof(TLVBUF_CHANNEL_LIST) +
                ((arg_num - 1) * sizeof(CHANNEL_LIST));
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append channel list TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_CHANNEL_LIST *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_CHANNELLIST_TLV_ID;
            tlv->Length = sizeof(CHANNEL_LIST) * (arg_num - 1);
            pChanList = (CHANNEL_LIST *) tlv->ChanList;
            for (i = 0; i < (arg_num - 1); i++) {
                pChanList->ChanNumber = (u8) atoi(args[i + 1]);
                pChanList->BandConfigType = 0;
                pChanList++;
            }
            endian_convert_tlv_header_out(tlv);
        }
        if (strcmp(args[0], "Channel") == 0) {
            if (is_input_valid(CHANNEL, arg_num - 1, args + 1) != UAP_SUCCESS) {
                goto done;
            }
            TLVBUF_CHANNEL_CONFIG *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_CHANNEL_CONFIG);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append channel TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_CHANNEL_CONFIG *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_CHANNELCONFIG_TLV_ID;
            tlv->Length = 2;
            tlv->ChanNumber = (u8) atoi(args[1]);
            if ((arg_num - 1) == 2)
                tlv->BandConfigType = atoi(args[2]) ? BAND_CONFIG_ACS_MODE : 0;
            else
                tlv->BandConfigType = 0;
            endian_convert_tlv_header_out(tlv);
        }
        if (strcmp(args[0], "AP_MAC") == 0) {
            int ret;
            TLVBUF_AP_MAC_ADDRESS *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_AP_MAC_ADDRESS);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append channel TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_AP_MAC_ADDRESS *) (buffer + cmd_len);
            cmd_len += tlv_len;
            cmd_buf->Action = ACTION_SET;
            tlv->Tag = MRVL_AP_MAC_ADDRESS_TLV_ID;
            tlv->Length = ETH_ALEN;
            if ((ret = mac2raw(args[1], tlv->ApMacAddr)) != UAP_SUCCESS) {
                printf("ERR: %s Address \n",
                       ret == UAP_FAILURE ? "Invalid MAC" : ret ==
                       UAP_RET_MAC_BROADCAST ? "Broadcast" : "Multicast");
                goto done;
            }
            endian_convert_tlv_header_out(tlv);
        }

        if (strcmp(args[0], "RxAntenna") == 0) {
            if ((ISDIGIT(args[1]) != UAP_SUCCESS) || (atoi(args[1]) < 0) ||
                (atoi(args[1]) > 1)) {
                printf("ERR: Invalid Antenna value\n");
                goto done;
            }
            TLVBUF_ANTENNA_CTL *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_ANTENNA_CTL);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append channel TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_ANTENNA_CTL *) (buffer + cmd_len);
            cmd_len += tlv_len;
            cmd_buf->Action = ACTION_SET;
            tlv->Tag = MRVL_ANTENNA_CTL_TLV_ID;
            tlv->Length = 2;
            tlv->WhichAntenna = 0;
            tlv->AntennaMode = atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
        }

        if (strcmp(args[0], "TxAntenna") == 0) {
            if ((ISDIGIT(args[1]) != UAP_SUCCESS) || (atoi(args[1]) < 0) ||
                (atoi(args[1]) > 1)) {
                printf("ERR: Invalid Antenna value\n");
                goto done;
            }
            TLVBUF_ANTENNA_CTL *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_ANTENNA_CTL);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append channel TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_ANTENNA_CTL *) (buffer + cmd_len);
            cmd_len += tlv_len;
            cmd_buf->Action = ACTION_SET;
            tlv->Tag = MRVL_ANTENNA_CTL_TLV_ID;
            tlv->Length = 2;
            tlv->WhichAntenna = 1;
            tlv->AntennaMode = atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
        }
        if (strcmp(args[0], "Rate") == 0) {
            if (is_input_valid(RATE, arg_num - 1, args + 1) != UAP_SUCCESS) {
                printf("ERR: Invalid Rate input\n");
                goto done;
            }
            TLVBUF_RATES *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_RATES) + arg_num - 1;
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append rates TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_RATES *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_RATES_TLV_ID;
            tlv->Length = arg_num - 1;
            for (i = 0; i < tlv->Length; i++) {
                rate[i] = tlv->OperationalRates[i] =
                    (u8) A2HEXDECIMAL(args[i + 1]);
            }
            endian_convert_tlv_header_out(tlv);
        }
        if (strcmp(args[0], "TxPowerLevel") == 0) {
            if (is_input_valid(TXPOWER, arg_num - 1, args + 1) != UAP_SUCCESS) {
                printf("ERR:Invalid TxPowerLevel \n");
                goto done;
            } else {
                TLVBUF_TX_POWER *tlv = NULL;
                /* Append a new TLV */
                tlv_len = sizeof(TLVBUF_TX_POWER);
                buffer = realloc(buffer, cmd_len + tlv_len);
                if (!buffer) {
                    printf("ERR:Cannot append tx power level TLV!\n");
                    goto done;
                }
                cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
                tlv = (TLVBUF_TX_POWER *) (buffer + cmd_len);
                cmd_len += tlv_len;
                /* Set TLV fields */
                tlv->Tag = MRVL_TX_POWER_TLV_ID;
                tlv->Length = 1;
                tlv->TxPower_dBm = (u8) atoi(args[1]);
                endian_convert_tlv_header_out(tlv);
            }
        }
        if (strcmp(args[0], "BroadcastSSID") == 0) {
            if (is_input_valid(BROADCASTSSID, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            TLVBUF_BCAST_SSID_CTL *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_BCAST_SSID_CTL);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append SSID broadcast control TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_BCAST_SSID_CTL *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_BCAST_SSID_CTL_TLV_ID;
            tlv->Length = 1;
            tlv->BcastSsidCtl = (u8) atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
        }
        if (strcmp(args[0], "RTSThreshold") == 0) {
            if (is_input_valid(RTSTHRESH, arg_num - 1, args + 1) != UAP_SUCCESS) {
                goto done;
            }
            TLVBUF_RTS_THRESHOLD *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_RTS_THRESHOLD);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append RTS threshold TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_RTS_THRESHOLD *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_RTS_THRESHOLD_TLV_ID;
            tlv->Length = 2;
            tlv->RtsThreshold = (u16) atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
            tlv->RtsThreshold = uap_cpu_to_le16(tlv->RtsThreshold);
        }
        if (strcmp(args[0], "FragThreshold") == 0) {
            if (is_input_valid(FRAGTHRESH, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            TLVBUF_FRAG_THRESHOLD *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_FRAG_THRESHOLD);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append Fragmentation threshold TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_FRAG_THRESHOLD *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_FRAG_THRESHOLD_TLV_ID;
            tlv->Length = 2;
            tlv->FragThreshold = (u16) atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
            tlv->FragThreshold = uap_cpu_to_le16(tlv->FragThreshold);
        }
        if (strcmp(args[0], "DTIMPeriod") == 0) {
            if (is_input_valid(DTIMPERIOD, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            TLVBUF_DTIM_PERIOD *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_DTIM_PERIOD);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append DTIM period TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_DTIM_PERIOD *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_DTIM_PERIOD_TLV_ID;
            tlv->Length = 1;
            tlv->DtimPeriod = (u8) atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
        }
        if (strcmp(args[0], "RadioControl") == 0) {
            if (is_input_valid(RADIOCONTROL, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            TLVBUF_RADIO_CTL *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_RADIO_CTL);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append radio control TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_RADIO_CTL *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_RADIO_CTL_TLV_ID;
            tlv->Length = 1;
            tlv->RadioCtl = (u8) atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
        }
        if (strcmp(args[0], "RSNReplayProtection") == 0) {
            if (is_input_valid(RSNREPLAYPROT, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            tlvbuf_rsn_replay_prot *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(tlvbuf_rsn_replay_prot);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append RSN replay protection TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (tlvbuf_rsn_replay_prot *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_RSN_REPLAY_PROT_TLV_ID;
            tlv->Length = 1;
            tlv->rsn_replay_prot = (u8) atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
        }
        if (strcmp(args[0], "TxDataRate") == 0) {
            if (is_input_valid(TXDATARATE, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            tx_data_rate = (u16) A2HEXDECIMAL(args[1]);
        }
        if (strcmp(args[0], "MCBCdataRate") == 0) {
            if (is_input_valid(MCBCDATARATE, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            mcbc_data_rate = (u16) A2HEXDECIMAL(args[1]);
        }
        if (strcmp(args[0], "PktFwdCtl") == 0) {
            if (is_input_valid(PKTFWD, arg_num - 1, args + 1) != UAP_SUCCESS) {
                goto done;
            }
            TLVBUF_PKT_FWD_CTL *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_PKT_FWD_CTL);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append packet forwarding control TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_PKT_FWD_CTL *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_PKT_FWD_CTL_TLV_ID;
            tlv->Length = 1;
            tlv->PktFwdCtl = (u8) atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
        }
        if (strcmp(args[0], "StaAgeoutTimer") == 0) {
            if (is_input_valid(STAAGEOUTTIMER, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            TLVBUF_STA_AGEOUT_TIMER *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_STA_AGEOUT_TIMER);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append STA ageout timer TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_STA_AGEOUT_TIMER *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_STA_AGEOUT_TIMER_TLV_ID;
            tlv->Length = 4;
            tlv->StaAgeoutTimer_ms = (u32) atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
            tlv->StaAgeoutTimer_ms = uap_cpu_to_le32(tlv->StaAgeoutTimer_ms);
        }
        if (strcmp(args[0], "AuthMode") == 0) {
            if (is_input_valid(AUTHMODE, arg_num - 1, args + 1) != UAP_SUCCESS) {
                goto done;
            }
            TLVBUF_AUTH_MODE *tlv = NULL;
            if ((atoi(args[1]) < 0) || (atoi(args[1]) > 1)) {
                printf
                    ("ERR:Illegal AuthMode parameter. Must be either '0' or '1'.\n");
                goto done;
            }
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_AUTH_MODE);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append auth mode TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_AUTH_MODE *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_AUTH_TLV_ID;
            tlv->Length = 1;
            tlv->AuthMode = (u8) atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
        }
        if (strcmp(args[0], "KeyIndex") == 0) {
            if (arg_num == 1) {
                printf("KeyIndex is blank!\n");
                goto done;
            } else {
                if (ISDIGIT(args[1]) == 0) {
                    printf
                        ("ERR:Illegal KeyIndex parameter. Must be either '0', '1', '2', or '3'.\n");
                    goto done;
                }
                keyindex = atoi(args[1]);
                if ((keyindex < 0) || (keyindex > 3)) {
                    printf
                        ("ERR:Illegal KeyIndex parameter. Must be either '0', '1', '2', or '3'.\n");
                    goto done;
                }
            }
        }
        if (strncmp(args[0], "Key_", 4) == 0) {
            if (arg_num == 1) {
                printf("ERR:%s is blank!\n", args[0]);
                goto done;
            } else {
                TLVBUF_WEP_KEY *tlv = NULL;
                int key_len = 0;
                if (args[1][0] == '"') {
                    if ((strlen(args[1]) != 2) && (strlen(args[1]) != 7) &&
                        (strlen(args[1]) != 15)) {
                        printf("ERR:Wrong key length!\n");
                        goto done;
                    }
                    key_len = strlen(args[1]) - 2;
                } else {
                    if ((strlen(args[1]) != 0) && (strlen(args[1]) != 10) &&
                        (strlen(args[1]) != 26)) {
                        printf("ERR:Wrong key length!\n");
                        goto done;
                    }
                    if (UAP_FAILURE == ishexstring(args[1])) {
                        printf
                            ("ERR:Only hex digits are allowed when key length is 10 or 26\n");
                        goto done;
                    }
                    key_len = strlen(args[1]) / 2;
                }
                /* Append a new TLV */
                tlv_len = sizeof(TLVBUF_WEP_KEY) + key_len;
                buffer = realloc(buffer, cmd_len + tlv_len);
                if (!buffer) {
                    printf("ERR:Cannot append WEP key configurations TLV!\n");
                    goto done;
                }
                cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
                tlv = (TLVBUF_WEP_KEY *) (buffer + cmd_len);
                cmd_len += tlv_len;
                /* Set TLV fields */
                tlv->Tag = MRVL_WEP_KEY_TLV_ID;
                tlv->Length = key_len + 2;
                if (strcmp(args[0], "Key_0") == 0) {
                    tlv->KeyIndex = 0;
                } else if (strcmp(args[0], "Key_1") == 0) {
                    tlv->KeyIndex = 1;
                } else if (strcmp(args[0], "Key_2") == 0) {
                    tlv->KeyIndex = 2;
                } else if (strcmp(args[0], "Key_3") == 0) {
                    tlv->KeyIndex = 3;
                }
                if (keyindex == tlv->KeyIndex) {
                    tlv->IsDefault = 1;
                } else {
                    tlv->IsDefault = 0;
                }
                if (args[1][0] == '"') {
                    memcpy(tlv->Key, &args[1][1], strlen(args[1]) - 2);
                } else {
                    string2raw(args[1], tlv->Key);
                }
                endian_convert_tlv_header_out(tlv);
            }
        }
        if (strcmp(args[0], "PSK") == 0) {
            if (arg_num == 1) {
                printf("ERR:PSK is blank!\n");
                goto done;
            } else {
                TLVBUF_WPA_PASSPHRASE *tlv = NULL;
                if (args[1][0] == '"') {
                    args[1]++;
                }
                if (args[1][strlen(args[1]) - 1] == '"') {
                    args[1][strlen(args[1]) - 1] = '\0';
                }
                tlv_len = sizeof(TLVBUF_WPA_PASSPHRASE) + strlen(args[1]);
                if (strlen(args[1]) > MAX_WPA_PASSPHRASE_LENGTH) {
                    printf("ERR:PSK too long.\n");
                    goto done;
                }
                if (strlen(args[1]) < MIN_WPA_PASSPHRASE_LENGTH) {
                    printf("ERR:PSK too short.\n");
                    goto done;
                }
                if (strlen(args[1]) == MAX_WPA_PASSPHRASE_LENGTH) {
                    if (UAP_FAILURE == ishexstring(args[1])) {
                        printf
                            ("ERR:Only hex digits are allowed when passphrase's length is 64\n");
                        goto done;
                    }
                }
                /* Append a new TLV */
                buffer = realloc(buffer, cmd_len + tlv_len);
                if (!buffer) {
                    printf("ERR:Cannot append WPA passphrase TLV!\n");
                    goto done;
                }
                cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
                tlv = (TLVBUF_WPA_PASSPHRASE *) (buffer + cmd_len);
                cmd_len += tlv_len;
                /* Set TLV fields */
                tlv->Tag = MRVL_WPA_PASSPHRASE_TLV_ID;
                tlv->Length = strlen(args[1]);
                memcpy(tlv->Passphrase, args[1], tlv->Length);
                endian_convert_tlv_header_out(tlv);
            }
        }
        if (strcmp(args[0], "Protocol") == 0) {
            if (is_input_valid(PROTOCOL, arg_num - 1, args + 1) != UAP_SUCCESS) {
                goto done;
            }
            TLVBUF_PROTOCOL *tlv = NULL;
            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_PROTOCOL);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append protocol TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_PROTOCOL *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_PROTOCOL_TLV_ID;
            tlv->Length = 2;
            tlv->Protocol = (u16) atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
            tlv->Protocol = uap_cpu_to_le16(tlv->Protocol);
            if (atoi(args[1]) & (PROTOCOL_WPA | PROTOCOL_WPA2)) {
                TLVBUF_AKMP *tlv = NULL;
                /* Append a new TLV */
                tlv_len = sizeof(TLVBUF_AKMP);
                buffer = realloc(buffer, cmd_len + tlv_len);
                if (!buffer) {
                    printf("ERR:Cannot append AKMP TLV!\n");
                    goto done;
                }
                cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
                tlv = (TLVBUF_AKMP *) (buffer + cmd_len);
                cmd_len += tlv_len;
                /* Set TLV fields */
                tlv->Tag = MRVL_AKMP_TLV_ID;
                tlv->Length = 2;
                tlv->KeyMgmt = KEY_MGMT_PSK;
                endian_convert_tlv_header_out(tlv);
                tlv->KeyMgmt = uap_cpu_to_le16(tlv->KeyMgmt);
            }
        }
        if (strcmp(args[0], "PairwiseCipher") == 0) {
            if (arg_num == 1) {
                printf("ERR:PairwiseCipher is blank!\n");
                goto done;
            } else {
                if (ISDIGIT(args[1]) == 0) {
                    printf
                        ("ERR:Illegal PairwiseCipher parameter. Must be either bit '2' or '3'.\n");
                    goto done;
                }
                pairwisecipher = atoi(args[1]);
                if (pairwisecipher & ~CIPHER_BITMAP) {
                    printf
                        ("ERR:Illegal PairwiseCipher parameter. Must be either bit '2' or '3'.\n");
                    goto done;
                }
            }
        }
        if (strcmp(args[0], "GroupCipher") == 0) {
            if (arg_num == 1) {
                printf("ERR:GroupCipher is blank!\n");
                goto done;
            } else {
                if (ISDIGIT(args[1]) == 0) {
                    printf
                        ("ERR:Illegal GroupCipher parameter. Must be either bit '2' or '3'.\n");
                    goto done;
                }
                groupcipher = atoi(args[1]);
                if (groupcipher & ~CIPHER_BITMAP) {
                    printf
                        ("ERR:Illegal GroupCipher parameter. Must be either bit '2' or '3'.\n");
                    goto done;
                }
            }
        }
        if (strcmp(args[0], "GroupRekeyTime") == 0) {
            if (is_input_valid(GROUPREKEYTIMER, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            TLVBUF_GROUP_REKEY_TIMER *tlv = NULL;

            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_GROUP_REKEY_TIMER);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot append protocol TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_GROUP_REKEY_TIMER *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_GRP_REKEY_TIME_TLV_ID;
            tlv->Length = 4;
            tlv->GroupRekeyTime_sec = (u32) atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
            tlv->GroupRekeyTime_sec = uap_cpu_to_le32(tlv->GroupRekeyTime_sec);
        }
        if (strcmp(args[0], "MaxStaNum") == 0) {
            if (is_input_valid(MAXSTANUM, arg_num - 1, args + 1) != UAP_SUCCESS) {
                goto done;
            }
            TLVBUF_MAX_STA_NUM *tlv = NULL;

            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_MAX_STA_NUM);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot realloc max station number TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_MAX_STA_NUM *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_MAX_STA_CNT_TLV_ID;
            tlv->Length = 2;
            tlv->Max_sta_num = (u16) atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
            tlv->Max_sta_num = uap_cpu_to_le16(tlv->Max_sta_num);
        }
        if (strcmp(args[0], "Retrylimit") == 0) {
            if (is_input_valid(RETRYLIMIT, arg_num - 1, args + 1) !=
                UAP_SUCCESS) {
                goto done;
            }
            TLVBUF_RETRY_LIMIT *tlv = NULL;

            /* Append a new TLV */
            tlv_len = sizeof(TLVBUF_RETRY_LIMIT);
            buffer = realloc(buffer, cmd_len + tlv_len);
            if (!buffer) {
                printf("ERR:Cannot realloc retry limit TLV!\n");
                goto done;
            }
            cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buffer;
            tlv = (TLVBUF_RETRY_LIMIT *) (buffer + cmd_len);
            cmd_len += tlv_len;
            /* Set TLV fields */
            tlv->Tag = MRVL_RETRY_LIMIT_TLV_ID;
            tlv->Length = 1;
            tlv->retry_limit = (u8) atoi(args[1]);
            endian_convert_tlv_header_out(tlv);
        }
#if DEBUG
        if (cmd_len != 0) {
            hexdump("Command Buffer", (void *) cmd_buf, cmd_len, ' ');
        }
#endif
    }
  done:
    fclose(config_file);
    if (buffer)
        free(buffer);
    if (line)
        free(line);
}

/**
 *  @brief Show usage information for the cfg_80211d command
 *
 *  $return         N/A
 */
void
print_apcmd_cfg_80211d_usage(void)
{
    printf("\nUsage: cfg_80211d <state 0/1> <country Country_code> \n");
    return;
}

/**
 *  @brief Show usage information for the uap_stats command
 *
 *  $return         N/A
 */
void
print_apcmd_uap_stats(void)
{
    printf("Usage: uap_stats \n");
    return;
}

/**
 *  SNMP MIB OIDs Table
 */
static oids_table snmp_oids[] = {
    {0x0b, 4, "dot11LocalTKIPMICFailures"},
    {0x0c, 4, "dot11CCMPDecryptErrors"},
    {0x0d, 4, "dot11WEPUndecryptableCount"},
    {0x0e, 4, "dot11WEPICVErrorCount"},
    {0x0f, 4, "dot11DecryptFailureCount"},
    {0x12, 4, "dot11FailedCount"},
    {0x13, 4, "dot11RetryCount"},
    {0x14, 4, "dot11MultipleRetryCount"},
    {0x15, 4, "dot11FrameDuplicateCount"},
    {0x16, 4, "dot11RTSSuccessCount"},
    {0x17, 4, "dot11RTSFailureCount"},
    {0x18, 4, "dot11ACKFailureCount"},
    {0x19, 4, "dot11ReceivedFragmentCount"},
    {0x1a, 4, "dot11MulticastReceivedFrameCount"},
    {0x1b, 4, "dot11FCSErrorCount"},
    {0x1c, 4, "dot11TransmittedFrameCount"},
    {0x1d, 4, "dot11RSNATKIPCounterMeasuresInvoked"},
    {0x1e, 4, "dot11RSNA4WayHandshakeFailures"},
    {0x1f, 4, "dot11MulticastTransmittedFrameCount"}
};

/** 
 *  @brief Get uAP stats
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  
 *  @return         NA
 */
void
apcmd_uap_stats(int argc, char *argv[])
{
    u8 no_of_oids = sizeof(snmp_oids) / sizeof(snmp_oids[0]);
    u16 i, j;
    int size;
    APCMDBUF_SNMP_MIB *cmd_buf = NULL;
    u8 *buf = NULL;
    TLVBUF_HEADER *tlv = NULL;
    u16 cmd_len = 0;
    u16 buf_len = 0;
    u8 ret;
    int opt;
    u16 oid_size;

    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_apcmd_uap_stats();
            return;
        }
    }

    argc -= optind;
    argv += optind;
    if (argc) {
        printf("Error: Invalid Input\n");
        print_apcmd_uap_stats();
        return;
    }

    /**  Command Header */
    buf_len += sizeof(APCMDBUF_SNMP_MIB);

    for (i = 0; i < no_of_oids; i++) {
        /** 
         * size of Oid + Oid_value + Oid_size 
         */
        buf_len += snmp_oids[i].len + sizeof(TLVBUF_HEADER);
    }
    buf = (u8 *) malloc(buf_len);
    if (!buf) {
        printf("ERR:Cannot allocate buffer from command!\n");
        return;
    }
    bzero((char *) buf, buf_len);

    /* Locate Headers */
    cmd_buf = (APCMDBUF_SNMP_MIB *) buf;
    cmd_buf->Size = buf_len - BUF_HEADER_SIZE;
    cmd_buf->Result = 0;
    cmd_buf->SeqNum = 0;
    cmd_buf->CmdCode = HostCmd_SNMP_MIB;
    cmd_buf->Action = uap_cpu_to_le16(ACTION_GET);

    tlv = (TLVBUF_HEADER *) ((u8 *) cmd_buf + sizeof(APCMDBUF_SNMP_MIB));
    /* Add oid, oid_size and oid_value for each OID */
    for (i = 0; i < no_of_oids; i++) {
        /** Copy Index as Oid */
        tlv->Type = uap_cpu_to_le16(snmp_oids[i].type);
        /** Copy its size */
        tlv->Len = uap_cpu_to_le16(snmp_oids[i].len);
        /** Next TLV */
        tlv = (TLVBUF_HEADER *) & (tlv->Data[snmp_oids[i].len]);
    }
    cmd_len = buf_len;
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, buf_len);
    if (ret == UAP_SUCCESS) {
        if (cmd_buf->Result == CMD_SUCCESS) {
            tlv =
                (TLVBUF_HEADER *) ((u8 *) cmd_buf + sizeof(APCMDBUF_SNMP_MIB));

            size =
                cmd_buf->Size - (sizeof(APCMDBUF_SNMP_MIB) - BUF_HEADER_SIZE);

            while (size >= sizeof(TLVBUF_HEADER)) {
                tlv->Type = uap_le16_to_cpu(tlv->Type);
                for (i = 0; i < no_of_oids; i++) {
                    if (snmp_oids[i].type == tlv->Type) {
                        printf("%s: ", snmp_oids[i].name);
                        break;
                    }
                }
                oid_size = uap_le16_to_cpu(tlv->Len);
                switch (oid_size) {
                case 1:
                    printf("%d", (unsigned int) tlv->Data[0]);
                    break;
                case 2:
                    printf("%d",
                           (unsigned int) uap_le16_to_cpu(*(u16 *) tlv->Data));
                    break;
                case 4:
                    printf("%ld",
                           (unsigned long) uap_le32_to_cpu(*(u32 *) tlv->Data));
                    break;
                default:
                    for (j = 0; j < oid_size; j++) {
                        printf("%d ", (u8) tlv->Data[i]);
                    }
                    break;
                }
                /** Next TLV */
                tlv = (TLVBUF_HEADER *) & (tlv->Data[oid_size]);
                size -= (sizeof(TLVBUF_HEADER) + oid_size);
                size = (size > 0) ? size : 0;
                printf("\n");
            }

        } else {
            printf("ERR:Command Response incorrect!\n");
        }
    } else {
        printf("ERR:Command sending failed!\n");
    }
    free(buf);
}

/**
 *  @brief parser for sys_cfg_80211d input 
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @param output   stores indexes for "state, country"
 *                  arguments
 *
 *  @return         NA
 *
 */
void
parse_input_80211d(int argc, char **argv, int output[2][2])
{
    int i, j, k = 0;
    char *keywords[2] = { "state", "country" };

    for (i = 0; i < 2; i++)
        output[i][0] = -1;

    for (i = 0; i < argc; i++) {
        for (j = 0; j < 2; j++) {
            if (strcmp(argv[i], keywords[j]) == 0) {
                output[j][1] = output[j][0] = i;
                k = j;
                break;
            }
        }
        output[k][1] += 1;
    }
}

/**
 *  @brief Set/Get 802.11D country information 
 *
 *  Usage: cfg_80211d state country_code 
 *  
 *  State 0 or 1
 *  
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         N/A
 */
void
apcmd_cfg_80211d(int argc, char *argv[])
{
    APCMDBUF_CFG_80211D *cmd_buf = NULL;
    IEEEtypes_SubbandSet_t *subband = NULL;
    u8 *buf = NULL;
    u16 cmd_len;
    u16 buf_len;
    int output[2][2];
    int ret = UAP_FAILURE;
    int opt;
    int i, j;
    u8 state = 0;
    char country[4] = { ' ', ' ', 0, 0 };
    u8 sflag = 0, cflag = 0;
    IEEEtypes_SubbandSet_t sub_bands[MAX_SUB_BANDS];
    u8 no_of_sub_band = 0;

    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_apcmd_cfg_80211d_usage();
            return;
        }
    }
    argc -= optind;
    argv += optind;

    if (argc) {
        /** SET */
        parse_input_80211d(argc, argv, output);

        /** state */
        if ((output[0][0] != -1) && (output[0][1] > output[0][0])) {
            if ((output[0][1] - output[0][0]) != 2) {
                printf("ERR: Invalid state inputs\n");
                print_apcmd_cfg_80211d_usage();
                return;
            }

            if (IS_HEX_OR_DIGIT(argv[output[0][0] + 1]) == UAP_FAILURE) {
                printf("ERR: valid input for state are 0 or 1\n");
                print_apcmd_cfg_80211d_usage();
                return;
            }
            state = (u8) A2HEXDECIMAL(argv[output[0][0] + 1]);

            if ((state != 0) && (state != 1)) {
                printf("ERR: valid input for state are 0 or 1 \n");
                print_apcmd_cfg_80211d_usage();
                return;
            }
            sflag = 1;
        }

        /** country */
        if ((output[1][0] != -1) && (output[1][1] > output[1][0])) {
            if ((output[1][1] - output[1][0]) > 2) {
                printf("ERR: Invalid country inputs\n");
                print_apcmd_cfg_80211d_usage();
                return;
            }
            if ((strlen(argv[output[1][0] + 1]) > 3) ||
                (strlen(argv[output[1][0] + 1]) < 0)) {
                print_apcmd_cfg_80211d_usage();
                return;
            }

            strcpy(country, argv[output[1][0] + 1]);

            for (i = 0; i < strlen(country); i++) {
                if ((country[i] < 'A') || (country[i] > 'z')) {
                    printf("Invalid Country Code\n");
                    print_apcmd_cfg_80211d_usage();
                    return;
                }
                if (country[i] > 'Z')
                    country[i] = country[i] - 'a' + 'A';
            }

            cflag = 1;

           /** Get domain information from the file */
            no_of_sub_band = parse_domain_file(country, sub_bands);
            if (no_of_sub_band == UAP_FAILURE) {
                printf("Parsing Failed\n");
                return;
            }
        }
    }

    if (argc && !cflag && !sflag) {
        printf("ERR: Invalid input\n");
        print_apcmd_cfg_80211d_usage();
        return;
    }

    if (sflag && !cflag) {
        /**
         * Update MIB only and return
         */
        if (sg_snmp_mib(ACTION_SET, OID_80211D_ENABLE, sizeof(state), &state) ==
            UAP_SUCCESS) {
            printf("802.11d %sd \n", state ? "enable" : "disable");
        }
        return;
    }

    buf_len = sizeof(APCMDBUF_CFG_80211D);

    if (cflag) {
        buf_len += no_of_sub_band * sizeof(IEEEtypes_SubbandSet_t);
    } else { /** Get */
        buf_len += MAX_SUB_BANDS * sizeof(IEEEtypes_SubbandSet_t);
    }

    buf = (u8 *) malloc(buf_len);
    if (!buf) {
        printf("ERR:Cannot allocate buffer from command!\n");
        return;
    }
    bzero((char *) buf, buf_len);
    /* Locate headers */
    cmd_buf = (APCMDBUF_CFG_80211D *) buf;
    cmd_len = argc ? buf_len :
                 /** set */
        (sizeof(APCMDBUF_CFG_80211D) - sizeof(domain_param_t)); /** Get */

    cmd_buf->Size = cmd_len - BUF_HEADER_SIZE;
    cmd_buf->Result = 0;
    cmd_buf->SeqNum = 0;
    cmd_buf->Action = argc ? ACTION_SET : ACTION_GET;
    cmd_buf->Action = uap_cpu_to_le16(cmd_buf->Action);
    cmd_buf->CmdCode = HostCmd_CMD_802_11D_DOMAIN_INFO;

    if (cflag) {
        cmd_buf->Domain.Tag = uap_cpu_to_le16(TLV_TYPE_DOMAIN);
        cmd_buf->Domain.Length = uap_cpu_to_le16(sizeof(domain_param_t)
                                                 - BUF_HEADER_SIZE
                                                 +
                                                 (no_of_sub_band *
                                                  sizeof
                                                  (IEEEtypes_SubbandSet_t)));

        memset(cmd_buf->Domain.CountryCode, ' ',
               sizeof(cmd_buf->Domain.CountryCode));
        memcpy(cmd_buf->Domain.CountryCode, country, strlen(country));
        memcpy(cmd_buf->Domain.Subband, sub_bands,
               no_of_sub_band * sizeof(IEEEtypes_SubbandSet_t));
    }

    /* Send the command */
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, buf_len);
    if (ret == UAP_SUCCESS) {
        if (cmd_buf->Result == CMD_SUCCESS) {
            if (argc) {
                printf("Set executed successfully\n");
                if (sflag) {
                    if (sg_snmp_mib
                        (ACTION_SET, OID_80211D_ENABLE, sizeof(state),
                         &state) == UAP_SUCCESS) {
                        printf("802.11d %sd \n", state ? "enable" : "disable");
                    }
                }
            } else {
                j = uap_le16_to_cpu(cmd_buf->Domain.Length);
                if (sg_snmp_mib
                    (ACTION_GET, OID_80211D_ENABLE, sizeof(state), &state)
                    == UAP_SUCCESS) {
                    printf("State = %sd\n", state ? "enable" : "disable");
                }

                if (!(cmd_buf->Domain.CountryCode[0] |
                      cmd_buf->Domain.CountryCode[1] |
                      cmd_buf->Domain.CountryCode[2])) {
                    printf("Dot11d = country code is not set.\n");
                } else {
                    printf("Country string = %c%c%c",
                           cmd_buf->Domain.CountryCode[0],
                           cmd_buf->Domain.CountryCode[1],
                           cmd_buf->Domain.CountryCode[2]);
                    j -= sizeof(cmd_buf->Domain.CountryCode);
                    subband =
                        (IEEEtypes_SubbandSet_t *) cmd_buf->Domain.Subband;
                    printf("\nSub-band info=");
                    // printf("\n\t\t(First Channel, Number of Channels,
                    // Maximum TX Power) \n"); 
                    printf("\t(1st, #chan, MAX-power) \n");
                    for (i = 0; i < (j / 3); i++) {
                        printf("\t\t(%d, \t%d, \t%d dbm)\n", subband->FirstChan,
                               subband->NoOfChan, subband->MaxTxPwr);
                        subband++;
                    }
                }
            }
        } else {
            printf("ERR:Command Response incorrect!\n");
        }
    } else {
        printf("ERR:Command sending failed!\n");
    }
    free(buf);
    return;
}

/** 
 *  @brief Creates a sys_config request and sends to the driver
 *
 *  Usage: "Usage : sys_config [CONFIG_FILE]"
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         UAP_SUCCESS or UAP_FAILURE
 */
void
apcmd_sys_config(int argc, char *argv[])
{
    APCMDBUF_SYS_CONFIGURE *cmd_buf = NULL;
    u8 *buf = NULL;
    u16 cmd_len;
    u16 buf_len;
    int ret = UAP_FAILURE;
    int opt;
    char **argv_dummy;
    ps_mgmt pm;

    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_sys_config_usage();
            return;
        }
    }
    argc -= optind;
    argv += optind;

    /* Check arguments */
    if (argc > 1) {
        printf("ERR:Too many arguments.\n");
        print_sys_config_usage();
        return;
    }
    if (argc == 1) {
        /* Read profile and send command to firmware */
        apcmd_sys_config_profile(argc, argv);
        return;
    }

        /** Query AP's setting */
    buf_len = MRVDRV_SIZE_OF_CMD_BUFFER;

    /* alloc buf for command */
    buf = (u8 *) malloc(buf_len);

    if (!buf) {
        printf("ERR:Cannot allocate buffer from command!\n");
        return;
    }
    bzero((char *) buf, buf_len);

    /* Locate headers */
    cmd_len = sizeof(APCMDBUF_SYS_CONFIGURE);
    cmd_buf = (APCMDBUF_SYS_CONFIGURE *) buf;

    /* Fill the command buffer */
    cmd_buf->CmdCode = APCMD_SYS_CONFIGURE;
    cmd_buf->Size = cmd_len - BUF_HEADER_SIZE;
    cmd_buf->SeqNum = 0;
    cmd_buf->Result = 0;

    /* Send the command */
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, buf_len);

    /* Process response */
    if (ret == UAP_SUCCESS) {
        /* Verify response */
        if (cmd_buf->CmdCode != (APCMD_SYS_CONFIGURE | APCMD_RESP_CHECK)) {
            printf("ERR:Corrupted response!\n");
            free(buf);
            return;
        }
        /* Print response */
        if (cmd_buf->Result == CMD_SUCCESS) {
            printf("AP settings:\n");
            print_tlv(buf + sizeof(APCMDBUF_SYS_CONFIGURE),
                      cmd_buf->Size - sizeof(APCMDBUF_SYS_CONFIGURE) +
                      BUF_HEADER_SIZE);
            printf("\n802.11D setting:\n");
            apcmd_cfg_80211d(1, argv_dummy);
        } else {
            printf("ERR:Could not retrieve system configure\n");
        }
    } else {
        printf("ERR:Command sending failed!\n");
    }
    free(buf);
    memset(&pm, 0, sizeof(ps_mgmt));
    send_power_mode_ioctl(&pm);
    return;
}

/** 
 *  @brief Send read/write command along with register details to the driver
 *  @param reg      reg type
 *  @param offset   pointer to register offset string
 *  @param strvalue pointer to value string
 *  @return         UAP_SUCCESS or UAP_FAILURE
 */
int
apcmd_regrdwr_process(int reg, s8 * offset, s8 * strvalue)
{
    APCMDBUF_REG_RDWR *cmd_buf = NULL;
    u8 *buf = NULL;
    u16 cmd_len;
    u16 buf_len;
    int ret = UAP_FAILURE;
    s8 *whichreg;

    buf_len = sizeof(APCMDBUF_REG_RDWR);

    /* alloc buf for command */
    buf = (u8 *) malloc(buf_len);

    if (!buf) {
        printf("ERR:Cannot allocate buffer from command!\n");
        return UAP_FAILURE;
    }
    bzero((char *) buf, buf_len);

    /* Locate headers */
    cmd_len = sizeof(APCMDBUF_REG_RDWR);
    cmd_buf = (APCMDBUF_REG_RDWR *) buf;

    /* Fill the command buffer */
    cmd_buf->Size = cmd_len - BUF_HEADER_SIZE;
    cmd_buf->SeqNum = 0;
    cmd_buf->Result = 0;

    switch (reg) {
    case CMD_MAC:
        whichreg = "MAC";
        cmd_buf->CmdCode = HostCmd_CMD_MAC_REG_ACCESS;
        break;
    case CMD_BBP:
        whichreg = "BBP";
        cmd_buf->CmdCode = HostCmd_CMD_BBP_REG_ACCESS;
        break;
    case CMD_RF:
        cmd_buf->CmdCode = HostCmd_CMD_RF_REG_ACCESS;
        whichreg = "RF";
        break;
    default:
        printf("Invalid register set specified.\n");
        free(buf);
        return UAP_FAILURE;
    }
    if (strvalue) {
        cmd_buf->Action = 1;    // WRITE
    } else {
        cmd_buf->Action = 0;    // READ
    }
    cmd_buf->Action = uap_cpu_to_le16(cmd_buf->Action);
    cmd_buf->Offset = A2HEXDECIMAL(offset);
    cmd_buf->Offset = uap_cpu_to_le16(cmd_buf->Offset);
    if (strvalue) {
        cmd_buf->Value = A2HEXDECIMAL(strvalue);
        cmd_buf->Value = uap_cpu_to_le32(cmd_buf->Value);
    }

    /* Send the command */
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, buf_len);

    /* Process response */
    if (ret == UAP_SUCCESS) {
        if (cmd_buf->Result == CMD_SUCCESS) {
            printf("Successfully executed the command\n");
            printf("%s[0x%04hx] = 0x%08lx\n",
                   whichreg, uap_le16_to_cpu(cmd_buf->Offset),
                   uap_le32_to_cpu(cmd_buf->Value));
        } else {
            printf("ERR:Command sending failed!\n");
            free(buf);
            return UAP_FAILURE;
        }
    } else {
        printf("ERR:Command sending failed!\n");
        free(buf);
        return UAP_FAILURE;
    }

    free(buf);
    return UAP_SUCCESS;
}

/**
 *  @brief Send read command for EEPROM 
 *
 *  Usage: "Usage : rdeeprom <offset> <byteCount>"
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         N/A
 */
void
apcmd_read_eeprom(int argc, char *argv[])
{
    APCMDBUF_EEPROM_ACCESS *cmd_buf = NULL;
    u8 *buf = NULL;
    u16 cmd_len;
    u16 buf_len;
    u16 byteCount, offset;
    int ret = UAP_FAILURE;
    int opt;
    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_apcmd_read_eeprom_usage();
            return;
        }
    }
    argc -= optind;
    argv += optind;

    /* Check arguments */
    if (!argc || (argc && is_input_valid(RDEEPROM, argc, argv) != UAP_SUCCESS)) {
        print_apcmd_read_eeprom_usage();
        return;
    }
    offset = A2HEXDECIMAL(argv[0]);
    byteCount = A2HEXDECIMAL(argv[1]);

    buf_len = sizeof(APCMDBUF_EEPROM_ACCESS) + MAX_EEPROM_LEN;
    buf = (u8 *) malloc(buf_len);
    if (!buf) {
        printf("ERR:Cannot allocate buffer from command!\n");
        return;
    }
    bzero((char *) buf, buf_len);

    /* Locate headers */
    cmd_buf = (APCMDBUF_EEPROM_ACCESS *) buf;
    cmd_len = sizeof(APCMDBUF_EEPROM_ACCESS);

    cmd_buf->Size = sizeof(APCMDBUF_EEPROM_ACCESS) - BUF_HEADER_SIZE;
    cmd_buf->Result = 0;
    cmd_buf->SeqNum = 0;
    cmd_buf->Action = 0;

    cmd_buf->CmdCode = HostCmd_EEPROM_ACCESS;
    cmd_buf->Offset = uap_cpu_to_le16(offset);
    cmd_buf->ByteCount = uap_cpu_to_le16(byteCount);

    /* Send the command */
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, buf_len);

    /* Process response */
    if (ret == UAP_SUCCESS) {
        if (cmd_buf->Result == CMD_SUCCESS) {
            printf("Successfully executed the command\n");
            byteCount = uap_le16_to_cpu(cmd_buf->ByteCount);
            offset = uap_le16_to_cpu(cmd_buf->Offset);
            hexdump_data("EEPROM", (void *) cmd_buf->Value, byteCount, ' ');
        } else {
            printf("ERR:Command Response incorrect!\n");
        }
    } else {
        printf("ERR:Command sending failed!\n");
    }

    free(buf);
    return;
}

/**
 *  @brief Show usage information for the regrdwr command
 *  command
 *
 *  $return         N/A
 */
void
print_regrdwr_usage(void)
{
    printf("\nUsage : uaputl regrdwr <TYPE> <OFFSET> [value]\n");
    printf("\nTYPE Options: 0     - read/write MAC register");
    printf("\n              1     - read/write BBP register");
    printf("\n              2     - read/write RF register");
    printf("\n");
    return;

}

/** 
 *  @brief Provides interface to perform read/write operations on regsiters
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         N/A
 */
void
apcmd_regrdwr(int argc, char *argv[])
{
    int opt;
    s32 reg;
    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_regrdwr_usage();
            return;
        }
    }
    argc -= optind;
    argv += optind;

    /* Check arguments */
    if ((argc < 2) || (argc > 3)) {
        printf("ERR:wrong arguments.\n");
        print_regrdwr_usage();
        return;
    }
    if ((atoi(argv[0]) != 0) && (atoi(argv[0]) != 1) && (atoi(argv[0]) != 2)) {
        printf("ERR:Illegal register type %s. Must be either '0','1' or '2'.\n",
               argv[0]);
        print_regrdwr_usage();
        return;
    }
    reg = atoi(argv[0]);
    apcmd_regrdwr_process(reg, argv[1], argc > 2 ? argv[2] : NULL);
    return;
}

/**
 *    @brief Show usage information for the memaccess command
 *    command
 *    
 *    $return         N/A
 */
void
print_memaccess_usage(void)
{
    printf("\nUsage : uaputl memaccess <ADDRESS> [value]\n");
    printf("\nRead/Write memory location");
    printf("\nADDRESS: Address of the memory location to be read/written");
    printf("\nValue  : Value to be written at that address\n");
    return;
}

/** 
 *  @brief Provides interface to perform read/write memory location
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         N/A
 */
void
apcmd_memaccess(int argc, char *argv[])
{
    int opt;
    APCMDBUF_MEM_ACCESS *cmd_buf = NULL;
    u8 *buf = NULL;
    u16 cmd_len;
    u16 buf_len;
    int ret = UAP_FAILURE;
    s8 *address = NULL;
    s8 *value = NULL;

    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_memaccess_usage();
            return;
        }
    }
    argc -= optind;
    argv += optind;

    /* Check arguments */
    if ((argc < 1) || (argc > 2)) {
        printf("ERR:wrong arguments.\n");
        print_memaccess_usage();
        return;
    }

    address = argv[0];
    if (argc == 2)
        value = argv[1];

    buf_len = sizeof(APCMDBUF_MEM_ACCESS);

    /* alloc buf for command */
    buf = (u8 *) malloc(buf_len);

    if (!buf) {
        printf("ERR:Cannot allocate buffer from command!\n");
        return;
    }
    bzero((char *) buf, buf_len);
    /* Locate headers */
    cmd_len = sizeof(APCMDBUF_MEM_ACCESS);
    cmd_buf = (APCMDBUF_MEM_ACCESS *) buf;

    /* Fill the command buffer */
    cmd_buf->Size = cmd_len - BUF_HEADER_SIZE;
    cmd_buf->SeqNum = 0;
    cmd_buf->Result = 0;
    cmd_buf->CmdCode = HostCmd_CMD_MEM_ACCESS;

    if (value)
        cmd_buf->Action = 1;    // WRITE
    else
        cmd_buf->Action = 0;    // READ

    cmd_buf->Action = uap_cpu_to_le16(cmd_buf->Action);
    cmd_buf->Address = A2HEXDECIMAL(address);
    cmd_buf->Address = uap_cpu_to_le32(cmd_buf->Address);

    if (value) {
        cmd_buf->Value = A2HEXDECIMAL(value);
        cmd_buf->Value = uap_cpu_to_le32(cmd_buf->Value);
    }

    /* Send the command */
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, buf_len);

    /* Process response */
    if (ret == UAP_SUCCESS) {
        if (cmd_buf->Result == CMD_SUCCESS) {
            printf("Successfully executed the command\n");
            printf("[0x%04lx] = 0x%08lx\n",
                   uap_le32_to_cpu(cmd_buf->Address),
                   uap_le32_to_cpu(cmd_buf->Value));
        } else {
            printf("ERR:Command sending failed!\n");
            free(buf);
            return;
        }
    } else {
        printf("ERR:Command sending failed!\n");
        free(buf);
        return;
    }
    free(buf);
    return;
}

/**
 *    @brief Show usage information for sys_debug command
 *    command
 *    
 *    $return         N/A
 */
void
print_sys_debug_usage(void)
{
    printf("\nUsage : uaputl sys_debug <subcmd> [parameter]\n");
    printf("\nSet/Get debug parameter");
    printf("\nsubcmd: used to set/get debug parameters or set user scan");
    printf("\nparameter  :  parameters for specific subcmd");
    printf("\n		If no [parameter] are given, it return");
    printf("\n		debug parameters for selected subcmd");
    printf("\n\n");
    return;
}

/** 
 *  @brief Creates a sys_debug request and sends to the driver
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         N/A
 */
void
apcmd_sys_debug(int argc, char *argv[])
{
    APCMDBUF_SYS_DEBUG *cmd_buf = NULL;
    u8 *buffer = NULL;
    u16 cmd_len;
    u16 buf_len;
    u32 subcmd = 0;
    int ret = UAP_FAILURE;
    int opt;
    s8 *value = NULL;
    u32 parameter = 0;
    while ((opt = getopt_long(argc, argv, "+", cmd_options, NULL)) != -1) {
        switch (opt) {
        default:
            print_sys_debug_usage();
            return;
        }
    }
    argc -= optind;
    argv += optind;
    /* Check arguments */
    if ((argc == 0) || (argc > 2)) {
        printf("ERR:wrong arguments.\n");
        print_sys_debug_usage();
        return;
    } else {
        if (argc == 2) {
            value = argv[1];
            parameter = A2HEXDECIMAL(value);
        }
    }
    subcmd = atoi(argv[0]);
    /* Initialize the command length */
    if (subcmd == DEBUG_SUBCOMMAND_CHANNEL_SCAN) {
        buf_len =
            sizeof(APCMDBUF_SYS_DEBUG) +
            MAX_CHANNELS * sizeof(CHANNEL_SCAN_ENTRY_T);
        cmd_len = sizeof(APCMDBUF_SYS_DEBUG) - sizeof(debugConfig_t);
    } else {
        cmd_len = sizeof(APCMDBUF_SYS_DEBUG);
        buf_len = cmd_len;
    }

    /* Initialize the command buffer */
    buffer = (u8 *) malloc(buf_len);
    if (!buffer) {
        printf("ERR:Cannot allocate buffer for command!\n");
        return;
    }
    bzero((char *) buffer, buf_len);

    /* Locate headers */
    cmd_buf = (APCMDBUF_SYS_DEBUG *) buffer;

    /* Fill the command buffer */
    cmd_buf->CmdCode = APCMD_SYS_DEBUG;
    cmd_buf->Size = cmd_len - BUF_HEADER_SIZE;
    cmd_buf->SeqNum = 0;
    cmd_buf->Result = 0;
    cmd_buf->subcmd = subcmd;
    if (subcmd == DEBUG_SUBCOMMAND_CHANNEL_SCAN) {
        cmd_buf->Action = ACTION_SET;
    } else {
        if (argc == 1) {
            cmd_buf->Action = ACTION_GET;
        } else {
            cmd_buf->Action = ACTION_SET;
            if (subcmd == DEBUG_SUBCOMMAND_GMODE)
                cmd_buf->debugConfig.globalDebugMode = (u8) parameter;
            else if (subcmd == DEBUG_SUBCOMMAND_MAJOREVTMASK) {
                cmd_buf->debugConfig.debugMajorIdMask = parameter;
                cmd_buf->debugConfig.debugMajorIdMask =
                    uap_cpu_to_le32(cmd_buf->debugConfig.debugMajorIdMask);
            } else {
                cmd_buf->debugConfig.value = uap_cpu_to_le32(parameter);
            }
        }
    }
    cmd_buf->Action = uap_cpu_to_le16(cmd_buf->Action);
    cmd_buf->subcmd = uap_cpu_to_le32(cmd_buf->subcmd);

    /* Send the command */
    ret = uap_ioctl((u8 *) cmd_buf, &cmd_len, buf_len);

    /* Process response */
    if (ret == UAP_SUCCESS) {
        /* Verify response */
        if (cmd_buf->CmdCode != (APCMD_SYS_DEBUG | APCMD_RESP_CHECK)) {
            printf("ERR:Corrupted response! CmdCode=%x\n", cmd_buf->CmdCode);
            free(buffer);
            return;
        }
        /* Print response */
        if (cmd_buf->Result == CMD_SUCCESS) {
            if (subcmd == DEBUG_SUBCOMMAND_CHANNEL_SCAN) {
                int i = 0;
                CHANNEL_SCAN_ENTRY_T *cst = NULL;
                if (cmd_buf->Size <
                    (sizeof(APCMDBUF_SYS_DEBUG) - BUF_HEADER_SIZE)) {
                    printf
                        ("ERR: Invalid command response size, cmd_buf->Size = %x\n",
                         cmd_buf->Size);
                    free(buffer);
                    return;
                }
                for (i = 0; i < cmd_buf->debugConfig.cs_entry.numChannels; i++) {
                    if (i == 0) {
                        printf
                            ("\n------------------------------------------------------");
                        printf("\nChan\tNumAPs\tCCA_Count\tDuration\tWeight");
                        printf
                            ("\n------------------------------------------------------");
                        cst = cmd_buf->debugConfig.cs_entry.cst;
                    }
                    printf("\n%d\t%d\t%ld\t\t%ld\t\t%ld", cst->chan_num,
                           cst->num_of_aps,
                           cst->CCA_count, cst->duration, cst->channel_weight);
                    cst++;
                }
                printf
                    ("\n------------------------------------------------------\n");
            } else {
                if (argc == 1) {
                    if (subcmd == DEBUG_SUBCOMMAND_GMODE) {
                        printf("globalDebugmode=%d\n",
                               cmd_buf->debugConfig.globalDebugMode);
                    } else if (subcmd == DEBUG_SUBCOMMAND_MAJOREVTMASK) {
                        printf("MajorId mask=0x%08lx\n",
                               uap_le32_to_cpu(cmd_buf->debugConfig.
                                               debugMajorIdMask));
                    } else {
                        printf("Value = %ld\n",
                               uap_le32_to_cpu(cmd_buf->debugConfig.value));
                    }
                } else {
                    printf("set debug parameter successful\n");
                }
            }
        } else {
            if (argc == 1) {
                printf("ERR:Could not get debug parameter!\n");
            } else {
                printf("ERR:Could not set debug parameter!\n");
            }
        }
    } else {
        printf("ERR:Command sending failed!\n");
    }
    if (buffer)
        free(buffer);
    return;
}

/** structure of command table*/
typedef struct
{
    /** command name */
    char *cmd;
    /** command function pointer */
    void (*func) (int argc, char *argv[]);
    /**command usuage */
    char *help;
} command_table;

/** ap command table */
static command_table ap_command[] = {
    {"sys_config", apcmd_sys_config, "\tSet/get uAP's profile"},
    {"sys_info", apcmd_sys_info, "\tDisplay system info"},
    {"sys_reset", apcmd_sys_reset, "\tReset uAP"},
    {"bss_start", apcmd_bss_start, "\tStart the BSS"},
    {"bss_stop", apcmd_bss_stop, "\tStop the BSS"},
    {"sta_deauth", apcmd_sta_deauth, "\tDeauth client"},
    {"sta_list", apcmd_sta_list, "\tDisplay list of clients"},
    {"sys_cfg_ap_mac_address", apcmd_sys_cfg_ap_mac_address,
     "Set/get uAP mac address"},
    {"sys_cfg_ssid", apcmd_sys_cfg_ssid, "\tSet/get uAP ssid"},
    {"sys_cfg_beacon_period", apcmd_sys_cfg_beacon_period,
     "Set/get uAP beacon period"},
    {"sys_cfg_dtim_period", apcmd_sys_cfg_dtim_period,
     "Set/get uAP dtim period"},
    {"sys_cfg_channel", apcmd_sys_cfg_channel, "\tSet/get uAP radio channel"},
    {"sys_cfg_scan_channels", apcmd_sys_cfg_scan_channels,
     "Set/get uAP radio channel list"},
    {"sys_cfg_rates", apcmd_sys_cfg_rates, "\tSet/get uAP rates"},
    {"sys_cfg_rates_ext", apcmd_sys_cfg_rates_ext,
     "Set/get uAP rates (extended)"},
    {"sys_cfg_tx_power", apcmd_sys_cfg_tx_power, "Set/get uAP tx power"},
    {"sys_cfg_bcast_ssid_ctl", apcmd_sys_cfg_bcast_ssid_ctl,
     "Set/get uAP broadcast ssid"},
    {"sys_cfg_preamble_ctl", apcmd_sys_cfg_preamble_ctl, "Get uAP preamble"},
    {"sys_cfg_antenna_ctl", apcmd_sys_cfg_antenna_ctl,
     "Set/get uAP tx/rx antenna"},
    {"sys_cfg_rts_threshold", apcmd_sys_cfg_rts_threshold,
     "Set/get uAP rts threshold"},
    {"sys_cfg_frag_threshold", apcmd_sys_cfg_frag_threshold,
     "Set/get uAP frag threshold"},
    {"sys_cfg_radio_ctl", apcmd_sys_cfg_radio_ctl, "Set/get uAP radio on/off"},
    {"sys_cfg_tx_data_rate", apcmd_sys_cfg_tx_data_rate, "Set/get uAP tx rate"},
    {"sys_cfg_mcbc_data_rate", apcmd_sys_cfg_mcbc_data_rate,
     "Set/get uAP MCBC rate"},
    {"sys_cfg_rsn_replay_prot", apcmd_sys_cfg_rsn_replay_prot,
     "Set/get RSN replay protection"},
    {"sys_cfg_pkt_fwd_ctl", apcmd_sys_cfg_pkt_fwd_ctl,
     "Set/get uAP packet forwarding"},
    {"sys_cfg_sta_ageout_timer", apcmd_sys_cfg_sta_ageout_timer,
     "Set/get station ageout timer"},
    {"sys_cfg_auth", apcmd_sys_cfg_auth, "\tSet/get uAP authentication mode"},
    {"sys_cfg_protocol", apcmd_sys_cfg_protocol,
     "Set/get uAP security protocol"},
    {"sys_cfg_wep_key", apcmd_sys_cfg_wep_key, "\tSet/get uAP wep key"},
    {"sys_cfg_cipher", apcmd_sys_cfg_cipher, "\tSet/get uAP WPA/WPA cipher"},
    {"sys_cfg_wpa_passphrase", apcmd_sys_cfg_wpa_passphrase,
     "Set/get uAP WPA or WPA2 passphrase"},
    {"sys_cfg_group_rekey_timer", apcmd_sys_cfg_group_rekey_timer,
     "Set/get uAP group re-key time"},
    {"sys_cfg_max_sta_num", apcmd_sys_cfg_max_sta_num,
     "Set/get uAP max station number"},
    {"sys_cfg_retry_limit", apcmd_sys_cfg_retry_limit,
     "Set/get uAP retry limit number"},
    {"sys_cfg_custom_ie", apcmd_sys_cfg_custom_ie,
     "\tSet/get custom IE configuration"},
    {"sta_filter_table", apcmd_sta_filter_table, "Set/get uAP mac filter"},
    {"regrdwr", apcmd_regrdwr, "\t\tRead/Write register command"},
    {"memaccess", apcmd_memaccess, "\tRead/Write to a memory address command"},
    {"rdeeprom", apcmd_read_eeprom, "\tRead EEPROM "},
    {"cfg_data", apcmd_cfg_data,
     "\tGet/Set configuration file from/to firmware"},
    {"sys_debug", apcmd_sys_debug, "\tSet/Get debug parameter"},
    {"sys_cfg_80211d", apcmd_cfg_80211d, "\tSet/Get 802.11D info"},
    {"uap_stats", apcmd_uap_stats, "\tGet uAP stats"},
    {"powermode", apcmd_power_mode, "\tSet/get uAP power mode"},
    {"coex_config", apcmd_coex_config, "\tSet/get uAP BT coex configuration"},
    {NULL, NULL, 0}
};

/** 
 *  @brief Prints usage information of uaputl
 *
 *  @return          N/A
 */
static void
print_tool_usage(void)
{
    int i;
    printf("uaputl - uAP utility ver %s\n", UAP_VERSION);
    printf("Usage:\n"
           "\tuaputl [options] <command> [command parameters]\n");
    printf("Options:\n"
           "\t--help\tDisplay help\n"
           "\t-v\tDisplay version\n"
           "\t-i <interface>\n" "\t-d <debug_level=0|1|2>\n");
    printf("Commands:\n");
    for (i = 0; ap_command[i].cmd; i++)
        printf("\t%-4s\t\t%s\n", ap_command[i].cmd, ap_command[i].help);
    printf("\n"
           "For more information on the usage of each command use:\n"
           "\tuaputl <command> --help\n");
}

/****************************************************************************
        Global functions
****************************************************************************/
/** option parameter*/
static struct option ap_options[] = {
    {"help", 0, NULL, 'h'},
    {"interface", 1, NULL, 'i'},
    {"debug", 1, NULL, 'd'},
    {"version", 0, NULL, 'v'},
    {NULL, 0, NULL, '\0'}
};

/**
 *    @brief isdigit for String.
 *   
 *    @param x            char string
 *    @return             UAP_FAILURE for non-digit.
 *                        UAP_SUCCESS for digit
 */
inline int
ISDIGIT(char *x)
{
    int i;
    for (i = 0; i < strlen(x); i++)
        if (isdigit(x[i]) == 0)
            return UAP_FAILURE;
    return UAP_SUCCESS;
}

/** 
 *  @brief Checkes a particular input for validatation.
 *
 *  @param cmd      Type of input
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         UAP_SUCCESS or UAP_FAILURE
 */
int
is_input_valid(valid_inputs cmd, int argc, char *argv[])
{
    int i;
    int ret = UAP_SUCCESS;
    if (argc == 0)
        return UAP_FAILURE;
    switch (cmd) {
    case RDEEPROM:
        if (argc != 2) {
            printf(" ERR: Argument count mismatch\n");
            ret = UAP_FAILURE;
        } else {
            if ((ISDIGIT(argv[0]) == 0) || (ISDIGIT(argv[1]) == 0) ||
                (A2HEXDECIMAL(argv[0]) & 0x03) ||
                (A2HEXDECIMAL(argv[0]) < 0) ||
                (A2HEXDECIMAL(argv[1]) & 0x03) ||
                (A2HEXDECIMAL(argv[1]) < 4) || (A2HEXDECIMAL(argv[1]) > 20)) {
                printf(" ERR: Invalid inputs for Read EEPROM\n");
                ret = UAP_FAILURE;
            }
        }
        break;
    case SCANCHANNELS:
        if (argc > MAX_CHANNELS) {
            printf("ERR: Invalid List of Channels\n");
            ret = UAP_FAILURE;
        } else {
            for (i = 0; i < argc; i++) {
                if ((ISDIGIT(argv[i]) == 0) || (atoi(argv[i]) < 1) ||
                    (atoi(argv[i]) > MAX_CHANNELS)) {
                    printf("ERR: Channel must be in the range of 1 to %d\n",
                           MAX_CHANNELS);
                    ret = UAP_FAILURE;
                    break;
                }
            }
            if ((ret != UAP_FAILURE) &&
                (has_dup_channel(argc, argv) != UAP_SUCCESS)) {
                printf("ERR: Duplicate channel values entered\n");
                ret = UAP_FAILURE;
            }
        }
        break;
    case TXPOWER:
        if ((argc > 1) || (ISDIGIT(argv[0]) == 0)) {
            printf("ERR:Invalid Transmit power\n");
            ret = UAP_FAILURE;
        } else {
            if ((atoi(argv[0]) < MIN_TX_POWER) ||
                (atoi(argv[0]) > MAX_TX_POWER)) {
                printf("ERR: TX Powar must be in the rage of %d to %d. \n",
                       MIN_TX_POWER, MAX_TX_POWER);
                ret = UAP_FAILURE;
            }
        }
        break;
    case PROTOCOL:
        if ((argc > 1) || (ISDIGIT(argv[0]) == 0)) {
            printf("ERR:Invalid Protocol\n");
            ret = UAP_FAILURE;
        } else
            ret = is_protocol_valid(atoi(argv[0]));
        break;
    case CHANNEL:
        if ((argc != 1) && (argc != 2)) {
            printf("ERR: Incorrect arguments for channel.\n");
            ret = UAP_FAILURE;
        } else {
            if (argc == 2) {
                if ((ISDIGIT(argv[1]) == 0) || (atoi(argv[1]) < 0) ||
                    (atoi(argv[1]) > 1)) {
                    printf("ERR: MODE must be either 0 or 1\n");
                    ret = UAP_FAILURE;
                }
                if ((atoi(argv[1]) == 1) && (atoi(argv[0]) != 0)) {
                    printf("ERR: Channel must be 0 for ACS; MODE = 1.\n");
                    ret = UAP_FAILURE;
                }
            }
            if ((argc == 1) || (atoi(argv[1]) == 0)) {
                if ((ISDIGIT(argv[0]) == 0) || (atoi(argv[0]) < 1) ||
                    (atoi(argv[0]) > MAX_CHANNELS)) {
                    printf("ERR: Channel must be in the range of 1 to %d\n",
                           MAX_CHANNELS);
                    ret = UAP_FAILURE;
                }
            }
        }
        break;
    case RATE:
        if (argc > MAX_RATES) {
            printf("ERR: Incorrect number of RATES arguments.\n");
            ret = UAP_FAILURE;
        } else {
            for (i = 0; i < argc; i++) {
                if ((IS_HEX_OR_DIGIT(argv[i]) == UAP_FAILURE) ||
                    (is_rate_valid(A2HEXDECIMAL(argv[i]) & ~BASIC_RATE_SET_BIT)
                     != UAP_SUCCESS)) {
                    printf("ERR:Unsupported rate.\n");
                    ret = UAP_FAILURE;
                    break;
                }
            }
            if ((ret != UAP_FAILURE) &&
                (has_dup_rate(argc, argv) != UAP_SUCCESS)) {
                printf("ERR: Duplicate rate values entered\n");
                ret = UAP_FAILURE;
            }
            if (check_mandatory_rates(argc, argv) != UAP_SUCCESS) {
                ret = UAP_FAILURE;
            }
        }
        break;
    case BROADCASTSSID:
        if (argc != 1) {
            printf("ERR:wrong BROADCASTSSID arguments.\n");
            ret = UAP_FAILURE;
        } else {
            if ((ISDIGIT(argv[0]) == 0) ||
                ((atoi(argv[0]) != 0) && (atoi(argv[0]) != 1))) {
                printf
                    ("ERR:Illegal parameter %s for BROADCASTSSID. Must be either '0' or '1'.\n",
                     argv[0]);
                ret = UAP_FAILURE;
            }
        }
        break;
    case RTSTHRESH:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for RTSTHRESHOLD\n");
            ret = UAP_FAILURE;
        } else if ((ISDIGIT(argv[0]) == 0) || (atoi(argv[0]) < 0) ||
                   (atoi(argv[0]) > MAX_RTS_THRESHOLD)) {
            printf
                ("ERR:Illegal RTSTHRESHOLD %s. The value must between 0 and %d\n",
                 argv[0], MAX_RTS_THRESHOLD);
            ret = UAP_FAILURE;
        }
        break;
    case FRAGTHRESH:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for FRAGTHRESH\n");
            ret = UAP_FAILURE;
        } else if ((ISDIGIT(argv[0]) == 0) ||
                   (atoi(argv[0]) < MIN_FRAG_THRESHOLD) ||
                   (atoi(argv[0]) > MAX_FRAG_THRESHOLD)) {
            printf
                ("ERR:Illegal FRAGTHRESH %s. The value must between %d and %d\n",
                 argv[0], MIN_FRAG_THRESHOLD, MAX_FRAG_THRESHOLD);
            ret = UAP_FAILURE;
        }
        break;
    case DTIMPERIOD:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for DTIMPERIOD\n");
            ret = UAP_FAILURE;
        } else if ((ISDIGIT(argv[0]) == 0) || (atoi(argv[0]) < 1) ||
                   (atoi(argv[0]) > MAX_DTIM_PERIOD)) {
            printf("ERR: DTIMPERIOD Value must be in range of 1 to %d\n",
                   MAX_DTIM_PERIOD);
            ret = UAP_FAILURE;
        }
        break;
    case RADIOCONTROL:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for RADIOCONTROL\n");
            ret = UAP_FAILURE;
        } else {
            if ((ISDIGIT(argv[0]) == 0) || (atoi(argv[0]) < 0) ||
                (atoi(argv[0]) > 1)) {
                printf
                    ("ERR:Illegal RADIOCONTROL parameter %s. Must be either '0' or '1'.\n",
                     argv[0]);
                ret = UAP_FAILURE;
            }
        }
        break;
    case RSNREPLAYPROT:
        if (argc != 1) {
            printf("ERR:wrong RSNREPLAYPROT arguments.\n");
            ret = UAP_FAILURE;
        } else {
            if ((ISDIGIT(argv[0]) == 0) ||
                ((atoi(argv[0]) != 0) && (atoi(argv[0]) != 1))) {
                printf
                    ("ERR:Illegal parameter %s for RSNREPLAYPROT. Must be either '0' or '1'.\n",
                     argv[0]);
                ret = UAP_FAILURE;
            }
        }
        break;
    case MCBCDATARATE:
    case TXDATARATE:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for DATARATE\n");
            ret = UAP_FAILURE;
        } else {
            if (IS_HEX_OR_DIGIT(argv[0]) == UAP_FAILURE) {
                printf("ERR: invalid data rate\n");
                ret = UAP_FAILURE;
            } else if ((A2HEXDECIMAL(argv[0]) != 0) &&
                       (is_rate_valid
                        (A2HEXDECIMAL(argv[0]) & ~BASIC_RATE_SET_BIT) !=
                        UAP_SUCCESS)) {
                printf("ERR: invalid data rate\n");
                ret = UAP_FAILURE;
            }
        }
        break;
    case PKTFWD:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for PKTFWD.\n");
            ret = UAP_FAILURE;
        } else if ((ISDIGIT(argv[0]) == 0) ||
                   ((atoi(argv[0]) != 0) && (atoi(argv[0]) != 1))) {
            printf
                ("ERR:Illegal PKTFWD parameter %s. Must be either '0' or '1'.\n",
                 argv[0]);
            ret = UAP_FAILURE;
        }
        break;
    case STAAGEOUTTIMER:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for STAAGEOUTTIMER.\n");
            ret = UAP_FAILURE;
        } else {
            if ((ISDIGIT(argv[0]) == 0) || ((atoi(argv[0]) != 0) &&
                                            ((atoi(argv[0]) <
                                              MIN_STAGE_OUT_TIME) ||
                                             (atoi(argv[0]) >
                                              MAX_STAGE_OUT_TIME)))) {
                printf
                    ("ERR:Illegal STAAGEOUTTIMER %s. Must be between %d and %d.\n",
                     argv[0], MIN_STAGE_OUT_TIME, MAX_STAGE_OUT_TIME);
                ret = UAP_FAILURE;
            }
        }
        break;
    case AUTHMODE:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for AUTHMODE\n");
            ret = UAP_FAILURE;
        } else {
            if ((ISDIGIT(argv[0]) == 0) || (atoi(argv[0]) < 0) ||
                (atoi(argv[0]) > 1)) {
                printf
                    ("ERR:Illegal AUTHMODE parameter %s. Must be either '0', or '1'.\n",
                     argv[0]);
                ret = UAP_FAILURE;
            }
        }
        break;
    case GROUPREKEYTIMER:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for GROUPREKEYTIMER.\n");
            ret = UAP_FAILURE;
        } else {
            if ((ISDIGIT(argv[0]) == 0) || (atoi(argv[0]) < 0) ||
                (atoi(argv[0]) > MAX_GRP_TIMER)) {
                printf("ERR: GROUPREKEYTIMER range is [0:%d] (0 for disable)\n",
                       MAX_GRP_TIMER);
                ret = UAP_FAILURE;
            }
        }
        break;
    case MAXSTANUM:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for MAXSTANUM\n");
            ret = UAP_FAILURE;
        } else {
            if ((ISDIGIT(argv[0]) == 0) || (atoi(argv[0]) > 8) ||
                (atoi(argv[0]) < 0)) {
                printf("ERR:STA_NUM must be in the range of [0:8] %s.\n",
                       argv[0]);
                ret = UAP_FAILURE;
            }
        }
        break;
    case BEACONPERIOD:
        if (argc != 1) {
            printf("ERR:Incorrect number of argument for BEACONPERIOD.\n");
            ret = UAP_FAILURE;
        } else {
            if ((ISDIGIT(argv[0]) == 0) || (atoi(argv[0]) < MIN_BEACON_PERIOD)
                || (atoi(argv[0]) > MAX_BEACON_PERIOD)) {
                printf("ERR: BEACONPERIOD must be in range of %d to %d.\n",
                       MIN_BEACON_PERIOD, MAX_BEACON_PERIOD);
                ret = UAP_FAILURE;
            }
        }
        break;
    case RETRYLIMIT:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for RETRY LIMIT\n");
            ret = UAP_FAILURE;
        } else {
            if ((ISDIGIT(argv[0]) == 0) || (atoi(argv[0]) > MAX_RETRY_LIMIT) ||
                (atoi(argv[0]) < 0)) {
                printf
                    ("ERR:RETRY_LIMIT must be in the range of [0:%d]. The  input was %s.\n",
                     MAX_RETRY_LIMIT, argv[0]);
                ret = UAP_FAILURE;
            }
        }
        break;
    case COEX_COMM_BITMAP:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for Bitmap.\n");
            ret = UAP_FAILURE;
        } else {
            /* Only bit 0 is supported now, hence check for 1 or 0 */
            if ((IS_HEX_OR_DIGIT(argv[0]) == 0) || (atoi(argv[0]) < 0) ||
                (atoi(argv[0]) > 1)) {
                printf("ERR: Bitmap must have value of 1 or 0.\n");
                ret = UAP_FAILURE;
            }
        }
        break;
    case COEX_SCO_ACL_FREQ:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for aclFrequency.\n");
            ret = UAP_FAILURE;
        } else {
            if (ISDIGIT(argv[0]) == 0) {
                printf("ERR: Incorrect value for aclFrequency.\n");
                ret = UAP_FAILURE;
            }
        }
        break;
    case COEX_ACL_ENABLED:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for (acl) enabled.\n");
            ret = UAP_FAILURE;
        } else {
            if ((ISDIGIT(argv[0]) == 0) || (atoi(argv[0]) < 0) ||
                (atoi(argv[0]) > 1)) {
                printf("ERR: (acl) enabled must have value of 1 or 0.\n");
                ret = UAP_FAILURE;
            }
        }
        break;
    case COEX_ACL_BT_TIME:
    case COEX_ACL_WLAN_TIME:
        if (argc != 1) {
            printf("ERR:Incorrect number of arguments for bt/wlan time.\n");
            ret = UAP_FAILURE;
        } else {
            if (ISDIGIT(argv[0]) == 0) {
                printf("ERR: Incorrect value for bt/wlan time.\n");
                ret = UAP_FAILURE;
            }
        }
        break;
    case COEX_PROTECTION:
        if (argc != 2) {
            printf("ERR:Incorrect number of arguments for %s.\n", argv[0]);
            ret = UAP_FAILURE;
        } else {
            if (ISDIGIT(argv[1]) == 0) {
                printf("ERR: Incorrect value for %s.\n", argv[0]);
                ret = UAP_FAILURE;
            }
        }
        break;
    default:
        ret = UAP_FAILURE;
        break;
    }
    return ret;
}

/** 
 *  @brief Converts colon separated MAC address to hex value
 *
 *  @param mac      A pointer to the colon separated MAC string
 *  @param raw      A pointer to the hex data buffer
 *  @return         UAP_SUCCESS or UAP_FAILURE
 *                  UAP_RET_MAC_BROADCAST  - if broadcast mac
 *                  UAP_RET_MAC_MULTICAST - if multicast mac
 */
int
mac2raw(char *mac, u8 * raw)
{
    unsigned int temp_raw[ETH_ALEN];
    int num_tokens = 0;
    int i;
    if (strlen(mac) != ((2 * ETH_ALEN) + (ETH_ALEN - 1))) {
        return UAP_FAILURE;
    }
    num_tokens = sscanf(mac, "%2x:%2x:%2x:%2x:%2x:%2x",
                        temp_raw + 0, temp_raw + 1, temp_raw + 2, temp_raw + 3,
                        temp_raw + 4, temp_raw + 5);
    if (num_tokens != ETH_ALEN) {
        return UAP_FAILURE;
    }
    for (i = 0; i < num_tokens; i++)
        raw[i] = (u8) temp_raw[i];

    if (memcmp(raw, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) == 0) {
        return UAP_RET_MAC_BROADCAST;
    } else if (raw[0] & 0x01) {
        return UAP_RET_MAC_MULTICAST;
    }
    return UAP_SUCCESS;
}

/** 
 *  @brief Converts a string to hex value
 *
 *  @param str      A pointer to the string
 *  @param raw      A pointer to the raw data buffer
 *  @return         Number of bytes read
 */
int
string2raw(char *str, unsigned char *raw)
{
    int len = (strlen(str) + 1) / 2;

    do {
        if (!isxdigit(*str)) {
            return -1;
        }
        *str = toupper(*str);
        *raw = CHAR2INT(*str) << 4;
        ++str;
        *str = toupper(*str);
        if (*str == '\0')
            break;
        *raw |= CHAR2INT(*str);
        ++raw;
    } while (*++str != '\0');
    return len;
}

/** 
 *  @brief Prints a MAC address in colon separated form from hex data
 *
 *  @param raw      A pointer to the hex data buffer
 *  @return         N/A
 */
void
print_mac(u8 * raw)
{
    printf("%02x:%02x:%02x:%02x:%02x:%02x", (unsigned int) raw[0],
           (unsigned int) raw[1], (unsigned int) raw[2], (unsigned int) raw[3],
           (unsigned int) raw[4], (unsigned int) raw[5]);
    return;
}

/** 
 *  @brief 		check hex string
 *  
 *  @param hex		A pointer to hex string
 *  @return      	UAP_SUCCESS or UAP_FAILURE
 */
int
ishexstring(void *hex)
{
    int i, a;
    char *p = hex;
    int len = strlen(p);
    if (!strncasecmp("0x", p, 2)) {
        p += 2;
        len -= 2;
    }
    for (i = 0; i < len; i++) {
        a = hex2num(*p);
        if (a < 0)
            return UAP_FAILURE;
        p++;
    }
    return UAP_SUCCESS;
}

/**
 *  @brief Show auth tlv 
 *
 *  @param tlv     Poniter to auth tlv
 *  
 *  $return         N/A
 */
void
print_auth(TLVBUF_AUTH_MODE * tlv)
{
    switch (tlv->AuthMode) {
    case 0:
        printf("AUTHMODE = Open authentication\n");
        break;
    case 1:
        printf("AUTHMODE = Shared key authentication\n");
        break;
    case 2:
        printf("AUTHMODE = Auto (open and shared key)\n");
        break;
    default:
        printf("ERR: Invalid authmode=%d\n", tlv->AuthMode);
        break;
    }
}

/**
 *
 *  @brief Show cipher tlv 
 *
 *  @param tlv     Poniter to cipher tlv
 *  
 *  $return         N/A
 */
void
print_cipher(TLVBUF_CIPHER * tlv)
{
    switch (tlv->PairwiseCipher) {
    case CIPHER_TKIP:
        printf("PairwiseCipher = TKIP\n");
        break;
    case CIPHER_AES_CCMP:
        printf("PairwiseCipher = AES CCMP\n");
        break;
    case CIPHER_TKIP | CIPHER_AES_CCMP:
        printf("PairwiseCipher = TKIP + AES CCMP\n");
        break;
    case CIPHER_NONE:
        printf("PairwiseCipher =  None\n");
        break;
    default:
        printf("Unknown Pairwise cipher 0x%x\n", tlv->PairwiseCipher);
        break;
    }
    switch (tlv->GroupCipher) {
    case CIPHER_TKIP:
        printf("GroupCipher = TKIP\n");
        break;
    case CIPHER_AES_CCMP:
        printf("GroupCipher = AES CCMP\n");
        break;
    case CIPHER_NONE:
        printf("GroupCipher = None\n");
        break;
    default:
        printf("Unknown Group cipher 0x%x\n", tlv->GroupCipher);
        break;
    }
}

/**
 *  @brief Show mac filter tlv 
 *
 *  @param tlv     Poniter to filter tlv
 *  
 *  $return         N/A
 */
void
print_mac_filter(TLVBUF_STA_MAC_ADDR_FILTER * tlv)
{
    int i;
    switch (tlv->FilterMode) {
    case 0:
        printf("Filter Mode = Filter table is disabled\n");
        return;
    case 1:
        printf
            ("Filter Mode = Allow mac address specified in the allwed list\n");
        break;
    case 2:
        printf
            ("Filter Mode = Block MAC addresses specified in the  banned list\n");
        break;
    }
    for (i = 0; i < tlv->Count; i++) {
        printf("MAC_%d = ", i);
        print_mac(&tlv->MacAddress[i * ETH_ALEN]);
        printf("\n");
    }
}

/**
 *  @brief Show rate tlv 
 *
 *  @param tlv      Poniter to rate tlv
 *  
 *  $return         N/A
 */
void
print_rate(TLVBUF_RATES * tlv)
{
    int flag = 0;
    int i;
    printf("Basic Rates =");
    for (i = 0; i < tlv->Length; i++) {
        if (tlv->OperationalRates[i] > (BASIC_RATE_SET_BIT - 1)) {
            flag = flag ? : 1;
            printf(" 0x%x", tlv->OperationalRates[i]);
        }
    }
    printf("%s\nNon-Basic Rates =", flag ? "" : " ( none ) ");
    for (flag = 0, i = 0; i < tlv->Length; i++) {
        if (tlv->OperationalRates[i] < BASIC_RATE_SET_BIT) {
            flag = flag ? : 1;
            printf(" 0x%x", tlv->OperationalRates[i]);
        }
    }
    printf("%s\n", flag ? "" : " ( none ) ");
}

/**
 *  @brief Show all the tlv in the buf
 *
 *  @param buf     Poniter to tlv buffer
 *  @param len     tlv buffer len
 *  
 *  $return         N/A
 */
void
print_tlv(u8 * buf, u16 len)
{
    TLVBUF_HEADER *pCurrentTlv = (TLVBUF_HEADER *) buf;
    int tlvBufLeft = len;
    u16 tlvType;
    u16 tlvLen;
    u16 custom_ie_len;
    u8 ssid[33];
    int i = 0;
    TLVBUF_AP_MAC_ADDRESS *mac_tlv;
    TLVBUF_SSID *ssid_tlv;
    TLVBUF_BEACON_PERIOD *beacon_tlv;
    TLVBUF_DTIM_PERIOD *dtim_tlv;
    TLVBUF_RATES *rates_tlv;
    TLVBUF_TX_POWER *txpower_tlv;
    TLVBUF_BCAST_SSID_CTL *bcast_tlv;
    TLVBUF_PREAMBLE_CTL *preamble_tlv;
    TLVBUF_ANTENNA_CTL *antenna_tlv;
    TLVBUF_RTS_THRESHOLD *rts_tlv;
    TLVBUF_RADIO_CTL *radio_tlv;
    TLVBUF_TX_DATA_RATE *txrate_tlv;
    TLVBUF_MCBC_DATA_RATE *mcbcrate_tlv;
    TLVBUF_PKT_FWD_CTL *pkt_fwd_tlv;
    TLVBUF_STA_AGEOUT_TIMER *ageout_tlv;
    TLVBUF_AUTH_MODE *auth_tlv;
    TLVBUF_PROTOCOL *proto_tlv;
    TLVBUF_AKMP *akmp_tlv;
    TLVBUF_CIPHER *cipher_tlv;
    TLVBUF_GROUP_REKEY_TIMER *rekey_tlv;
    TLVBUF_WPA_PASSPHRASE *psk_tlv;
    TLVBUF_WEP_KEY *wep_tlv;
    TLVBUF_FRAG_THRESHOLD *frag_tlv;
    TLVBUF_STA_MAC_ADDR_FILTER *filter_tlv;
    TLVBUF_MAX_STA_NUM *max_sta_tlv;
    TLVBUF_RETRY_LIMIT *retry_limit_tlv;
    TLVBUF_CHANNEL_CONFIG *channel_tlv;
    TLVBUF_CHANNEL_LIST *chnlist_tlv;
    tlvbuf_custom_ie *custom_ie_tlv;
    custom_ie *custom_ie_ptr;
    tlvbuf_coex_common_cfg *coex_common_tlv;
    tlvbuf_coex_sco_cfg *coex_sco_tlv;
    tlvbuf_coex_acl_cfg *coex_acl_tlv;
    tlvbuf_coex_stats *coex_stats_tlv;
    CHANNEL_LIST *pChanList;
#ifdef DEBUG
    uap_printf(MSG_DEBUG, "tlv total len=%d\n", len);
#endif
    while (tlvBufLeft >= (int) sizeof(TLVBUF_HEADER)) {
        tlvType = uap_le16_to_cpu(pCurrentTlv->Type);
        tlvLen = uap_le16_to_cpu(pCurrentTlv->Len);
        if ((sizeof(TLVBUF_HEADER) + tlvLen) > tlvBufLeft) {
            printf("wrong tlv: tlvLen=%d, tlvBufLeft=%d\n", tlvLen, tlvBufLeft);
            break;
        }
        switch (tlvType) {
        case MRVL_AP_MAC_ADDRESS_TLV_ID:
            mac_tlv = (TLVBUF_AP_MAC_ADDRESS *) pCurrentTlv;
            printf("AP MAC address = ");
            print_mac(mac_tlv->ApMacAddr);
            printf("\n");
            break;
        case MRVL_SSID_TLV_ID:
            memset(ssid, 0, sizeof(ssid));
            ssid_tlv = (TLVBUF_SSID *) pCurrentTlv;
            memcpy(ssid, ssid_tlv->Ssid, ssid_tlv->Length);
            printf("SSID = %s\n", ssid);
            break;
        case MRVL_BEACON_PERIOD_TLV_ID:
            beacon_tlv = (TLVBUF_BEACON_PERIOD *) pCurrentTlv;
            beacon_tlv->BeaconPeriod_ms =
                uap_le16_to_cpu(beacon_tlv->BeaconPeriod_ms);
            printf("Beacon period = %d\n", beacon_tlv->BeaconPeriod_ms);
            break;
        case MRVL_DTIM_PERIOD_TLV_ID:
            dtim_tlv = (TLVBUF_DTIM_PERIOD *) pCurrentTlv;
            printf("DTIM period = %d\n", dtim_tlv->DtimPeriod);
            break;
        case MRVL_CHANNELCONFIG_TLV_ID:
            channel_tlv = (TLVBUF_CHANNEL_CONFIG *) pCurrentTlv;
            printf("Channel = %d\n", channel_tlv->ChanNumber);
            printf("Channel Select Mode = %s\n",
                   (channel_tlv->BandConfigType == 0) ? "Manual" : "ACS");
            break;
        case MRVL_CHANNELLIST_TLV_ID:
            chnlist_tlv = (TLVBUF_CHANNEL_LIST *) pCurrentTlv;
            printf("Channels List = ");
            pChanList = (CHANNEL_LIST *) & (chnlist_tlv->ChanList);
            if (chnlist_tlv->Length % sizeof(CHANNEL_LIST)) {
                break;
            }
            for (i = 0; i < (chnlist_tlv->Length / sizeof(CHANNEL_LIST)); i++) {
                printf("%d ", pChanList->ChanNumber);
                pChanList++;
            }
            printf("\n");
            break;
        case MRVL_RATES_TLV_ID:
            rates_tlv = (TLVBUF_RATES *) pCurrentTlv;
            print_rate(rates_tlv);
            break;
        case MRVL_TX_POWER_TLV_ID:
            txpower_tlv = (TLVBUF_TX_POWER *) pCurrentTlv;
            printf("Tx power = %d dBm\n", txpower_tlv->TxPower_dBm);
            break;
        case MRVL_BCAST_SSID_CTL_TLV_ID:
            bcast_tlv = (TLVBUF_BCAST_SSID_CTL *) pCurrentTlv;
            printf("SSID broadcast = %s\n",
                   (bcast_tlv->BcastSsidCtl == 1) ? "enabled" : "disabled");
            break;
        case MRVL_PREAMBLE_CTL_TLV_ID:
            preamble_tlv = (TLVBUF_PREAMBLE_CTL *) pCurrentTlv;
            printf("Preamble type = %s\n", (preamble_tlv->PreambleType == 0) ?
                   "auto" : ((preamble_tlv->PreambleType == 1) ? "short" :
                             "long"));
            break;
        case MRVL_ANTENNA_CTL_TLV_ID:
            antenna_tlv = (TLVBUF_ANTENNA_CTL *) pCurrentTlv;
            printf("%s antenna = %s\n", (antenna_tlv->WhichAntenna == 0) ?
                   "Rx" : "Tx", (antenna_tlv->AntennaMode == 0) ? "A" : "B");
            break;
        case MRVL_RTS_THRESHOLD_TLV_ID:
            rts_tlv = (TLVBUF_RTS_THRESHOLD *) pCurrentTlv;
            rts_tlv->RtsThreshold = uap_le16_to_cpu(rts_tlv->RtsThreshold);
            printf("RTS threshold = %d\n", rts_tlv->RtsThreshold);
            break;
        case MRVL_FRAG_THRESHOLD_TLV_ID:
            frag_tlv = (TLVBUF_FRAG_THRESHOLD *) pCurrentTlv;
            frag_tlv->FragThreshold = uap_le16_to_cpu(frag_tlv->FragThreshold);
            printf("Fragmentation threshold = %d\n", frag_tlv->FragThreshold);
            break;
        case MRVL_RADIO_CTL_TLV_ID:
            radio_tlv = (TLVBUF_RADIO_CTL *) pCurrentTlv;
            printf("Radio = %s\n", (radio_tlv->RadioCtl == 0) ? "on" : "off");
            break;
        case MRVL_TX_DATA_RATE_TLV_ID:
            txrate_tlv = (TLVBUF_TX_DATA_RATE *) pCurrentTlv;
            txrate_tlv->TxDataRate = uap_le16_to_cpu(txrate_tlv->TxDataRate);
            if (txrate_tlv->TxDataRate == 0)
                printf("Tx data rate = auto\n");
            else
                printf("Tx data rate = 0x%x\n", txrate_tlv->TxDataRate);
            break;
        case MRVL_MCBC_DATA_RATE_TLV_ID:
            mcbcrate_tlv = (TLVBUF_MCBC_DATA_RATE *) pCurrentTlv;
            mcbcrate_tlv->MCBCdatarate =
                uap_le16_to_cpu(mcbcrate_tlv->MCBCdatarate);
            if (mcbcrate_tlv->MCBCdatarate == 0)
                printf("MCBC data rate = auto\n");
            else
                printf("MCBC data rate = 0x%x\n", mcbcrate_tlv->MCBCdatarate);
            break;
        case MRVL_PKT_FWD_CTL_TLV_ID:
            pkt_fwd_tlv = (TLVBUF_PKT_FWD_CTL *) pCurrentTlv;
            printf("Firmware = %s\n", (pkt_fwd_tlv->PktFwdCtl == 0) ?
                   "forwards all packets to the host" :
                   "handles intra-BSS packets");
            break;
        case MRVL_STA_AGEOUT_TIMER_TLV_ID:
            ageout_tlv = (TLVBUF_STA_AGEOUT_TIMER *) pCurrentTlv;
            ageout_tlv->StaAgeoutTimer_ms =
                uap_le32_to_cpu(ageout_tlv->StaAgeoutTimer_ms);
            printf("STA ageout timer = %d\n",
                   (int) ageout_tlv->StaAgeoutTimer_ms);
            break;
        case MRVL_AUTH_TLV_ID:
            auth_tlv = (TLVBUF_AUTH_MODE *) pCurrentTlv;
            print_auth(auth_tlv);
            break;
        case MRVL_PROTOCOL_TLV_ID:
            proto_tlv = (TLVBUF_PROTOCOL *) pCurrentTlv;
            proto_tlv->Protocol = uap_le16_to_cpu(proto_tlv->Protocol);
            print_protocol(proto_tlv);
            break;
        case MRVL_AKMP_TLV_ID:
            akmp_tlv = (TLVBUF_AKMP *) pCurrentTlv;
            if (uap_le16_to_cpu(akmp_tlv->KeyMgmt) == KEY_MGMT_PSK)
                printf("KeyMgmt = PSK\n");
            else
                printf("KeyMgmt = NONE\n");
            break;
        case MRVL_CIPHER_TLV_ID:
            cipher_tlv = (TLVBUF_CIPHER *) pCurrentTlv;
            print_cipher(cipher_tlv);
            break;
        case MRVL_GRP_REKEY_TIME_TLV_ID:
            rekey_tlv = (TLVBUF_GROUP_REKEY_TIMER *) pCurrentTlv;
            if (rekey_tlv->GroupRekeyTime_sec == 0)
                printf("Group re-key time = disabled\n");
            else
                printf("Group re-key time = %ld second\n",
                       uap_le32_to_cpu(rekey_tlv->GroupRekeyTime_sec));
            break;
        case MRVL_WPA_PASSPHRASE_TLV_ID:
            psk_tlv = (TLVBUF_WPA_PASSPHRASE *) pCurrentTlv;
            if (psk_tlv->Length > 0) {
                printf("WPA passphrase = ");
                for (i = 0; i < psk_tlv->Length; i++)
                    printf("%c", psk_tlv->Passphrase[i]);
                printf("\n");
            } else
                printf("WPA passphrase = None\n");
            break;
        case MRVL_WEP_KEY_TLV_ID:
            wep_tlv = (TLVBUF_WEP_KEY *) pCurrentTlv;
            print_wep_key(wep_tlv);
            break;
        case MRVL_STA_MAC_ADDR_FILTER_TLV_ID:
            filter_tlv = (TLVBUF_STA_MAC_ADDR_FILTER *) pCurrentTlv;
            print_mac_filter(filter_tlv);
            break;
        case MRVL_MAX_STA_CNT_TLV_ID:
            max_sta_tlv = (TLVBUF_MAX_STA_NUM *) pCurrentTlv;
            printf("Max Station Number = %d\n", max_sta_tlv->Max_sta_num);
            break;
        case MRVL_RETRY_LIMIT_TLV_ID:
            retry_limit_tlv = (TLVBUF_RETRY_LIMIT *) pCurrentTlv;
            printf("Retry Limit = %d\n", retry_limit_tlv->retry_limit);
            break;
        case MRVL_MGMT_IE_LIST_TLV_ID:
            custom_ie_tlv = (tlvbuf_custom_ie *) pCurrentTlv;
            custom_ie_len = tlvLen;
            custom_ie_ptr = (custom_ie *) (custom_ie_tlv->ie_data);
            while (custom_ie_len >= sizeof(custom_ie)) {
                printf("Index [%d]\n",
                       uap_le16_to_cpu(custom_ie_ptr->ie_index));
                printf("Management Subtype Mask = 0x%02x\n",
                       uap_le16_to_cpu(custom_ie_ptr->mgmt_subtype_mask));
                hexdump_data("IE Buffer", (void *) custom_ie_ptr->ie_buffer,
                             uap_le16_to_cpu(custom_ie_ptr->ie_length), ' ');
                custom_ie_len -=
                    sizeof(custom_ie) +
                    uap_le16_to_cpu(custom_ie_ptr->ie_length);
                custom_ie_ptr =
                    (custom_ie *) ((u8 *) custom_ie_ptr + sizeof(custom_ie) +
                                   uap_le16_to_cpu(custom_ie_ptr->ie_length));
            }
            break;
        case MRVL_BT_COEX_COMMON_CFG_TLV_ID:
            printf("Coex common configuration:\n");
            coex_common_tlv = (tlvbuf_coex_common_cfg *) pCurrentTlv;
            printf("\tConfig Bitmap = 0x%02lx\n",
                   uap_le32_to_cpu(coex_common_tlv->config_bitmap));
            break;

        case MRVL_BT_COEX_SCO_CFG_TLV_ID:
            printf("Coex sco configuration:\n");
            coex_sco_tlv = (tlvbuf_coex_sco_cfg *) pCurrentTlv;
            for (i = 0; i < 4; i++)
                printf("\tQtime protection [%d] = %d usecs\n", i,
                       uap_le16_to_cpu(coex_sco_tlv->protection_qtime[i]));
            printf("\tProtection frame rate = %d\n",
                   uap_le16_to_cpu(coex_sco_tlv->protection_rate));
            printf("\tACL frequency = %d\n",
                   uap_le16_to_cpu(coex_sco_tlv->acl_frequency));
            break;

        case MRVL_BT_COEX_ACL_CFG_TLV_ID:
            printf("Coex acl configuration: ");
            coex_acl_tlv = (tlvbuf_coex_acl_cfg *) pCurrentTlv;
            coex_acl_tlv->enabled = uap_le16_to_cpu(coex_acl_tlv->enabled);
            printf("%s\n", (coex_acl_tlv->enabled) ? "enabled" : "disabled");
            if (coex_acl_tlv->enabled) {
                printf("\tBT time = %d usecs\n",
                       uap_le16_to_cpu(coex_acl_tlv->bt_time));
                printf("\tWLan time = %d usecs\n",
                       uap_le16_to_cpu(coex_acl_tlv->wlan_time));
                printf("\tProtection frame rate = %d\n",
                       uap_le16_to_cpu(coex_acl_tlv->protection_rate));
            }
            break;

        case MRVL_BT_COEX_STATS_TLV_ID:
            printf("Coex statistics: \n");
            coex_stats_tlv = (tlvbuf_coex_stats *) pCurrentTlv;
            printf("\tNull not sent = %ld\n",
                   uap_le32_to_cpu(coex_stats_tlv->null_not_sent));
            printf("\tNull queued = %ld\n",
                   uap_le32_to_cpu(coex_stats_tlv->null_queued));
            printf("\tNull not queued = %ld\n",
                   uap_le32_to_cpu(coex_stats_tlv->null_not_queued));
            printf("\tCF End queued = %ld\n",
                   uap_le32_to_cpu(coex_stats_tlv->cf_end_queued));
            printf("\tCF End not queued = %ld\n",
                   uap_le32_to_cpu(coex_stats_tlv->cf_end_not_queued));
            printf("\tNull allocation failures = %ld\n",
                   uap_le32_to_cpu(coex_stats_tlv->null_alloc_fail));
            printf("\tCF End allocation failures = %ld\n",
                   uap_le32_to_cpu(coex_stats_tlv->cf_end_alloc_fail));
            break;
        default:
            break;
        }
        tlvBufLeft -= (sizeof(TLVBUF_HEADER) + tlvLen);
        pCurrentTlv = (TLVBUF_HEADER *) (pCurrentTlv->Data + tlvLen);
    }
    return;
}

/** 
 *  @brief Performs the ioctl operation to send the command to
 *  the driver.
 *
 *  @param cmd        	 Pointer to the command buffer
 *  @param size          Pointer to the command size. This value is
 *                       overwritten by the function with the size of the
 *                       received response.
 *  @param buf_size 	 Size of the allocated command buffer
 *  @return              UAP_SUCCESS or UAP_FAILURE
 */
int
uap_ioctl(u8 * cmd, u16 * size, u16 buf_size)
{
    struct ifreq ifr;
    APCMDBUF *header = NULL;
    s32 sockfd;

    if (buf_size < *size) {
        printf("buf_size should not less than cmd buffer size\n");
        return UAP_FAILURE;
    }

    /* Open socket */
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        printf("ERR:Cannot open socket\n");
        return UAP_FAILURE;
    }
    *(u32 *) cmd = buf_size - BUF_HEADER_SIZE;

    /* Initialize the ifr structure */
    memset(&ifr, 0, sizeof(ifr));
    strncpy(ifr.ifr_ifrn.ifrn_name, dev_name, strlen(dev_name));
    ifr.ifr_ifru.ifru_data = (void *) cmd;
    header = (APCMDBUF *) cmd;
    header->Size = *size - BUF_HEADER_SIZE;
    if (header->CmdCode == APCMD_SYS_CONFIGURE) {
        APCMDBUF_SYS_CONFIGURE *sys_cfg;
        sys_cfg = (APCMDBUF_SYS_CONFIGURE *) cmd;
        sys_cfg->Action = uap_cpu_to_le16(sys_cfg->Action);
    }
    endian_convert_request_header(header);
#if DEBUG
    /* Dump request buffer */
    hexdump("Request buffer", (void *) cmd, *size, ' ');
#endif
    /* Perform ioctl */
    errno = 0;
    if (ioctl(sockfd, UAPHOSTCMD, &ifr)) {
        perror("");
        printf("ERR:UAPHOSTCMD is not supported by %s\n", dev_name);
        close(sockfd);
        return UAP_FAILURE;
    }
    endian_convert_response_header(header);
    header->CmdCode &= HostCmd_CMD_ID_MASK;
    header->CmdCode |= APCMD_RESP_CHECK;
    *size = header->Size;

    /* Validate response size */
    if (*size > (buf_size - BUF_HEADER_SIZE)) {
        printf
            ("ERR:Response size (%d) greater than buffer size (%d)! Aborting!\n",
             *size, buf_size);
        close(sockfd);
        return UAP_FAILURE;
    }
#if DEBUG
    /* Dump respond buffer */
    hexdump("Respond buffer", (void *) header, header->Size + BUF_HEADER_SIZE,
            ' ');
#endif

    /* Close socket */
    close(sockfd);
    return UAP_SUCCESS;
}

/** 
 *  @brief check cipher is valid or not
 *
 *  @param pairwisecipher    pairwise cipher
 *  @param groupcipher       group cipher
 *  @return         UAP_SUCCESS or UAP_FAILURE
 */
int
is_cipher_valid(int pairwisecipher, int groupcipher)
{
    if ((pairwisecipher == CIPHER_NONE) && (groupcipher == CIPHER_NONE))
        return UAP_SUCCESS;
    if ((pairwisecipher == CIPHER_TKIP) && (groupcipher == CIPHER_TKIP))
        return UAP_SUCCESS;
    if ((pairwisecipher == CIPHER_AES_CCMP) && (groupcipher == CIPHER_AES_CCMP))
        return UAP_SUCCESS;
    if ((pairwisecipher == CIPHER_BITMAP) && (groupcipher == CIPHER_TKIP))
        return UAP_SUCCESS;
    return UAP_FAILURE;
}

/** 
 *  @brief The main function
 *
 *  @param argc     Number of arguments
 *  @param argv     Pointer to the arguments
 *  @return         0 or 1
 */
int
main(int argc, char *argv[])
{
    int opt, i;
    memset(dev_name, 0, sizeof(dev_name));
    strcpy(dev_name, DEFAULT_DEV_NAME);

    /* parse arguments */
    while ((opt = getopt_long(argc, argv, "+hi:d:v", ap_options, NULL)) != -1) {
        switch (opt) {
        case 'i':
            if (strlen(optarg) < IFNAMSIZ) {
                memset(dev_name, 0, sizeof(dev_name));
                strncpy(dev_name, optarg, strlen(optarg));
            }
            printf("dev_name:%s\n", dev_name);
            break;
        case 'v':
            printf("uaputl - uAP utility ver %s\n", UAP_VERSION);
            exit(0);
        case 'd':
            debug_level = strtoul(optarg, NULL, 10);
            uap_printf(MSG_DEBUG, "debug_level=%x\n", debug_level);
            break;
        case 'h':
        default:
            print_tool_usage();
            exit(0);
        }
    }

    argc -= optind;
    argv += optind;
    optind = 0;

    if (argc < 1) {
        print_tool_usage();
        exit(1);
    }

    /* process command */
    for (i = 0; ap_command[i].cmd; i++) {
        if (strncmp(ap_command[i].cmd, argv[0], strlen(ap_command[i].cmd)))
            continue;
        if (strlen(ap_command[i].cmd) != strlen(argv[0]))
            continue;
        ap_command[i].func(argc, argv);
        break;
    }
    if (!ap_command[i].cmd) {
        printf("ERR: %s is not supported\n", argv[0]);
        exit(1);
    }
    return 0;
}