brain-hackers_pepepper-mirror/u-boot-brain
1
0
Fork 0
mirror of https://github.com/brain-hackers/u-boot-brain synced 2024-06-09 23:36:03 +09:00
Code Issues Projects Releases Wiki Activity

drivers/net/vsc9953: Add commands to manipulate the FDB for VSC9953

Browse Source 
The new command:
ethsw [port <port_no>] [vlan <vid>] fdb
        { [help] | show | flush | { add | del } <mac> }

Can be used to add and delete FDB entries. Also, the command can be used
to show entries from the FDB tables. When used with [port <port_no>]
and [vlan <vid>], only the matching the FDB entries can be seen or
flushed. The command has also been added to the generic ethsw parser
from cmd_ethsw.c.

Signed-off-by: Johnson Leung <johnson.leung@freescale.com>
Signed-off-by: Codrin Ciubotariu <codrin.ciubotariu@freescale.com>
Acked-by: Joe Hershberger <joe.hershberger@ni.com>
Reviewed-by: York Sun <yorksun@freescale.com>
This commit is contained in:
Codrin Ciubotariu 2015-09-09 18:00:52 +03:00 committed by York Sun
parent 0118e83ba4
commit 22449858f8
4 changed files with 693 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

178
common/cmd_ethsw.c
View File

