/*
<:copyright-BRCM:2016:DUAL/GPL:standard

   Broadcom Proprietary and Confidential.(c) 2016 Broadcom
   All Rights Reserved

Unless you and Broadcom execute a separate written software license
agreement governing use of this software, this software is licensed
to you under the terms of the GNU General Public License version 2
(the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
with the following added to such license:

   As a special exception, the copyright holders of this software give
   you permission to link this software with independent modules, and
   to copy and distribute the resulting executable under terms of your
   choice, provided that you also meet, for each linked independent
   module, the terms and conditions of the license of that module.
   An independent module is a module which is not derived from this
   software.  The special exception does not apply to any modifications
   of the software.

Not withstanding the above, under no circumstances may you combine
this software in any way with any other Broadcom software provided
under a license other than the GPL, without Broadcom's express prior
written consent.

:>
 */

#include <bcmcli.h>
#include "bcmolt_board.h"
#include "bcmolt_board_cli.h"
#include <arpa/inet.h>

#define BCM_I2C_DEV_ADDR_START static bcmcli_enum_val bcm_i2c_dev_addr_table[] = {
#define BCM_I2C_DEV_ADDR(name, desc, val) {desc, val},
#define BCM_I2C_DEV_ADDR_END BCMCLI_ENUM_LAST};
#include <bcmolt_i2c_devs_addr.h>

static bcmos_errno bcm_board_cli_dev_change(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    uint32_t addr = bcmcli_find_named_parm(session, "dev")->value.unumber;

    return bcm_board_dev_change(addr);
}

static bcmos_errno bcm_board_cli_dev_write(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    uint32_t count = bcmcli_find_named_parm(session, "width")->value.unumber;
    uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
    uint32_t val = bcmcli_find_named_parm(session, "val")->value.unumber;

    switch (count)
    {
    case 8:
    case 16:
    case 32:
        break;
    default:
        bcmcli_session_print(session, "Count can be 8|16|32\n");
        return BCM_ERR_PARM;
    }
    return bcm_board_dev_write(count, addr, val);
}

static bcmos_errno bcm_board_cli_dev_read(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    uint32_t count = bcmcli_find_named_parm(session, "width")->value.unumber;
    uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
    uint32_t val;
    bcmos_errno rc;
    
    switch (count)
    {
    case 8:
    case 16:
    case 32:
        break;
    default:
        bcmcli_session_print(session, "Count can be 8|16|32\n");
        return BCM_ERR_PARM;
    }
    rc = bcm_board_dev_read(count, addr, &val);
    BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_dev_read() failed\n");
    bcmcli_session_print(session, "0x%x\n", val);
    
    return BCM_ERR_OK;
}

static bcmos_errno bcm_board_cli_switch_write(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    uint32_t val = bcmcli_find_named_parm(session, "val")->value.unumber;

    return bcm_board_switch_write(val);
}

static bcmos_errno bcm_board_cli_switch_read(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    uint32_t val;
    bcmos_errno rc;

    rc = bcm_board_switch_read(&val);
    BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_switch_read() failed\n");
    bcmcli_session_print(session, "0x%x\n", val);
    
    return BCM_ERR_OK;
}

static bcmos_errno bcm_board_cli_fpga_write(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
    uint32_t val = bcmcli_find_named_parm(session, "val")->value.unumber;
    
    return bcm_board_fpga_write(addr, val);
}

static bcmos_errno bcm_board_cli_fpga_read(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
    uint32_t val;
    bcmos_errno rc;
    
    rc = bcm_board_fpga_read(addr, &val);
    BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_fpga_read() failed\n");
    bcmcli_session_print(session, "0x%x\n", val);

    return BCM_ERR_OK;
}

static bcmos_errno bcm_board_cli_fpga_version(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    uint32_t version;
    bcmos_errno rc;

    rc = bcm_board_fpga_version_get(&version);
    bcmcli_session_print(session, "0x%x\n", version);
    return rc;
}

