2 * Copyright 2015 Freescale Semiconductor, Inc.
4 * SPDX-License-Identifier: GPL-2.0+
6 * Ethernet Switch commands
12 #include <env_flags.h>
15 static const char *ethsw_name
;
17 #define ETHSW_PORT_STATS_HELP "ethsw [port <port_no>] statistics " \
18 "{ [help] | [clear] } - show an l2 switch port's statistics"
20 static int ethsw_port_stats_help_key_func(struct ethsw_command_def
*parsed_cmd
)
22 printf(ETHSW_PORT_STATS_HELP
"\n");
24 return CMD_RET_SUCCESS
;
27 #define ETHSW_LEARN_HELP "ethsw [port <port_no>] learning " \
28 "{ [help] | show | auto | disable } " \
29 "- enable/disable/show learning configuration on a port"
31 static int ethsw_learn_help_key_func(struct ethsw_command_def
*parsed_cmd
)
33 printf(ETHSW_LEARN_HELP
"\n");
35 return CMD_RET_SUCCESS
;
38 #define ETHSW_FDB_HELP "ethsw [port <port_no>] [vlan <vid>] fdb " \
39 "{ [help] | show | flush | { add | del } <mac> } " \
40 "- Add/delete a mac entry in FDB; use show to see FDB entries; " \
41 "if vlan <vid> is missing, VID 1 will be used"
43 static int ethsw_fdb_help_key_func(struct ethsw_command_def
*parsed_cmd
)
45 printf(ETHSW_FDB_HELP
"\n");
47 return CMD_RET_SUCCESS
;
50 #define ETHSW_PVID_HELP "ethsw [port <port_no>] " \
51 "pvid { [help] | show | <pvid> } " \
52 "- set/show PVID (ingress and egress VLAN tagging) for a port"
54 static int ethsw_pvid_help_key_func(struct ethsw_command_def
*parsed_cmd
)
56 printf(ETHSW_PVID_HELP
"\n");
58 return CMD_RET_SUCCESS
;
61 #define ETHSW_VLAN_HELP "ethsw [port <port_no>] vlan " \
62 "{ [help] | show | add <vid> | del <vid> } " \
63 "- add a VLAN to a port (VLAN members)"
65 static int ethsw_vlan_help_key_func(struct ethsw_command_def
*parsed_cmd
)
67 printf(ETHSW_VLAN_HELP
"\n");
69 return CMD_RET_SUCCESS
;
72 #define ETHSW_PORT_UNTAG_HELP "ethsw [port <port_no>] untagged " \
73 "{ [help] | show | all | none | pvid } " \
74 " - set egress tagging mode for a port"
76 static int ethsw_port_untag_help_key_func(struct ethsw_command_def
*parsed_cmd
)
78 printf(ETHSW_PORT_UNTAG_HELP
"\n");
80 return CMD_RET_SUCCESS
;
83 #define ETHSW_EGR_VLAN_TAG_HELP "ethsw [port <port_no>] egress tag " \
84 "{ [help] | show | pvid | classified } " \
85 "- Configure VID source for egress tag. " \
86 "Tag's VID could be the frame's classified VID or the PVID of the port"
88 static int ethsw_egr_tag_help_key_func(struct ethsw_command_def
*parsed_cmd
)
90 printf(ETHSW_EGR_VLAN_TAG_HELP
"\n");
92 return CMD_RET_SUCCESS
;
95 #define ETHSW_VLAN_FDB_HELP "ethsw vlan fdb " \
96 "{ [help] | show | shared | private } " \
97 "- make VLAN learning shared or private"
99 static int ethsw_vlan_learn_help_key_func(struct ethsw_command_def
*parsed_cmd
)
101 printf(ETHSW_VLAN_FDB_HELP
"\n");
103 return CMD_RET_SUCCESS
;
106 #define ETHSW_PORT_INGR_FLTR_HELP "ethsw [port <port_no>] ingress filtering" \
107 " { [help] | show | enable | disable } " \
108 "- enable/disable VLAN ingress filtering on port"
110 static int ethsw_ingr_fltr_help_key_func(struct ethsw_command_def
*parsed_cmd
)
112 printf(ETHSW_PORT_INGR_FLTR_HELP
"\n");
114 return CMD_RET_SUCCESS
;
117 #define ETHSW_PORT_AGGR_HELP "ethsw [port <port_no>] aggr" \
118 " { [help] | show | <lag_group_no> } " \
119 "- get/set LAG group for a port"
121 static int ethsw_port_aggr_help_key_func(struct ethsw_command_def
*parsed_cmd
)
123 printf(ETHSW_PORT_AGGR_HELP
"\n");
125 return CMD_RET_SUCCESS
;
128 static struct keywords_to_function
{
129 enum ethsw_keyword_id cmd_keyword
[ETHSW_MAX_CMD_PARAMS
];
131 int (*keyword_function
)(struct ethsw_command_def
*parsed_cmd
);
132 } ethsw_cmd_def
[] = {
138 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
140 .keyword_function
= NULL
,
146 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
148 .keyword_function
= NULL
,
154 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
156 .keyword_function
= NULL
,
163 .cmd_func_offset
= -1,
164 .keyword_function
= ðsw_port_stats_help_key_func
,
170 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
172 .keyword_function
= NULL
,
179 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
181 .keyword_function
= NULL
,
187 .cmd_func_offset
= -1,
188 .keyword_function
= ðsw_learn_help_key_func
,
195 .cmd_func_offset
= -1,
196 .keyword_function
= ðsw_learn_help_key_func
,
203 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
205 .keyword_function
= NULL
,
212 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
214 .keyword_function
= NULL
,
221 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
223 .keyword_function
= NULL
,
229 .cmd_func_offset
= -1,
230 .keyword_function
= ðsw_fdb_help_key_func
,
237 .cmd_func_offset
= -1,
238 .keyword_function
= ðsw_fdb_help_key_func
,
245 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
247 .keyword_function
= NULL
,
254 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
256 .keyword_function
= NULL
,
261 ethsw_id_add_del_mac
,
264 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
266 .keyword_function
= NULL
,
271 ethsw_id_add_del_mac
,
274 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
276 .keyword_function
= NULL
,
282 .cmd_func_offset
= -1,
283 .keyword_function
= ðsw_pvid_help_key_func
,
290 .cmd_func_offset
= -1,
291 .keyword_function
= ðsw_pvid_help_key_func
,
298 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
300 .keyword_function
= NULL
,
307 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
309 .keyword_function
= NULL
,
315 .cmd_func_offset
= -1,
316 .keyword_function
= ðsw_vlan_help_key_func
,
323 .cmd_func_offset
= -1,
324 .keyword_function
= ðsw_vlan_help_key_func
,
331 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
333 .keyword_function
= NULL
,
341 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
343 .keyword_function
= NULL
,
351 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
353 .keyword_function
= NULL
,
359 .cmd_func_offset
= -1,
360 .keyword_function
= ðsw_port_untag_help_key_func
,
367 .cmd_func_offset
= -1,
368 .keyword_function
= ðsw_port_untag_help_key_func
,
375 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
377 .keyword_function
= NULL
,
384 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
386 .keyword_function
= NULL
,
393 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
395 .keyword_function
= NULL
,
402 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
404 .keyword_function
= NULL
,
411 .cmd_func_offset
= -1,
412 .keyword_function
= ðsw_egr_tag_help_key_func
,
420 .cmd_func_offset
= -1,
421 .keyword_function
= ðsw_egr_tag_help_key_func
,
429 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
431 .keyword_function
= NULL
,
439 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
441 .keyword_function
= NULL
,
449 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
451 .keyword_function
= NULL
,
458 .cmd_func_offset
= -1,
459 .keyword_function
= ðsw_vlan_learn_help_key_func
,
467 .cmd_func_offset
= -1,
468 .keyword_function
= ðsw_vlan_learn_help_key_func
,
476 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
478 .keyword_function
= NULL
,
486 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
488 .keyword_function
= NULL
,
496 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
498 .keyword_function
= NULL
,
505 .cmd_func_offset
= -1,
506 .keyword_function
= ðsw_ingr_fltr_help_key_func
,
514 .cmd_func_offset
= -1,
515 .keyword_function
= ðsw_ingr_fltr_help_key_func
,
523 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
524 port_ingr_filt_show
),
525 .keyword_function
= NULL
,
533 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
535 .keyword_function
= NULL
,
543 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
545 .keyword_function
= NULL
,
551 .cmd_func_offset
= -1,
552 .keyword_function
= ðsw_port_aggr_help_key_func
,
559 .cmd_func_offset
= -1,
560 .keyword_function
= ðsw_port_aggr_help_key_func
,
567 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
569 .keyword_function
= NULL
,
576 .cmd_func_offset
= offsetof(struct ethsw_command_func
,
578 .keyword_function
= NULL
,
582 struct keywords_optional
{
583 int cmd_keyword
[ETHSW_MAX_CMD_PARAMS
];
608 static int keyword_match_gen(enum ethsw_keyword_id key_id
, int argc
, char
609 *const argv
[], int *argc_nr
,
610 struct ethsw_command_def
*parsed_cmd
);
611 static int keyword_match_port(enum ethsw_keyword_id key_id
, int argc
,
612 char *const argv
[], int *argc_nr
,
613 struct ethsw_command_def
*parsed_cmd
);
614 static int keyword_match_vlan(enum ethsw_keyword_id key_id
, int argc
,
615 char *const argv
[], int *argc_nr
,
616 struct ethsw_command_def
*parsed_cmd
);
617 static int keyword_match_pvid(enum ethsw_keyword_id key_id
, int argc
,
618 char *const argv
[], int *argc_nr
,
619 struct ethsw_command_def
*parsed_cmd
);
620 static int keyword_match_mac_addr(enum ethsw_keyword_id key_id
, int argc
,
621 char *const argv
[], int *argc_nr
,
622 struct ethsw_command_def
*parsed_cmd
);
623 static int keyword_match_aggr(enum ethsw_keyword_id key_id
, int argc
,
624 char *const argv
[], int *argc_nr
,
625 struct ethsw_command_def
*parsed_cmd
);
628 * Define properties for each keyword;
629 * keep the order synced with enum ethsw_keyword_id
632 const char *keyword_name
;
633 int (*match
)(enum ethsw_keyword_id key_id
, int argc
, char *const argv
[],
634 int *argc_nr
, struct ethsw_command_def
*parsed_cmd
);
637 .keyword_name
= "help",
638 .match
= &keyword_match_gen
,
640 .keyword_name
= "show",
641 .match
= &keyword_match_gen
,
643 .keyword_name
= "port",
644 .match
= &keyword_match_port
646 .keyword_name
= "enable",
647 .match
= &keyword_match_gen
,
649 .keyword_name
= "disable",
650 .match
= &keyword_match_gen
,
652 .keyword_name
= "statistics",
653 .match
= &keyword_match_gen
,
655 .keyword_name
= "clear",
656 .match
= &keyword_match_gen
,
658 .keyword_name
= "learning",
659 .match
= &keyword_match_gen
,
661 .keyword_name
= "auto",
662 .match
= &keyword_match_gen
,
664 .keyword_name
= "vlan",
665 .match
= &keyword_match_vlan
,
667 .keyword_name
= "fdb",
668 .match
= &keyword_match_gen
,
670 .keyword_name
= "add",
671 .match
= &keyword_match_mac_addr
,
673 .keyword_name
= "del",
674 .match
= &keyword_match_mac_addr
,
676 .keyword_name
= "flush",
677 .match
= &keyword_match_gen
,
679 .keyword_name
= "pvid",
680 .match
= &keyword_match_pvid
,
682 .keyword_name
= "untagged",
683 .match
= &keyword_match_gen
,
685 .keyword_name
= "all",
686 .match
= &keyword_match_gen
,
688 .keyword_name
= "none",
689 .match
= &keyword_match_gen
,
691 .keyword_name
= "egress",
692 .match
= &keyword_match_gen
,
694 .keyword_name
= "tag",
695 .match
= &keyword_match_gen
,
697 .keyword_name
= "classified",
698 .match
= &keyword_match_gen
,
700 .keyword_name
= "shared",
701 .match
= &keyword_match_gen
,
703 .keyword_name
= "private",
704 .match
= &keyword_match_gen
,
706 .keyword_name
= "ingress",
707 .match
= &keyword_match_gen
,
709 .keyword_name
= "filtering",
710 .match
= &keyword_match_gen
,
712 .keyword_name
= "aggr",
713 .match
= &keyword_match_aggr
,
718 * Function used by an Ethernet Switch driver to set the functions
719 * that must be called by the parser when an ethsw command is given
721 int ethsw_define_functions(const struct ethsw_command_func
*cmd_func
)
725 int (*cmd_func_aux
)(struct ethsw_command_def
*);
727 if (!cmd_func
->ethsw_name
)
730 ethsw_name
= cmd_func
->ethsw_name
;
732 for (i
= 0; i
< ARRAY_SIZE(ethsw_cmd_def
); i
++) {
734 * get the pointer to the function send by the Ethernet Switch
735 * driver that corresponds to the proper ethsw command
737 if (ethsw_cmd_def
[i
].keyword_function
)
740 aux_p
= (void *)cmd_func
+ ethsw_cmd_def
[i
].cmd_func_offset
;
742 cmd_func_aux
= (int (*)(struct ethsw_command_def
*)) *aux_p
;
743 ethsw_cmd_def
[i
].keyword_function
= cmd_func_aux
;
749 /* Generic function used to match a keyword only by a string */
750 static int keyword_match_gen(enum ethsw_keyword_id key_id
, int argc
,
751 char *const argv
[], int *argc_nr
,
752 struct ethsw_command_def
*parsed_cmd
)
754 if (strcmp(argv
[*argc_nr
], keyword
[key_id
].keyword_name
) == 0) {
755 parsed_cmd
->cmd_to_keywords
[*argc_nr
] = key_id
;
762 /* Function used to match the command's port */
763 static int keyword_match_port(enum ethsw_keyword_id key_id
, int argc
,
764 char *const argv
[], int *argc_nr
,
765 struct ethsw_command_def
*parsed_cmd
)
769 if (!keyword_match_gen(key_id
, argc
, argv
, argc_nr
, parsed_cmd
))
772 if (*argc_nr
+ 1 >= argc
)
775 if (strict_strtoul(argv
[*argc_nr
+ 1], 10, &val
) != -EINVAL
) {
776 parsed_cmd
->port
= val
;
778 parsed_cmd
->cmd_to_keywords
[*argc_nr
] = ethsw_id_port_no
;
785 /* Function used to match the command's vlan */
786 static int keyword_match_vlan(enum ethsw_keyword_id key_id
, int argc
,
787 char *const argv
[], int *argc_nr
,
788 struct ethsw_command_def
*parsed_cmd
)
793 if (!keyword_match_gen(key_id
, argc
, argv
, argc_nr
, parsed_cmd
))
796 if (*argc_nr
+ 1 >= argc
)
799 if (strict_strtoul(argv
[*argc_nr
+ 1], 10, &val
) != -EINVAL
) {
800 parsed_cmd
->vid
= val
;
802 parsed_cmd
->cmd_to_keywords
[*argc_nr
] = ethsw_id_vlan_no
;
808 if (keyword_match_gen(ethsw_id_add
, argc
, argv
, &aux
, parsed_cmd
))
809 parsed_cmd
->cmd_to_keywords
[*argc_nr
+ 1] = ethsw_id_add
;
810 else if (keyword_match_gen(ethsw_id_del
, argc
, argv
, &aux
, parsed_cmd
))
811 parsed_cmd
->cmd_to_keywords
[*argc_nr
+ 1] = ethsw_id_del
;
815 if (*argc_nr
+ 2 >= argc
)
818 if (strict_strtoul(argv
[*argc_nr
+ 2], 10, &val
) != -EINVAL
) {
819 parsed_cmd
->vid
= val
;
821 parsed_cmd
->cmd_to_keywords
[*argc_nr
] = ethsw_id_add_del_no
;
828 /* Function used to match the command's pvid */
829 static int keyword_match_pvid(enum ethsw_keyword_id key_id
, int argc
,
830 char *const argv
[], int *argc_nr
,
831 struct ethsw_command_def
*parsed_cmd
)
835 if (!keyword_match_gen(key_id
, argc
, argv
, argc_nr
, parsed_cmd
))
838 if (*argc_nr
+ 1 >= argc
)
841 if (strict_strtoul(argv
[*argc_nr
+ 1], 10, &val
) != -EINVAL
) {
842 parsed_cmd
->vid
= val
;
844 parsed_cmd
->cmd_to_keywords
[*argc_nr
] = ethsw_id_pvid_no
;
850 /* Function used to match the command's MAC address */
851 static int keyword_match_mac_addr(enum ethsw_keyword_id key_id
, int argc
,
852 char *const argv
[], int *argc_nr
,
853 struct ethsw_command_def
*parsed_cmd
)
855 if (!keyword_match_gen(key_id
, argc
, argv
, argc_nr
, parsed_cmd
))
858 if ((*argc_nr
+ 1 >= argc
) ||
859 !is_broadcast_ethaddr(parsed_cmd
->ethaddr
))
862 if (eth_validate_ethaddr_str(argv
[*argc_nr
+ 1])) {
863 printf("Invalid MAC address: %s\n", argv
[*argc_nr
+ 1]);
867 eth_parse_enetaddr(argv
[*argc_nr
+ 1], parsed_cmd
->ethaddr
);
869 if (is_broadcast_ethaddr(parsed_cmd
->ethaddr
)) {
870 memset(parsed_cmd
->ethaddr
, 0xFF, sizeof(parsed_cmd
->ethaddr
));
874 parsed_cmd
->cmd_to_keywords
[*argc_nr
+ 1] = ethsw_id_add_del_mac
;
879 /* Function used to match the command's aggregation number */
880 static int keyword_match_aggr(enum ethsw_keyword_id key_id
, int argc
,
881 char *const argv
[], int *argc_nr
,
882 struct ethsw_command_def
*parsed_cmd
)
886 if (!keyword_match_gen(key_id
, argc
, argv
, argc_nr
, parsed_cmd
))
889 if (*argc_nr
+ 1 >= argc
)
892 if (strict_strtoul(argv
[*argc_nr
+ 1], 10, &val
) != -EINVAL
) {
893 parsed_cmd
->aggr_grp
= val
;
895 parsed_cmd
->cmd_to_keywords
[*argc_nr
] = ethsw_id_aggr_no
;
901 /* Finds optional keywords and modifies *argc_va to skip them */
902 static void cmd_keywords_opt_check(const struct ethsw_command_def
*parsed_cmd
,
906 int keyw_opt_matched
;
908 int const *cmd_keyw_p
;
909 int const *cmd_keyw_opt_p
;
911 /* remember the best match */
912 argc_val_max
= *argc_val
;
915 * check if our command's optional keywords match the optional
916 * keywords of an available command
918 for (i
= 0; i
< ARRAY_SIZE(ethsw_cmd_def
); i
++) {
919 keyw_opt_matched
= 0;
920 cmd_keyw_p
= &parsed_cmd
->cmd_to_keywords
[keyw_opt_matched
];
921 cmd_keyw_opt_p
= &cmd_opt_def
[i
].cmd_keyword
[keyw_opt_matched
];
924 * increase the number of keywords that
925 * matched with a command
927 while (keyw_opt_matched
+ *argc_val
<
928 parsed_cmd
->cmd_keywords_nr
&&
929 *cmd_keyw_opt_p
!= ethsw_id_key_end
&&
930 *(cmd_keyw_p
+ *argc_val
) == *cmd_keyw_opt_p
) {
937 * if all our optional command's keywords perfectly match an
938 * optional pattern, then we can move to the next defined
939 * keywords in our command; remember the one that matched the
940 * greatest number of keywords
942 if (keyw_opt_matched
+ *argc_val
<=
943 parsed_cmd
->cmd_keywords_nr
&&
944 *cmd_keyw_opt_p
== ethsw_id_key_end
&&
945 *argc_val
+ keyw_opt_matched
> argc_val_max
)
946 argc_val_max
= *argc_val
+ keyw_opt_matched
;
949 *argc_val
= argc_val_max
;
953 * Finds the function to call based on keywords and
954 * modifies *argc_va to skip them
956 static void cmd_keywords_check(struct ethsw_command_def
*parsed_cmd
,
965 * check if our command's keywords match the
966 * keywords of an available command
968 for (i
= 0; i
< ARRAY_SIZE(ethsw_cmd_def
); i
++) {
970 cmd_keyw_p
= &parsed_cmd
->cmd_to_keywords
[keyw_matched
];
971 cmd_keyw_def_p
= ðsw_cmd_def
[i
].cmd_keyword
[keyw_matched
];
974 * increase the number of keywords that
975 * matched with a command
977 while (keyw_matched
+ *argc_val
< parsed_cmd
->cmd_keywords_nr
&&
978 *cmd_keyw_def_p
!= ethsw_id_key_end
&&
979 *(cmd_keyw_p
+ *argc_val
) == *cmd_keyw_def_p
) {
986 * if all our command's keywords perfectly match an
987 * available command, then we get the function we need to call
988 * to configure the Ethernet Switch
990 if (keyw_matched
&& keyw_matched
+ *argc_val
==
991 parsed_cmd
->cmd_keywords_nr
&&
992 *cmd_keyw_def_p
== ethsw_id_key_end
) {
993 *argc_val
+= keyw_matched
;
994 parsed_cmd
->cmd_function
=
995 ethsw_cmd_def
[i
].keyword_function
;
1001 /* find all the keywords in the command */
1002 static int keywords_find(int argc
, char * const argv
[],
1003 struct ethsw_command_def
*parsed_cmd
)
1008 int rc
= CMD_RET_SUCCESS
;
1010 for (i
= 1; i
< argc
; i
++) {
1011 for (j
= 0; j
< ethsw_id_count
; j
++) {
1012 if (keyword
[j
].match(j
, argc
, argv
, &i
, parsed_cmd
))
1017 /* if there is no keyword match for a word, the command is invalid */
1018 for (i
= 1; i
< argc
; i
++)
1019 if (parsed_cmd
->cmd_to_keywords
[i
] == ethsw_id_key_end
)
1022 parsed_cmd
->cmd_keywords_nr
= argc
;
1025 /* get optional parameters first */
1026 cmd_keywords_opt_check(parsed_cmd
, &argc_val
);
1028 if (argc_val
== parsed_cmd
->cmd_keywords_nr
)
1029 return CMD_RET_USAGE
;
1032 * check the keywords and if a match is found,
1033 * get the function to call
1035 cmd_keywords_check(parsed_cmd
, &argc_val
);
1037 /* error if not all commands' parameters were matched */
1038 if (argc_val
== parsed_cmd
->cmd_keywords_nr
) {
1039 if (!parsed_cmd
->cmd_function
) {
1040 printf("Command not available for: %s\n", ethsw_name
);
1041 rc
= CMD_RET_FAILURE
;
1050 static void command_def_init(struct ethsw_command_def
*parsed_cmd
)
1054 for (i
= 0; i
< ETHSW_MAX_CMD_PARAMS
; i
++)
1055 parsed_cmd
->cmd_to_keywords
[i
] = ethsw_id_key_end
;
1057 parsed_cmd
->port
= ETHSW_CMD_PORT_ALL
;
1058 parsed_cmd
->vid
= ETHSW_CMD_VLAN_ALL
;
1059 parsed_cmd
->aggr_grp
= ETHSW_CMD_AGGR_GRP_NONE
;
1060 parsed_cmd
->cmd_function
= NULL
;
1062 /* We initialize the MAC address with the Broadcast address */
1063 memset(parsed_cmd
->ethaddr
, 0xff, sizeof(parsed_cmd
->ethaddr
));
1066 /* function to interpret commands starting with "ethsw " */
1067 static int do_ethsw(cmd_tbl_t
*cmdtp
, int flag
, int argc
, char * const argv
[])
1069 struct ethsw_command_def parsed_cmd
;
1070 int rc
= CMD_RET_SUCCESS
;
1072 if (argc
== 1 || argc
>= ETHSW_MAX_CMD_PARAMS
)
1073 return CMD_RET_USAGE
;
1075 command_def_init(&parsed_cmd
);
1077 rc
= keywords_find(argc
, argv
, &parsed_cmd
);
1079 if (rc
== CMD_RET_SUCCESS
)
1080 rc
= parsed_cmd
.cmd_function(&parsed_cmd
);
1085 #define ETHSW_PORT_CONF_HELP "[port <port_no>] { enable | disable | show } " \
1086 "- enable/disable a port; show a port's configuration"
1088 U_BOOT_CMD(ethsw
, ETHSW_MAX_CMD_PARAMS
, 0, do_ethsw
,
1089 "Ethernet l2 switch commands",
1090 ETHSW_PORT_CONF_HELP
"\n"
1091 ETHSW_PORT_STATS_HELP
"\n"
1092 ETHSW_LEARN_HELP
"\n"
1096 ETHSW_PORT_UNTAG_HELP
"\n"
1097 ETHSW_EGR_VLAN_TAG_HELP
"\n"
1098 ETHSW_VLAN_FDB_HELP
"\n"
1099 ETHSW_PORT_INGR_FLTR_HELP
"\n"
1100 ETHSW_PORT_AGGR_HELP
"\n"