@ -9,6 +9,7 @@
#include <common.h>
#include <command.h>
#include <errno.h>
#include <env_flags.h>
#include <ethsw.h>
static const char *ethsw_name;
@ -34,6 +35,18 @@ static int ethsw_learn_help_key_func(struct ethsw_command_def *parsed_cmd)
return CMD_RET_SUCCESS;
}
#define ETHSW_FDB_HELP "ethsw [port <port_no>] [vlan <vid>] fdb " \
"{ [help] | show | flush | { add | del } <mac> } " \
"- Add/delete a mac entry in FDB; use show to see FDB entries; " \
"if vlan <vid> is missing, VID 1 will be used"
static int ethsw_fdb_help_key_func(struct ethsw_command_def *parsed_cmd)
{
printf(ETHSW_FDB_HELP"\n");
return CMD_RET_SUCCESS;
}
static struct keywords_to_function {
enum ethsw_keyword_id cmd_keyword[ETHSW_MAX_CMD_PARAMS];
int cmd_func_offset;
@ -130,6 +143,59 @@ static struct keywords_to_function {
.cmd_func_offset = offsetof(struct ethsw_command_func,
port_learn),
.keyword_function = NULL,
}, {
.cmd_keyword = {
ethsw_id_fdb,
ethsw_id_key_end,
},
.cmd_func_offset = -1,
.keyword_function = &ethsw_fdb_help_key_func,
}, {
.cmd_keyword = {
ethsw_id_fdb,
ethsw_id_help,
ethsw_id_key_end,
},
.cmd_func_offset = -1,
.keyword_function = &ethsw_fdb_help_key_func,
}, {
.cmd_keyword = {
ethsw_id_fdb,
ethsw_id_show,
ethsw_id_key_end,
},
.cmd_func_offset = offsetof(struct ethsw_command_func,
fdb_show),
.keyword_function = NULL,
}, {
.cmd_keyword = {
ethsw_id_fdb,
ethsw_id_flush,
ethsw_id_key_end,
},
.cmd_func_offset = offsetof(struct ethsw_command_func,
fdb_flush),
.keyword_function = NULL,
}, {
.cmd_keyword = {
ethsw_id_fdb,
ethsw_id_add,
ethsw_id_add_del_mac,
ethsw_id_key_end,
},
.cmd_func_offset = offsetof(struct ethsw_command_func,
fdb_entry_add),
.keyword_function = NULL,
}, {
.cmd_keyword = {
ethsw_id_fdb,
ethsw_id_del,
ethsw_id_add_del_mac,
ethsw_id_key_end,
},
.cmd_func_offset = offsetof(struct ethsw_command_func,
fdb_entry_del),
.keyword_function = NULL,
},
};
@ -142,6 +208,20 @@ struct keywords_optional {
ethsw_id_port_no,
ethsw_id_key_end,
},
}, {
.cmd_keyword = {
ethsw_id_vlan,
ethsw_id_vlan_no,
ethsw_id_key_end,
},
}, {
.cmd_keyword = {
ethsw_id_port,
ethsw_id_port_no,
ethsw_id_vlan,
ethsw_id_vlan_no,
ethsw_id_key_end,
},
},
};
@ -151,6 +231,12 @@ static int keyword_match_gen(enum ethsw_keyword_id key_id, int argc, char
static int keyword_match_port(enum ethsw_keyword_id key_id, int argc,
char *const argv[], int *argc_nr,
struct ethsw_command_def *parsed_cmd);
static int keyword_match_vlan(enum ethsw_keyword_id key_id, int argc,
char *const argv[], int *argc_nr,
struct ethsw_command_def *parsed_cmd);
static int keyword_match_mac_addr(enum ethsw_keyword_id key_id, int argc,
char *const argv[], int *argc_nr,
struct ethsw_command_def *parsed_cmd);
/*
* Define properties for each keyword;
@ -188,6 +274,21 @@ struct keyword_def {
}, {
.keyword_name = "auto",
.match = &keyword_match_gen,
}, {
.keyword_name = "vlan",
.match = &keyword_match_vlan,
}, {
.keyword_name = "fdb",
.match = &keyword_match_gen,
}, {
.keyword_name = "add",
.match = &keyword_match_mac_addr,
}, {
.keyword_name = "del",
.match = &keyword_match_mac_addr,
}, {
.keyword_name = "flush",
.match = &keyword_match_gen,
},
};
@ -259,6 +360,78 @@ static int keyword_match_port(enum ethsw_keyword_id key_id, int argc,
return 0;
}
/* Function used to match the command's vlan */
static int keyword_match_vlan(enum ethsw_keyword_id key_id, int argc,
char *const argv[], int *argc_nr,
struct ethsw_command_def *parsed_cmd)
{
unsigned long val;
int aux;
if (!keyword_match_gen(key_id, argc, argv, argc_nr, parsed_cmd))
return 0;
if (*argc_nr + 1 >= argc)
return 0;
if (strict_strtoul(argv[*argc_nr + 1], 10, &val) != -EINVAL) {
parsed_cmd->vid = val;
(*argc_nr)++;
parsed_cmd->cmd_to_keywords[*argc_nr] = ethsw_id_vlan_no;
return 1;
}
aux = *argc_nr + 1;
if (keyword_match_gen(ethsw_id_add, argc, argv, &aux, parsed_cmd))
parsed_cmd->cmd_to_keywords[*argc_nr + 1] = ethsw_id_add;
else if (keyword_match_gen(ethsw_id_del, argc, argv, &aux, parsed_cmd))
parsed_cmd->cmd_to_keywords[*argc_nr + 1] = ethsw_id_del;
else
return 0;
if (*argc_nr + 2 >= argc)
return 0;
if (strict_strtoul(argv[*argc_nr + 2], 10, &val) != -EINVAL) {
parsed_cmd->vid = val;
(*argc_nr) += 2;
parsed_cmd->cmd_to_keywords[*argc_nr] = ethsw_id_add_del_no;
return 1;
}
return 0;
}
/* Function used to match the command's MAC address */
static int keyword_match_mac_addr(enum ethsw_keyword_id key_id, int argc,
char *const argv[], int *argc_nr,
struct ethsw_command_def *parsed_cmd)
{
if (!keyword_match_gen(key_id, argc, argv, argc_nr, parsed_cmd))
return 0;
if ((*argc_nr + 1 >= argc) ||
!is_broadcast_ethaddr(parsed_cmd->ethaddr))
return 1;
if (eth_validate_ethaddr_str(argv[*argc_nr + 1])) {
printf("Invalid MAC address: %s\n", argv[*argc_nr + 1]);
return 0;
}
eth_parse_enetaddr(argv[*argc_nr + 1], parsed_cmd->ethaddr);
if (is_broadcast_ethaddr(parsed_cmd->ethaddr)) {
memset(parsed_cmd->ethaddr, 0xFF, sizeof(parsed_cmd->ethaddr));
return 0;
}
parsed_cmd->cmd_to_keywords[*argc_nr + 1] = ethsw_id_add_del_mac;
return 1;
}
/* Finds optional keywords and modifies *argc_va to skip them */
static void cmd_keywords_opt_check(const struct ethsw_command_def *parsed_cmd,
int *argc_val)
@ -416,7 +589,11 @@ static void command_def_init(struct ethsw_command_def *parsed_cmd)
parsed_cmd->cmd_to_keywords[i] = ethsw_id_key_end;
parsed_cmd->port = ETHSW_CMD_PORT_ALL;
parsed_cmd->vid = ETHSW_CMD_VLAN_ALL;
parsed_cmd->cmd_function = NULL;
/* We initialize the MAC address with the Broadcast address */
memset(parsed_cmd->ethaddr, 0xff, sizeof(parsed_cmd->ethaddr));
}
/* function to interpret commands starting with "ethsw " */
@ -446,4 +623,5 @@ U_BOOT_CMD(ethsw, ETHSW_MAX_CMD_PARAMS, 0, do_ethsw,
ETHSW_PORT_CONF_HELP"\n"
ETHSW_PORT_STATS_HELP"\n"
ETHSW_LEARN_HELP"\n"
ETHSW_FDB_HELP"\n"
);