static bcmos_errno bcm_board_cli_fpga_set_gpio_dir(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    bcmolt_gpio_pin gpio_pin = bcmcli_find_named_parm(session, "gpio_pin")->value.unumber;
    bcm_fpga_gpio_dir dir = bcmcli_find_named_parm(session, "dir")->value.unumber;

    return bcm_board_fpga_set_gpio_dir(gpio_pin, dir);
}

static bcmos_errno bcm_board_cli_fpga_get_gpio_dir(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    bcmolt_gpio_pin gpio_pin = bcmcli_find_named_parm(session, "gpio_pin")->value.unumber;
    bcm_fpga_gpio_dir dir;
    bcmos_errno rc;
  
    rc = bcm_board_fpga_get_gpio_dir(gpio_pin, &dir);
    bcmcli_session_print(session, "%s\n", dir == BCM_FPGA_GPIO_DIR_INPUT ? "input" : "output");
    return rc;
}

static bcmos_errno bcm_board_cli_fpga_write_gpio(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    bcmolt_gpio_pin gpio_pin = bcmcli_find_named_parm(session, "gpio_pin")->value.unumber;
    uint32_t val = bcmcli_find_named_parm(session, "val")->value.unumber;

    return bcm_board_fpga_write_gpio(gpio_pin, val);
}

static bcmos_errno bcm_board_cli_fpga_read_gpio(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    bcmolt_gpio_pin gpio_pin = bcmcli_find_named_parm(session, "gpio_pin")->value.unumber;
    uint32_t val;
    bcmos_errno rc;
  
    rc = bcm_board_fpga_read_gpio(gpio_pin, &val);
    bcmcli_session_print(session, "0x%x\n", val);
    return rc;
}

static bcmos_errno bcm_board_cli_fpga_gen_gpio_irq(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    bcmolt_ext_irq ext_irq = bcmcli_find_named_parm(session, "irq")->value.unumber;
  
    return bcm_board_fpga_gen_gpio_irq(ext_irq);
}

static bcmos_errno bcm_board_cli_trx_enable(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    uint8_t pon_id = bcmcli_find_named_parm(session, "pon_id")->value.unumber;

    return bcm_board_trx_enable(pon_id, BCMOS_TRUE);
}

static bcmos_errno bcm_board_cli_trx_disable(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    uint8_t pon_id = bcmcli_find_named_parm(session, "pon_id")->value.unumber;

    return bcm_board_trx_enable(pon_id, BCMOS_FALSE);
}

static bcmos_errno bcm_board_cli_device_reset(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    return bcm_board_device_reset();
}

static bcmos_errno bcm_board_cli_device_on(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    return bcm_board_device_on();
}

static bcmos_errno bcm_board_cli_device_off(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    return bcm_board_device_off();
}

static bcmos_errno bcm_board_cli_kt2_on(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    return bcm_board_kt2_device_on();
}

static bcmos_errno bcm_board_cli_kt2_off(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    return bcm_board_kt2_device_off();
}

static bcmos_errno bcm_board_cli_fpga_reg_read(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
	uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
	uint32_t val;
	bcmos_errno rc;

	rc = bcm_board_fpga_reg_read(addr, &val);
	BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_fpga_reg_read() failed\n");
	bcmcli_session_print(session, "0x%x\n", val);

	return BCM_ERR_OK;
}

static bcmos_errno bcm_board_cli_fpga_reg_write(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
	uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
	uint32_t val = bcmcli_find_named_parm(session, "val")->value.unumber;

    return bcm_board_fpga_reg_write(addr, val);
}

static bcmos_errno bcm_board_cli_burn_dpll(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
	bcmos_errno rc;

    uint32_t dev = bcmcli_find_named_parm(session, "device")->value.unumber;
    rc = bcm_board_burn_pon_dpll(dev);
	BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_burn_pon_dpll() failed\n");

    return BCM_ERR_OK;
}

static bcmos_errno bcm_board_cli_dpll_write(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    uint32_t page = bcmcli_find_named_parm(session, "page")->value.unumber;
    uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
    uint32_t val = bcmcli_find_named_parm(session, "val")->value.unumber;
    
    return bcm_board_write_dpll(page, addr, val);
}

