| /* |
| <: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; |
| } |
| |