472
drivers/net/vsc9953.c
View File

@ -783,6 +783,389 @@ static int vsc9953_port_learn_mode_get(int port_no, enum port_learn_mode *mode)
return 0;
}
/* wait for FDB to become available */
static int vsc9953_mac_table_poll_idle(void)
{
struct vsc9953_analyzer *l2ana_reg;
u32 timeout;
l2ana_reg = (struct vsc9953_analyzer *)(VSC9953_OFFSET +
VSC9953_ANA_OFFSET);
timeout = 50000;
while (((in_le32(&l2ana_reg->ana_tables.mac_access) &
VSC9953_MAC_CMD_MASK) !=
VSC9953_MAC_CMD_IDLE) && --timeout)
udelay(1);
return timeout ? 0 : -EBUSY;
}
/* enum describing available commands for the MAC table */
enum mac_table_cmd {
MAC_TABLE_READ,
MAC_TABLE_LOOKUP,
MAC_TABLE_WRITE,
MAC_TABLE_LEARN,
MAC_TABLE_FORGET,
MAC_TABLE_GET_NEXT,
MAC_TABLE_AGE,
};
/* Issues a command to the FDB table */
static int vsc9953_mac_table_cmd(enum mac_table_cmd cmd)
{
struct vsc9953_analyzer *l2ana_reg;
l2ana_reg = (struct vsc9953_analyzer *)(VSC9953_OFFSET +
VSC9953_ANA_OFFSET);
switch (cmd) {
case MAC_TABLE_READ:
clrsetbits_le32(&l2ana_reg->ana_tables.mac_access,
VSC9953_MAC_CMD_MASK | VSC9953_MAC_CMD_VALID,
VSC9953_MAC_CMD_READ);
break;
case MAC_TABLE_LOOKUP:
clrsetbits_le32(&l2ana_reg->ana_tables.mac_access,
VSC9953_MAC_CMD_MASK, VSC9953_MAC_CMD_READ |
VSC9953_MAC_CMD_VALID);
break;
case MAC_TABLE_WRITE:
clrsetbits_le32(&l2ana_reg->ana_tables.mac_access,
VSC9953_MAC_CMD_MASK |
VSC9953_MAC_ENTRYTYPE_MASK,
VSC9953_MAC_CMD_WRITE |
VSC9953_MAC_ENTRYTYPE_LOCKED);
break;
case MAC_TABLE_LEARN:
clrsetbits_le32(&l2ana_reg->ana_tables.mac_access,
VSC9953_MAC_CMD_MASK |
VSC9953_MAC_ENTRYTYPE_MASK,
VSC9953_MAC_CMD_LEARN |
VSC9953_MAC_ENTRYTYPE_LOCKED |
VSC9953_MAC_CMD_VALID);
break;
case MAC_TABLE_FORGET:
clrsetbits_le32(&l2ana_reg->ana_tables.mac_access,
VSC9953_MAC_CMD_MASK |
VSC9953_MAC_ENTRYTYPE_MASK,
VSC9953_MAC_CMD_FORGET);
break;
case MAC_TABLE_GET_NEXT:
clrsetbits_le32(&l2ana_reg->ana_tables.mac_access,
VSC9953_MAC_CMD_MASK |
VSC9953_MAC_ENTRYTYPE_MASK,
VSC9953_MAC_CMD_NEXT);
break;
case MAC_TABLE_AGE:
clrsetbits_le32(&l2ana_reg->ana_tables.mac_access,
VSC9953_MAC_CMD_MASK |
VSC9953_MAC_ENTRYTYPE_MASK,
VSC9953_MAC_CMD_AGE);
break;
default:
printf("Unknown MAC table command\n");
}
if (vsc9953_mac_table_poll_idle() < 0) {
debug("MAC table timeout\n");
return -1;
}
return 0;
}
/* show the FDB entries that correspond to a port and a VLAN */
static void vsc9953_mac_table_show(int port_no, int vid)
{
int rc[VSC9953_MAX_PORTS];
enum port_learn_mode mode[VSC9953_MAX_PORTS];
int i;
u32 val;
u32 vlan;
u32 mach;
u32 macl;
u32 dest_indx;
struct vsc9953_analyzer *l2ana_reg;
l2ana_reg = (struct vsc9953_analyzer *)(VSC9953_OFFSET +
VSC9953_ANA_OFFSET);
/* disable auto learning */
if (port_no == ETHSW_CMD_PORT_ALL) {
for (i = 0; i < VSC9953_MAX_PORTS; i++) {
rc[i] = vsc9953_port_learn_mode_get(i, &mode[i]);
if (!rc[i] && mode[i] != PORT_LEARN_NONE)
vsc9953_port_learn_mode_set(i, PORT_LEARN_NONE);
}
} else {
rc[port_no] = vsc9953_port_learn_mode_get(port_no,
&mode[port_no]);
if (!rc[port_no] && mode[port_no] != PORT_LEARN_NONE)
vsc9953_port_learn_mode_set(port_no, PORT_LEARN_NONE);
}
/* write port and vid to get selected FDB entries */
val = in_le32(&l2ana_reg->ana.anag_efil);
if (port_no != ETHSW_CMD_PORT_ALL) {
val = bitfield_replace_by_mask(val, VSC9953_AGE_PORT_MASK,
port_no) | VSC9953_AGE_PORT_EN;
}
if (vid != ETHSW_CMD_VLAN_ALL) {
val = bitfield_replace_by_mask(val, VSC9953_AGE_VID_MASK,
vid) | VSC9953_AGE_VID_EN;
}
out_le32(&l2ana_reg->ana.anag_efil, val);
/* set MAC and VLAN to 0 to look from beginning */
clrbits_le32(&l2ana_reg->ana_tables.mach_data,
VSC9953_MAC_VID_MASK | VSC9953_MAC_MACH_MASK);
out_le32(&l2ana_reg->ana_tables.macl_data, 0);
/* get entries */
printf("%10s %17s %5s %4s\n", "EntryType", "MAC", "PORT", "VID");
do {
if (vsc9953_mac_table_cmd(MAC_TABLE_GET_NEXT) < 0) {
debug("GET NEXT MAC table command failed\n");
break;
}
val = in_le32(&l2ana_reg->ana_tables.mac_access);
/* get out when an invalid entry is found */
if (!(val & VSC9953_MAC_CMD_VALID))
break;
switch (val & VSC9953_MAC_ENTRYTYPE_MASK) {
case VSC9953_MAC_ENTRYTYPE_NORMAL:
printf("%10s ", "Dynamic");
break;
case VSC9953_MAC_ENTRYTYPE_LOCKED:
printf("%10s ", "Static");
break;
case VSC9953_MAC_ENTRYTYPE_IPV4MCAST:
printf("%10s ", "IPv4 Mcast");
break;
case VSC9953_MAC_ENTRYTYPE_IPV6MCAST:
printf("%10s ", "IPv6 Mcast");
break;
default:
printf("%10s ", "Unknown");
}
dest_indx = bitfield_extract_by_mask(val,
VSC9953_MAC_DESTIDX_MASK);
val = in_le32(&l2ana_reg->ana_tables.mach_data);
vlan = bitfield_extract_by_mask(val, VSC9953_MAC_VID_MASK);
mach = bitfield_extract_by_mask(val, VSC9953_MAC_MACH_MASK);
macl = in_le32(&l2ana_reg->ana_tables.macl_data);
printf("%02x:%02x:%02x:%02x:%02x:%02x ", (mach >> 8) & 0xff,
mach & 0xff, (macl >> 24) & 0xff, (macl >> 16) & 0xff,
(macl >> 8) & 0xff, macl & 0xff);
printf("%5d ", dest_indx);
printf("%4d\n", vlan);
} while (1);
/* set learning mode to previous value */
if (port_no == ETHSW_CMD_PORT_ALL) {
for (i = 0; i < VSC9953_MAX_PORTS; i++) {
if (!rc[i] && mode[i] != PORT_LEARN_NONE)
vsc9953_port_learn_mode_set(i, mode[i]);
}
} else {
/* If administrative down, skip */
if (!rc[port_no] && mode[port_no] != PORT_LEARN_NONE)
vsc9953_port_learn_mode_set(port_no, mode[port_no]);
}
/* reset FDB port and VLAN FDB selection */
clrbits_le32(&l2ana_reg->ana.anag_efil, VSC9953_AGE_PORT_EN |
VSC9953_AGE_PORT_MASK | VSC9953_AGE_VID_EN |
VSC9953_AGE_VID_MASK);
}
/* Add a static FDB entry */
static int vsc9953_mac_table_add(u8 port_no, uchar mac[6], int vid)
{
u32 val;
struct vsc9953_analyzer *l2ana_reg;
l2ana_reg = (struct vsc9953_analyzer *)(VSC9953_OFFSET +
VSC9953_ANA_OFFSET);
val = in_le32(&l2ana_reg->ana_tables.mach_data);
val = bitfield_replace_by_mask(val, VSC9953_MACHDATA_VID_MASK, vid) |
(mac[0] << 8) | (mac[1] << 0);
out_le32(&l2ana_reg->ana_tables.mach_data, val);
out_le32(&l2ana_reg->ana_tables.macl_data,
(mac[2] << 24) | (mac[3] << 16) | (mac[4] << 8) |
(mac[5] << 0));
/* set on which port is the MAC address added */
val = in_le32(&l2ana_reg->ana_tables.mac_access);
val = bitfield_replace_by_mask(val, VSC9953_MAC_DESTIDX_MASK, port_no);
out_le32(&l2ana_reg->ana_tables.mac_access, val);
if (vsc9953_mac_table_cmd(MAC_TABLE_LEARN) < 0)
return -1;
/* check if the MAC address was indeed added */
val = in_le32(&l2ana_reg->ana_tables.mach_data);
val = bitfield_replace_by_mask(val, VSC9953_MACHDATA_VID_MASK, vid) |
(mac[0] << 8) | (mac[1] << 0);
out_le32(&l2ana_reg->ana_tables.mach_data, val);
out_le32(&l2ana_reg->ana_tables.macl_data,
(mac[2] << 24) | (mac[3] << 16) | (mac[4] << 8) |
(mac[5] << 0));
if (vsc9953_mac_table_cmd(MAC_TABLE_READ) < 0)
return -1;
val = in_le32(&l2ana_reg->ana_tables.mac_access);
if ((port_no != bitfield_extract_by_mask(val,
VSC9953_MAC_DESTIDX_MASK))) {
printf("Failed to add MAC address\n");
return -1;
}
return 0;
}
/* Delete a FDB entry */
static int vsc9953_mac_table_del(uchar mac[6], u16 vid)
{
u32 val;
struct vsc9953_analyzer *l2ana_reg;
l2ana_reg = (struct vsc9953_analyzer *)(VSC9953_OFFSET +
VSC9953_ANA_OFFSET);
/* check first if MAC entry is present */
val = in_le32(&l2ana_reg->ana_tables.mach_data);
val = bitfield_replace_by_mask(val, VSC9953_MACHDATA_VID_MASK, vid) |
(mac[0] << 8) | (mac[1] << 0);
out_le32(&l2ana_reg->ana_tables.mach_data, val);
out_le32(&l2ana_reg->ana_tables.macl_data,
(mac[2] << 24) | (mac[3] << 16) | (mac[4] << 8) |
(mac[5] << 0));
if (vsc9953_mac_table_cmd(MAC_TABLE_LOOKUP) < 0) {
debug("Lookup in the MAC table failed\n");
return -1;
}
if (!(in_le32(&l2ana_reg->ana_tables.mac_access) &
VSC9953_MAC_CMD_VALID)) {
printf("The MAC address: %02x:%02x:%02x:%02x:%02x:%02x ",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
printf("VLAN: %d does not exist.\n", vid);
return -1;
}
/* FDB entry found, proceed to delete */
val = in_le32(&l2ana_reg->ana_tables.mach_data);
val = bitfield_replace_by_mask(val, VSC9953_MACHDATA_VID_MASK, vid) |
(mac[0] << 8) | (mac[1] << 0);
out_le32(&l2ana_reg->ana_tables.mach_data, val);
out_le32(&l2ana_reg->ana_tables.macl_data, (mac[2] << 24) |
(mac[3] << 16) | (mac[4] << 8) | (mac[5] << 0));
if (vsc9953_mac_table_cmd(MAC_TABLE_FORGET) < 0)
return -1;
/* check if the MAC entry is still in FDB */
val = in_le32(&l2ana_reg->ana_tables.mach_data);
val = bitfield_replace_by_mask(val, VSC9953_MACHDATA_VID_MASK, vid) |
(mac[0] << 8) | (mac[1] << 0);
out_le32(&l2ana_reg->ana_tables.mach_data, val);
out_le32(&l2ana_reg->ana_tables.macl_data, (mac[2] << 24) |
(mac[3] << 16) | (mac[4] << 8) | (mac[5] << 0));
if (vsc9953_mac_table_cmd(MAC_TABLE_LOOKUP) < 0) {
debug("Lookup in the MAC table failed\n");
return -1;
}
if (in_le32(&l2ana_reg->ana_tables.mac_access) &
VSC9953_MAC_CMD_VALID) {
printf("Failed to delete MAC address\n");
return -1;
}
return 0;
}
/* age the unlocked entries in FDB */
static void vsc9953_mac_table_age(int port_no, int vid)
{
int rc[VSC9953_MAX_PORTS];
enum port_learn_mode mode[VSC9953_MAX_PORTS];
u32 val;
int i;
struct vsc9953_analyzer *l2ana_reg;
l2ana_reg = (struct vsc9953_analyzer *)(VSC9953_OFFSET +
VSC9953_ANA_OFFSET);
/* set port and VID for selective aging */
val = in_le32(&l2ana_reg->ana.anag_efil);
if (port_no != ETHSW_CMD_PORT_ALL) {
/* disable auto learning */
rc[port_no] = vsc9953_port_learn_mode_get(port_no,
&mode[port_no]);
if (!rc[port_no] && mode[port_no] != PORT_LEARN_NONE)
vsc9953_port_learn_mode_set(port_no, PORT_LEARN_NONE);
val = bitfield_replace_by_mask(val, VSC9953_AGE_PORT_MASK,
port_no) | VSC9953_AGE_PORT_EN;
} else {
/* disable auto learning on all ports */
for (i = 0; i < VSC9953_MAX_PORTS; i++) {
rc[i] = vsc9953_port_learn_mode_get(i, &mode[i]);
if (!rc[i] && mode[i] != PORT_LEARN_NONE)
vsc9953_port_learn_mode_set(i, PORT_LEARN_NONE);
}
}
if (vid != ETHSW_CMD_VLAN_ALL) {
val = bitfield_replace_by_mask(val, VSC9953_AGE_VID_MASK, vid) |
VSC9953_AGE_VID_EN;
}
out_le32(&l2ana_reg->ana.anag_efil, val);
/* age the dynamic FDB entries */
vsc9953_mac_table_cmd(MAC_TABLE_AGE);
/* clear previously set port and VID */
clrbits_le32(&l2ana_reg->ana.anag_efil, VSC9953_AGE_PORT_EN |
VSC9953_AGE_PORT_MASK | VSC9953_AGE_VID_EN |
VSC9953_AGE_VID_MASK);
if (port_no != ETHSW_CMD_PORT_ALL) {
if (!rc[port_no] && mode[port_no] != PORT_LEARN_NONE)
vsc9953_port_learn_mode_set(port_no, mode[port_no]);
} else {
for (i = 0; i < VSC9953_MAX_PORTS; i++) {
if (!rc[i] && mode[i] != PORT_LEARN_NONE)
vsc9953_port_learn_mode_set(i, mode[i]);
}
}
}
/* Delete all the dynamic FDB entries */
static void vsc9953_mac_table_flush(int port, int vid)
{
vsc9953_mac_table_age(port, vid);
vsc9953_mac_table_age(port, vid);
}
static int vsc9953_port_status_key_func(struct ethsw_command_def *parsed_cmd)
{
int i;
@ -949,6 +1332,91 @@ static int vsc9953_learn_set_key_func(struct ethsw_command_def *parsed_cmd)
return CMD_RET_SUCCESS;
}
static int vsc9953_fdb_show_key_func(struct ethsw_command_def *parsed_cmd)
{
if (parsed_cmd->port != ETHSW_CMD_PORT_ALL &&
!VSC9953_PORT_CHECK(parsed_cmd->port)) {
printf("Invalid port number: %d\n", parsed_cmd->port);
return CMD_RET_FAILURE;
}
if (parsed_cmd->vid != ETHSW_CMD_VLAN_ALL &&
!VSC9953_VLAN_CHECK(parsed_cmd->vid)) {
printf("Invalid VID number: %d\n", parsed_cmd->vid);
return CMD_RET_FAILURE;
}
vsc9953_mac_table_show(parsed_cmd->port, parsed_cmd->vid);
return CMD_RET_SUCCESS;
}
static int vsc9953_fdb_flush_key_func(struct ethsw_command_def *parsed_cmd)
{
if (parsed_cmd->port != ETHSW_CMD_PORT_ALL &&
!VSC9953_PORT_CHECK(parsed_cmd->port)) {
printf("Invalid port number: %d\n", parsed_cmd->port);
return CMD_RET_FAILURE;
}
if (parsed_cmd->vid != ETHSW_CMD_VLAN_ALL &&
!VSC9953_VLAN_CHECK(parsed_cmd->vid)) {
printf("Invalid VID number: %d\n", parsed_cmd->vid);
return CMD_RET_FAILURE;
}
vsc9953_mac_table_flush(parsed_cmd->port, parsed_cmd->vid);
return CMD_RET_SUCCESS;
}
static int vsc9953_fdb_entry_add_key_func(struct ethsw_command_def *parsed_cmd)
{
int vid;
/* a port number must be present */
if (parsed_cmd->port == ETHSW_CMD_PORT_ALL) {
printf("Please specify a port\n");
return CMD_RET_FAILURE;
}
if (!VSC9953_PORT_CHECK(parsed_cmd->port)) {
printf("Invalid port number: %d\n", parsed_cmd->port);
return CMD_RET_FAILURE;
}
/* Use VLAN 1 if VID is not set */
vid = (parsed_cmd->vid == ETHSW_CMD_VLAN_ALL ? 1 : parsed_cmd->vid);
if (!VSC9953_VLAN_CHECK(vid)) {
printf("Invalid VID number: %d\n", vid);
return CMD_RET_FAILURE;
}
if (vsc9953_mac_table_add(parsed_cmd->port, parsed_cmd->ethaddr, vid))
return CMD_RET_FAILURE;
return CMD_RET_SUCCESS;
}
static int vsc9953_fdb_entry_del_key_func(struct ethsw_command_def *parsed_cmd)
{
int vid;
/* Use VLAN 1 if VID is not set */
vid = (parsed_cmd->vid == ETHSW_CMD_VLAN_ALL ? 1 : parsed_cmd->vid);
if (!VSC9953_VLAN_CHECK(vid)) {
printf("Invalid VID number: %d\n", vid);
return CMD_RET_FAILURE;
}
if (vsc9953_mac_table_del(parsed_cmd->ethaddr, vid))
return CMD_RET_FAILURE;
return CMD_RET_SUCCESS;
}
static struct ethsw_command_func vsc9953_cmd_func = {
.ethsw_name = "L2 Switch VSC9953",
.port_enable = &vsc9953_port_status_key_func,
@ -958,6 +1426,10 @@ static struct ethsw_command_func vsc9953_cmd_func = {
.port_stats_clear = &vsc9953_port_stats_clear_key_func,
.port_learn = &vsc9953_learn_set_key_func,
.port_learn_show = &vsc9953_learn_show_key_func,
.fdb_show = &vsc9953_fdb_show_key_func,
.fdb_flush = &vsc9953_fdb_flush_key_func,
.fdb_entry_add = &vsc9953_fdb_entry_add_key_func,
.fdb_entry_del = &vsc9953_fdb_entry_del_key_func,
};
#endif /* CONFIG_CMD_ETHSW */

15
include/ethsw.h
View File

@ -11,6 +11,7 @@
#define ETHSW_MAX_CMD_PARAMS 20
#define ETHSW_CMD_PORT_ALL -1
#define ETHSW_CMD_VLAN_ALL -1
/* IDs used to track keywords in a command */
enum ethsw_keyword_id {
@ -24,11 +25,19 @@ enum ethsw_keyword_id {
ethsw_id_clear,
ethsw_id_learning,
ethsw_id_auto,
ethsw_id_vlan,
ethsw_id_fdb,
ethsw_id_add,
ethsw_id_del,
ethsw_id_flush,
ethsw_id_count, /* keep last */
};
enum ethsw_keyword_opt_id {
ethsw_id_port_no = ethsw_id_count + 1,
ethsw_id_vlan_no,
ethsw_id_add_del_no,
ethsw_id_add_del_mac,
ethsw_id_count_all, /* keep last */
};
@ -36,6 +45,8 @@ struct ethsw_command_def {
int cmd_to_keywords[ETHSW_MAX_CMD_PARAMS];
int cmd_keywords_nr;
int port;
int vid;
uchar ethaddr[6];
int (*cmd_function)(struct ethsw_command_def *parsed_cmd);
};
@ -49,6 +60,10 @@ struct ethsw_command_func {
int (*port_stats_clear)(struct ethsw_command_def *parsed_cmd);
int (*port_learn)(struct ethsw_command_def *parsed_cmd);
int (*port_learn_show)(struct ethsw_command_def *parsed_cmd);
int (*fdb_show)(struct ethsw_command_def *parsed_cmd);
int (*fdb_flush)(struct ethsw_command_def *parsed_cmd);
int (*fdb_entry_add)(struct ethsw_command_def *parsed_cmd);
int (*fdb_entry_del)(struct ethsw_command_def *parsed_cmd);
};
int ethsw_define_functions(const struct ethsw_command_func *cmd_func);

28
include/vsc9953.h
View File

@ -86,6 +86,25 @@
#define VSC9953_VCAP_MV_CFG 0x0000ffff
#define VSC9953_VCAP_UPDATE_CTRL 0x01000004
/* Macros for register vsc9953_ana_ana_tables.mac_access register */
#define VSC9953_MAC_CMD_IDLE 0x00000000
#define VSC9953_MAC_CMD_LEARN 0x00000001
#define VSC9953_MAC_CMD_FORGET 0x00000002
#define VSC9953_MAC_CMD_AGE 0x00000003
#define VSC9953_MAC_CMD_NEXT 0x00000004
#define VSC9953_MAC_CMD_READ 0x00000006
#define VSC9953_MAC_CMD_WRITE 0x00000007
#define VSC9953_MAC_CMD_MASK 0x00000007
#define VSC9953_MAC_CMD_VALID 0x00000800
#define VSC9953_MAC_ENTRYTYPE_NORMAL 0x00000000
#define VSC9953_MAC_ENTRYTYPE_LOCKED 0x00000200
#define VSC9953_MAC_ENTRYTYPE_IPV4MCAST 0x00000400
#define VSC9953_MAC_ENTRYTYPE_IPV6MCAST 0x00000600
#define VSC9953_MAC_ENTRYTYPE_MASK 0x00000600
#define VSC9953_MAC_DESTIDX_MASK 0x000001f8
#define VSC9953_MAC_VID_MASK 0x1fff0000
#define VSC9953_MAC_MACH_MASK 0x0000ffff
/* Macros for vsc9953_ana_port.vlan_cfg register */
#define VSC9953_VLAN_CFG_AWARE_ENA 0x00100000
#define VSC9953_VLAN_CFG_POP_CNT_MASK 0x000c0000
@ -124,6 +143,15 @@
#define VSC9953_TAG_CFG_ALL_BUT_ZERO 0x00000100
#define VSC9953_TAG_CFG_ALL 0x00000180
/* Macros for vsc9953_ana_ana.anag_efil register */
#define VSC9953_AGE_PORT_EN 0x00080000
#define VSC9953_AGE_PORT_MASK 0x0007c000
#define VSC9953_AGE_VID_EN 0x00002000
#define VSC9953_AGE_VID_MASK 0x00001fff
/* Macros for vsc9953_ana_ana_tables.mach_data register */
#define VSC9953_MACHDATA_VID_MASK 0x1fff0000
#define VSC9953_MAX_PORTS 10
#define VSC9953_PORT_CHECK(port) \
(((port) < 0 || (port) >= VSC9953_MAX_PORTS) ? 0 : 1)