static bcmos_errno bcm_board_cli_dpll_read(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
{
    uint32_t page = bcmcli_find_named_parm(session, "page")->value.unumber;
    uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
    uint32_t val;
    bcmos_errno rc;
    
    rc = bcm_board_read_dpll(page, addr, &val);
    BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_dpll_read() failed\n");
    bcmcli_session_print(session, "0x%x\n", val);

    return BCM_ERR_OK;
}

/* LUK_MAX_DATA_SIZE (2*1024) */
#define SWITCH_RECEIVE_BUFFER_LENGTH   (2*1024)
static int switch_socket = -1;
static char *switch_buffer = NULL;
static bcmos_bool switch_first_connection = BCMOS_TRUE;

static void switch_response(bcmcli_session *session)
{
    int len;
    char *prompt = NULL;

    while (1)
    {
        len = read(switch_socket, switch_buffer, SWITCH_RECEIVE_BUFFER_LENGTH-1);
        if (len > 0)
        {
            switch_buffer[len] = '\0';
            bcmcli_print(session, "%s", switch_buffer);
            prompt = strstr(switch_buffer, "BCM");
            while (prompt)
            {
                len = strlen(prompt);
                if (len >= 6)
                {
                    if ((prompt[3] == '>') || ((prompt[3] == '.') && (prompt[5] == '>')))
                        return;
                }
                else if (len >= 4)
                {
                    if (prompt[3] == '>')
                        return;
                }
                prompt = strstr(&prompt[2], "BCM");
            }
        }
        else
            break;
    }
}

static bcmos_errno kt2_conn(bcmcli_session *session, const bcmcli_cmd_parm parm[],  uint16_t n_parms)
{
    struct sockaddr_in server;

    if (switch_socket != -1)
    {
        bcmcli_print(session, "A connection already exists\n");
        return BCM_ERR_ALREADY;
    }

    switch_buffer = bcmos_alloc(SWITCH_RECEIVE_BUFFER_LENGTH);
    if (!switch_buffer)
    {
        bcmcli_print(session, "Failed to allocate buffer\n");
        return BCM_ERR_NOMEM;
    }
    memset((void *)&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(parm[0].value.number);
    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    switch_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (switch_socket < 0)
    {
        bcmcli_print(session, "Can't open client socket\n");
        goto exit;
    }
    if (connect(switch_socket, (struct sockaddr *)&server, sizeof(server)) == -1)
    {
        close(switch_socket);
        bcmcli_print(session, "Failed to connect\n");
        goto exit;
    }
    if (switch_first_connection)
    {
        switch_first_connection = BCMOS_FALSE;
        switch_response(session);
    }

    return BCM_ERR_OK;

exit:
    bcmos_free(switch_buffer);
    return BCM_ERR_COMM_FAIL;
}

static bcmos_errno kt2_disconn(bcmcli_session *session, const bcmcli_cmd_parm parm[],  uint16_t n_parms)
{
    if (switch_socket != -1)
    {
        bcmcli_print(session, "Send 'exit'\n");
        if (write(switch_socket, "exit\r", strlen("exit\r")) < 0)
            bcmcli_print(session, "Send 'exit' to switch failed\n");
        fsync(switch_socket);
    }
    bcmos_usleep(1000);
    if (switch_socket != -1)
        close(switch_socket);
    if (switch_buffer)
        bcmos_free(switch_buffer);
    /* set socket and buffer with initial values */
    switch_socket = -1;
    switch_buffer = NULL;

    return BCM_ERR_OK;
}

static bcmos_errno kt2_cmd(bcmcli_session *session, const bcmcli_cmd_parm parm[],  uint16_t n_parms)
{
    int len, sent_len;
    char *str;

    if ((switch_socket == -1) || (!switch_buffer))
    {
        bcmcli_print(session, "Connection or buffer do not exist\n");
        return BCM_ERR_NORES;
    }
    /* switch user space application receives thru _fd_input_cb and
       send to kernel thru _kernel_proxy_output_cb */
    len = (int)strlen(parm[0].value.string);
    {
        /* dirty - just to avoid error : cast discards '__attribute__((const))' qualifier if useing strcat */
        unsigned long strp = (unsigned long)&parm[0].value.string;
        str = *(char **)strp;
    }
    str[len++] = '\r';
    str[len] = '\0';
    sent_len = 0;
    do
    {
        sent_len = write(switch_socket, str + sent_len , len - sent_len);
        if (sent_len == -1 || ((sent_len == 0) && errno))
        {
            bcmcli_print(session, "Send command to switch failed (write to socket error: %d)\n", errno);
            return BCM_ERR_COMM_FAIL;
        }
        fsync(switch_socket);
    } while(len - sent_len);
    /* switch kernel send thru _kernel_proxy_input_cb
       to switch user space application thru _fd_outout_cb */
    switch_response(session);

    return BCM_ERR_OK;
}

bcmos_errno bcm_board_cli_init(bcmcli_entry *top_dir)
{
    bcmcli_entry *board_dir, *i2c_dir;
    bcmos_errno rc;
    bcm_board_svk_board_id board_id;
    bcmcli_entry *dir;
    static bcmcli_enum_val fpga_gpio_pin_table[] =
    {
        {"pin4", BCMOLT_GPIO_PIN_PIN4},
        {"pin5", BCMOLT_GPIO_PIN_PIN5},
        {"pin6", BCMOLT_GPIO_PIN_PIN6},
        {"pin7", BCMOLT_GPIO_PIN_PIN7},
        {"pin8", BCMOLT_GPIO_PIN_PIN8},
        {"pin9", BCMOLT_GPIO_PIN_PIN9},
        {"pin10", BCMOLT_GPIO_PIN_PIN10},
        {"pin11", BCMOLT_GPIO_PIN_PIN11},
        {"pin12", BCMOLT_GPIO_PIN_PIN12},
        {"pin13", BCMOLT_GPIO_PIN_PIN13},
        {"pin14", BCMOLT_GPIO_PIN_PIN14},
        {"pin15", BCMOLT_GPIO_PIN_PIN15},
        {"pin16", BCMOLT_GPIO_PIN_PIN16},
        {"pin17", BCMOLT_GPIO_PIN_PIN17},
        {"pin18", BCMOLT_GPIO_PIN_PIN18},
        {"pin19", BCMOLT_GPIO_PIN_PIN19},
        {"pin20", BCMOLT_GPIO_PIN_PIN20},
        {"pin21", BCMOLT_GPIO_PIN_PIN21},
        {"pin22", BCMOLT_GPIO_PIN_PIN22},
        {"pin23", BCMOLT_GPIO_PIN_PIN23},
        {"pin24", BCMOLT_GPIO_PIN_PIN24},
        {"pin25", BCMOLT_GPIO_PIN_PIN25},
        {"pin26", BCMOLT_GPIO_PIN_PIN26},
        {"pin27", BCMOLT_GPIO_PIN_PIN27},
        {"pin28", BCMOLT_GPIO_PIN_PIN28},
        {"pin29", BCMOLT_GPIO_PIN_PIN29},
        {"pin30", BCMOLT_GPIO_PIN_PIN30},
        {"pin31", BCMOLT_GPIO_PIN_PIN31},
        BCMCLI_ENUM_LAST
    };
    static bcmcli_enum_val fpga_ext_irq_table[] =
    {
        {"ext_irq0", BCMOLT_EXT_IRQ_EXT_IRQ0},
        {"ext_irq1", BCMOLT_EXT_IRQ_EXT_IRQ1},
        {"ext_irq2", BCMOLT_EXT_IRQ_EXT_IRQ2},
        {"ext_irq3", BCMOLT_EXT_IRQ_EXT_IRQ3},
        {"ext_irq4", BCMOLT_EXT_IRQ_EXT_IRQ4},
        {"ext_irq5", BCMOLT_EXT_IRQ_EXT_IRQ5},
        BCMCLI_ENUM_LAST
    };

    static bcmcli_enum_val fpga_gpio_dir_table[] =
    {
        {"input", BCM_FPGA_GPIO_DIR_INPUT},
        {"output", BCM_FPGA_GPIO_DIR_OUTPUT},
        BCMCLI_ENUM_LAST
    };

    static bcmcli_enum_val dpll_devices[] = {
        { .name="gpon", .val=GPON_DPLL},
        { .name="epon", .val=EPON_DPLL},
        { .name="synce", .val=GPON_SYNCE},
        BCMCLI_ENUM_LAST
    };
    
    board_dir = bcmcli_dir_add(top_dir, "board", "Board", BCMCLI_ACCESS_GUEST, NULL);
    BCMOS_CHECK_RETURN_ERROR(!board_dir, BCM_ERR_INTERNAL);

    i2c_dir = bcmcli_dir_add(board_dir, "i2c", "i2c", BCMCLI_ACCESS_GUEST, NULL);
    BCMOS_CHECK_RETURN_ERROR(!i2c_dir, BCM_ERR_INTERNAL);

    BCMCLI_MAKE_CMD(i2c_dir, "dev_change", "Change current device", bcm_board_cli_dev_change,
        BCMCLI_MAKE_PARM_ENUM("dev", "device", bcm_i2c_dev_addr_table, 0));

    BCMCLI_MAKE_CMD(i2c_dir, "dev_write", "Write to current i2c device", bcm_board_cli_dev_write,
        BCMCLI_MAKE_PARM("width", "Width of register in bits (8|16|32)", BCMCLI_PARM_NUMBER, 0),
        BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0),
        BCMCLI_MAKE_PARM("val", "value", BCMCLI_PARM_HEX, 0));

    BCMCLI_MAKE_CMD(i2c_dir, "dev_read", "Read from current i2c device", bcm_board_cli_dev_read,
        BCMCLI_MAKE_PARM("width", "Width of register in bits (8|16|32)", BCMCLI_PARM_NUMBER, 0),
        BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0));

    BCMCLI_MAKE_CMD(i2c_dir, "switch_write", "Write to switch", bcm_board_cli_switch_write,
        BCMCLI_MAKE_PARM_RANGE("val", "value", BCMCLI_PARM_HEX, 0, 0, UCHAR_MAX));

    BCMCLI_MAKE_CMD_NOPARM(i2c_dir, "switch_read", "Read from switch", bcm_board_cli_switch_read);

    BCMCLI_MAKE_CMD(i2c_dir, "fpga_write", "Write to FPGA", bcm_board_cli_fpga_write,
        BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0),
        BCMCLI_MAKE_PARM("val", "value", BCMCLI_PARM_HEX, 0));

    BCMCLI_MAKE_CMD(i2c_dir, "fpga_read", "Read from FPGA", bcm_board_cli_fpga_read,
        BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0));

    BCMCLI_MAKE_CMD_NOPARM(board_dir, "fpga_version", "FPGA version", bcm_board_cli_fpga_version);
    
    BCMCLI_MAKE_CMD(board_dir, "fpga_set_gpio_dir", "Set GPIO direction", bcm_board_cli_fpga_set_gpio_dir,
        BCMCLI_MAKE_PARM_ENUM("gpio_pin", "GPIO pin", fpga_gpio_pin_table, 0),
        BCMCLI_MAKE_PARM_ENUM("dir", "Direction", fpga_gpio_dir_table, 0));
    BCMCLI_MAKE_CMD(board_dir, "fpga_get_gpio_dir", "Get GPIO direction", bcm_board_cli_fpga_get_gpio_dir,
        BCMCLI_MAKE_PARM_ENUM("gpio_pin", "GPIO pin", fpga_gpio_pin_table, 0));
    BCMCLI_MAKE_CMD(board_dir, "fpga_write_gpio", "Write to GPIO pin", bcm_board_cli_fpga_write_gpio,
        BCMCLI_MAKE_PARM_ENUM("gpio_pin", "GPIO pin", fpga_gpio_pin_table, 0),
        BCMCLI_MAKE_PARM("val", "Value", BCMCLI_PARM_HEX, 0));
    BCMCLI_MAKE_CMD(board_dir, "fpga_read_gpio", "Read from GPIO pin", bcm_board_cli_fpga_read_gpio,
        BCMCLI_MAKE_PARM_ENUM("gpio_pin", "GPIO pin", fpga_gpio_pin_table, 0));
    BCMCLI_MAKE_CMD(board_dir, "fpga_gen_irq", "Generate GPIO IRQ", bcm_board_cli_fpga_gen_gpio_irq,
        BCMCLI_MAKE_PARM_ENUM("irq", "IRQ", fpga_ext_irq_table, 0));

    BCMCLI_MAKE_CMD(board_dir, "trx_enable", "Enable transceiver", bcm_board_cli_trx_enable,
        BCMCLI_MAKE_PARM("pon_id", "pon_id", BCMCLI_PARM_UDECIMAL, 0));

    BCMCLI_MAKE_CMD(board_dir, "trx_disable", "Disable transceiver", bcm_board_cli_trx_disable,
        BCMCLI_MAKE_PARM("pon_id", "pon_id", BCMCLI_PARM_UDECIMAL, 0));

    BCMCLI_MAKE_CMD_NOPARM(board_dir, "device_reset", "Reset the device - clears the reset bit and then set it on", bcm_board_cli_device_reset);

    BCMCLI_MAKE_CMD_NOPARM(board_dir, "device_on", "Keeps the device with reset bit on", bcm_board_cli_device_on);

    BCMCLI_MAKE_CMD_NOPARM(board_dir, "device_off", "Keeps the device with reset bit off", bcm_board_cli_device_off);

    BCMCLI_MAKE_CMD(board_dir, "fpga_reg_read", "Read data from an FPGA register", bcm_board_cli_fpga_reg_read,
    	BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0));

    BCMCLI_MAKE_CMD(board_dir, "fpga_reg_write", "Write data to an FPGA register", bcm_board_cli_fpga_reg_write,
        BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0),
        BCMCLI_MAKE_PARM("val", "value", BCMCLI_PARM_HEX, 0));

    BCMCLI_MAKE_CMD(board_dir, "dpll", "Burn DPLL", bcm_board_cli_burn_dpll,
        BCMCLI_MAKE_PARM_ENUM("device", "Device", dpll_devices, 0));
    
    BCMCLI_MAKE_CMD(board_dir, "dpll_write", "Write to DPLL", bcm_board_cli_dpll_write,
        BCMCLI_MAKE_PARM("page", "page", BCMCLI_PARM_HEX, 0),
        BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0),
        BCMCLI_MAKE_PARM("val", "value", BCMCLI_PARM_HEX, 0));

    BCMCLI_MAKE_CMD(board_dir, "dpll_read", "Read from DPLL", bcm_board_cli_dpll_read,
        BCMCLI_MAKE_PARM("page", "page", BCMCLI_PARM_HEX, 0),
        BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0));

    rc = bcm_board_get_board_id(&board_id);
    BCMOS_CHECK_RETURN(rc, rc, rc);
    /* check if the board is SVK#3 */
    if (board_id == SVK_3)
    {
        BCMCLI_MAKE_CMD_NOPARM(board_dir, "kt2_on", "Keeps the Katana2 with reset bit on", bcm_board_cli_kt2_on);

        BCMCLI_MAKE_CMD_NOPARM(board_dir, "kt2_off", "Keeps the Katana2 with reset bit off", bcm_board_cli_kt2_off);

        dir = bcmcli_dir_add(board_dir, "switch", "Switch", BCMCLI_ACCESS_ADMIN, NULL);
        BCMOS_CHECK_RETURN_ERROR(!dir, BCM_ERR_NOMEM);
        BCMCLI_MAKE_CMD(dir, "conn", "connect to switch daemon", kt2_conn,
            BCMCLI_MAKE_PARM("port", "connection port on localhost", BCMCLI_PARM_NUMBER, 0));
        BCMCLI_MAKE_CMD_NOPARM(dir, "disconn", "disconnect from switch daemon", kt2_disconn);
        BCMCLI_MAKE_CMD(dir, "cmd", "command to switch - string between quotes", kt2_cmd,
            BCMCLI_MAKE_PARM("", "", BCMCLI_PARM_STRING, 0));
    }
    return BCM_ERR_OK;
}