]> git.ipfire.org Git - people/ms/u-boot.git/blob - cmd/cmd_ethsw.c
projects / people / ms / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
x86: ivybridge: Use syscon for the GMA device
[people/ms/u-boot.git] / cmd / cmd_ethsw.c
1 /*
2 * Copyright 2015 Freescale Semiconductor, Inc.
3 *
4 * SPDX-License-Identifier: GPL-2.0+
5 *
6 * Ethernet Switch commands
7 */
8
9 #include <common.h>
10 #include <command.h>
11 #include <errno.h>
12 #include <env_flags.h>
13 #include <ethsw.h>
14
15 static const char *ethsw_name;
16
17 #define ETHSW_PORT_STATS_HELP "ethsw [port <port_no>] statistics " \
18 "{ [help] | [clear] } - show an l2 switch port's statistics"
19
20 static int ethsw_port_stats_help_key_func(struct ethsw_command_def *parsed_cmd)
21 {
22 printf(ETHSW_PORT_STATS_HELP"\n");
23
24 return CMD_RET_SUCCESS;
25 }
26
27 #define ETHSW_LEARN_HELP "ethsw [port <port_no>] learning " \
28 "{ [help] | show | auto | disable } " \
29 "- enable/disable/show learning configuration on a port"
30
31 static int ethsw_learn_help_key_func(struct ethsw_command_def *parsed_cmd)
32 {
33 printf(ETHSW_LEARN_HELP"\n");
34
35 return CMD_RET_SUCCESS;
36 }
37
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"
42
43 static int ethsw_fdb_help_key_func(struct ethsw_command_def *parsed_cmd)
44 {
45 printf(ETHSW_FDB_HELP"\n");
46
47 return CMD_RET_SUCCESS;
48 }
49
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"
53
54 static int ethsw_pvid_help_key_func(struct ethsw_command_def *parsed_cmd)
55 {
56 printf(ETHSW_PVID_HELP"\n");
57
58 return CMD_RET_SUCCESS;
59 }
60
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)"
64
65 static int ethsw_vlan_help_key_func(struct ethsw_command_def *parsed_cmd)
66 {
67 printf(ETHSW_VLAN_HELP"\n");
68
69 return CMD_RET_SUCCESS;
70 }
71
72 #define ETHSW_PORT_UNTAG_HELP "ethsw [port <port_no>] untagged " \
73 "{ [help] | show | all | none | pvid } " \
74 " - set egress tagging mod for a port"
75
76 static int ethsw_port_untag_help_key_func(struct ethsw_command_def *parsed_cmd)
77 {
78 printf(ETHSW_PORT_UNTAG_HELP"\n");
79
80 return CMD_RET_SUCCESS;
81 }
82
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"
87
88 static int ethsw_egr_tag_help_key_func(struct ethsw_command_def *parsed_cmd)
89 {
90 printf(ETHSW_EGR_VLAN_TAG_HELP"\n");
91
92 return CMD_RET_SUCCESS;
93 }
94
95 #define ETHSW_VLAN_FDB_HELP "ethsw vlan fdb " \
96 "{ [help] | show | shared | private } " \
97 "- make VLAN learning shared or private"
98
99 static int ethsw_vlan_learn_help_key_func(struct ethsw_command_def *parsed_cmd)
100 {
101 printf(ETHSW_VLAN_FDB_HELP"\n");
102
103 return CMD_RET_SUCCESS;
104 }
105
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"
109
110 static int ethsw_ingr_fltr_help_key_func(struct ethsw_command_def *parsed_cmd)
111 {
112 printf(ETHSW_PORT_INGR_FLTR_HELP"\n");
113
114 return CMD_RET_SUCCESS;
115 }
116
117 static struct keywords_to_function {
118 enum ethsw_keyword_id cmd_keyword[ETHSW_MAX_CMD_PARAMS];
119 int cmd_func_offset;
120 int (*keyword_function)(struct ethsw_command_def *parsed_cmd);
121 } ethsw_cmd_def[] = {
122 {
123 .cmd_keyword = {
124 ethsw_id_enable,
125 ethsw_id_key_end,
126 },
127 .cmd_func_offset = offsetof(struct ethsw_command_func,
128 port_enable),
129 .keyword_function = NULL,
130 }, {
131 .cmd_keyword = {
132 ethsw_id_disable,
133 ethsw_id_key_end,
134 },
135 .cmd_func_offset = offsetof(struct ethsw_command_func,
136 port_disable),
137 .keyword_function = NULL,
138 }, {
139 .cmd_keyword = {
140 ethsw_id_show,
141 ethsw_id_key_end,
142 },
143 .cmd_func_offset = offsetof(struct ethsw_command_func,
144 port_show),
145 .keyword_function = NULL,
146 }, {
147 .cmd_keyword = {
148 ethsw_id_statistics,
149 ethsw_id_help,
150 ethsw_id_key_end,
151 },
152 .cmd_func_offset = -1,
153 .keyword_function = &ethsw_port_stats_help_key_func,
154 }, {
155 .cmd_keyword = {
156 ethsw_id_statistics,
157 ethsw_id_key_end,
158 },
159 .cmd_func_offset = offsetof(struct ethsw_command_func,
160 port_stats),
161 .keyword_function = NULL,
162 }, {
163 .cmd_keyword = {
164 ethsw_id_statistics,
165 ethsw_id_clear,
166 ethsw_id_key_end,
167 },
168 .cmd_func_offset = offsetof(struct ethsw_command_func,
169 port_stats_clear),
170 .keyword_function = NULL,
171 }, {
172 .cmd_keyword = {
173 ethsw_id_learning,
174 ethsw_id_key_end,
175 },
176 .cmd_func_offset = -1,
177 .keyword_function = &ethsw_learn_help_key_func,
178 }, {
179 .cmd_keyword = {
180 ethsw_id_learning,
181 ethsw_id_help,
182 ethsw_id_key_end,
183 },
184 .cmd_func_offset = -1,
185 .keyword_function = &ethsw_learn_help_key_func,
186 }, {
187 .cmd_keyword = {
188 ethsw_id_learning,
189 ethsw_id_show,
190 ethsw_id_key_end,
191 },
192 .cmd_func_offset = offsetof(struct ethsw_command_func,
193 port_learn_show),
194 .keyword_function = NULL,
195 }, {
196 .cmd_keyword = {
197 ethsw_id_learning,
198 ethsw_id_auto,
199 ethsw_id_key_end,
200 },
201 .cmd_func_offset = offsetof(struct ethsw_command_func,
202 port_learn),
203 .keyword_function = NULL,
204 }, {
205 .cmd_keyword = {
206 ethsw_id_learning,
207 ethsw_id_disable,
208 ethsw_id_key_end,
209 },
210 .cmd_func_offset = offsetof(struct ethsw_command_func,
211 port_learn),
212 .keyword_function = NULL,
213 }, {
214 .cmd_keyword = {
215 ethsw_id_fdb,
216 ethsw_id_key_end,
217 },
218 .cmd_func_offset = -1,
219 .keyword_function = &ethsw_fdb_help_key_func,
220 }, {
221 .cmd_keyword = {
222 ethsw_id_fdb,
223 ethsw_id_help,
224 ethsw_id_key_end,
225 },
226 .cmd_func_offset = -1,
227 .keyword_function = &ethsw_fdb_help_key_func,
228 }, {
229 .cmd_keyword = {
230 ethsw_id_fdb,
231 ethsw_id_show,
232 ethsw_id_key_end,
233 },
234 .cmd_func_offset = offsetof(struct ethsw_command_func,
235 fdb_show),
236 .keyword_function = NULL,
237 }, {
238 .cmd_keyword = {
239 ethsw_id_fdb,
240 ethsw_id_flush,
241 ethsw_id_key_end,
242 },
243 .cmd_func_offset = offsetof(struct ethsw_command_func,
244 fdb_flush),
245 .keyword_function = NULL,
246 }, {
247 .cmd_keyword = {
248 ethsw_id_fdb,
249 ethsw_id_add,
250 ethsw_id_add_del_mac,
251 ethsw_id_key_end,
252 },
253 .cmd_func_offset = offsetof(struct ethsw_command_func,
254 fdb_entry_add),
255 .keyword_function = NULL,
256 }, {
257 .cmd_keyword = {
258 ethsw_id_fdb,
259 ethsw_id_del,
260 ethsw_id_add_del_mac,
261 ethsw_id_key_end,
262 },
263 .cmd_func_offset = offsetof(struct ethsw_command_func,
264 fdb_entry_del),
265 .keyword_function = NULL,
266 }, {
267 .cmd_keyword = {
268 ethsw_id_pvid,
269 ethsw_id_key_end,
270 },
271 .cmd_func_offset = -1,
272 .keyword_function = &ethsw_pvid_help_key_func,
273 }, {
274 .cmd_keyword = {
275 ethsw_id_pvid,
276 ethsw_id_help,
277 ethsw_id_key_end,
278 },
279 .cmd_func_offset = -1,
280 .keyword_function = &ethsw_pvid_help_key_func,
281 }, {
282 .cmd_keyword = {
283 ethsw_id_pvid,
284 ethsw_id_show,
285 ethsw_id_key_end,
286 },
287 .cmd_func_offset = offsetof(struct ethsw_command_func,
288 pvid_show),
289 .keyword_function = NULL,
290 }, {
291 .cmd_keyword = {
292 ethsw_id_pvid,
293 ethsw_id_pvid_no,
294 ethsw_id_key_end,
295 },
296 .cmd_func_offset = offsetof(struct ethsw_command_func,
297 pvid_set),
298 .keyword_function = NULL,
299 }, {
300 .cmd_keyword = {
301 ethsw_id_vlan,
302 ethsw_id_key_end,
303 },
304 .cmd_func_offset = -1,
305 .keyword_function = &ethsw_vlan_help_key_func,
306 }, {
307 .cmd_keyword = {
308 ethsw_id_vlan,
309 ethsw_id_help,
310 ethsw_id_key_end,
311 },
312 .cmd_func_offset = -1,
313 .keyword_function = &ethsw_vlan_help_key_func,
314 }, {
315 .cmd_keyword = {
316 ethsw_id_vlan,
317 ethsw_id_show,
318 ethsw_id_key_end,
319 },
320 .cmd_func_offset = offsetof(struct ethsw_command_func,
321 vlan_show),
322 .keyword_function = NULL,
323 }, {
324 .cmd_keyword = {
325 ethsw_id_vlan,
326 ethsw_id_add,
327 ethsw_id_add_del_no,
328 ethsw_id_key_end,
329 },
330 .cmd_func_offset = offsetof(struct ethsw_command_func,
331 vlan_set),
332 .keyword_function = NULL,
333 }, {
334 .cmd_keyword = {
335 ethsw_id_vlan,
336 ethsw_id_del,
337 ethsw_id_add_del_no,
338 ethsw_id_key_end,
339 },
340 .cmd_func_offset = offsetof(struct ethsw_command_func,
341 vlan_set),
342 .keyword_function = NULL,
343 }, {
344 .cmd_keyword = {
345 ethsw_id_untagged,
346 ethsw_id_key_end,
347 },
348 .cmd_func_offset = -1,
349 .keyword_function = &ethsw_port_untag_help_key_func,
350 }, {
351 .cmd_keyword = {
352 ethsw_id_untagged,
353 ethsw_id_help,
354 ethsw_id_key_end,
355 },
356 .cmd_func_offset = -1,
357 .keyword_function = &ethsw_port_untag_help_key_func,
358 }, {
359 .cmd_keyword = {
360 ethsw_id_untagged,
361 ethsw_id_show,
362 ethsw_id_key_end,
363 },
364 .cmd_func_offset = offsetof(struct ethsw_command_func,
365 port_untag_show),
366 .keyword_function = NULL,
367 }, {
368 .cmd_keyword = {
369 ethsw_id_untagged,
370 ethsw_id_all,
371 ethsw_id_key_end,
372 },
373 .cmd_func_offset = offsetof(struct ethsw_command_func,
374 port_untag_set),
375 .keyword_function = NULL,
376 }, {
377 .cmd_keyword = {
378 ethsw_id_untagged,
379 ethsw_id_none,
380 ethsw_id_key_end,
381 },
382 .cmd_func_offset = offsetof(struct ethsw_command_func,
383 port_untag_set),
384 .keyword_function = NULL,
385 }, {
386 .cmd_keyword = {
387 ethsw_id_untagged,
388 ethsw_id_pvid,
389 ethsw_id_key_end,
390 },
391 .cmd_func_offset = offsetof(struct ethsw_command_func,
392 port_untag_set),
393 .keyword_function = NULL,
394 }, {
395 .cmd_keyword = {
396 ethsw_id_egress,
397 ethsw_id_tag,
398 ethsw_id_key_end,
399 },
400 .cmd_func_offset = -1,
401 .keyword_function = &ethsw_egr_tag_help_key_func,
402 }, {
403 .cmd_keyword = {
404 ethsw_id_egress,
405 ethsw_id_tag,
406 ethsw_id_help,
407 ethsw_id_key_end,
408 },
409 .cmd_func_offset = -1,
410 .keyword_function = &ethsw_egr_tag_help_key_func,
411 }, {
412 .cmd_keyword = {
413 ethsw_id_egress,
414 ethsw_id_tag,
415 ethsw_id_show,
416 ethsw_id_key_end,
417 },
418 .cmd_func_offset = offsetof(struct ethsw_command_func,
419 port_egr_vlan_show),
420 .keyword_function = NULL,
421 }, {
422 .cmd_keyword = {
423 ethsw_id_egress,
424 ethsw_id_tag,
425 ethsw_id_pvid,
426 ethsw_id_key_end,
427 },
428 .cmd_func_offset = offsetof(struct ethsw_command_func,
429 port_egr_vlan_set),
430 .keyword_function = NULL,
431 }, {
432 .cmd_keyword = {
433 ethsw_id_egress,
434 ethsw_id_tag,
435 ethsw_id_classified,
436 ethsw_id_key_end,
437 },
438 .cmd_func_offset = offsetof(struct ethsw_command_func,
439 port_egr_vlan_set),
440 .keyword_function = NULL,
441 }, {
442 .cmd_keyword = {
443 ethsw_id_vlan,
444 ethsw_id_fdb,
445 ethsw_id_key_end,
446 },
447 .cmd_func_offset = -1,
448 .keyword_function = &ethsw_vlan_learn_help_key_func,
449 }, {
450 .cmd_keyword = {
451 ethsw_id_vlan,
452 ethsw_id_fdb,
453 ethsw_id_help,
454 ethsw_id_key_end,
455 },
456 .cmd_func_offset = -1,
457 .keyword_function = &ethsw_vlan_learn_help_key_func,
458 }, {
459 .cmd_keyword = {
460 ethsw_id_vlan,
461 ethsw_id_fdb,
462 ethsw_id_show,
463 ethsw_id_key_end,
464 },
465 .cmd_func_offset = offsetof(struct ethsw_command_func,
466 vlan_learn_show),
467 .keyword_function = NULL,
468 }, {
469 .cmd_keyword = {
470 ethsw_id_vlan,
471 ethsw_id_fdb,
472 ethsw_id_shared,
473 ethsw_id_key_end,
474 },
475 .cmd_func_offset = offsetof(struct ethsw_command_func,
476 vlan_learn_set),
477 .keyword_function = NULL,
478 }, {
479 .cmd_keyword = {
480 ethsw_id_vlan,
481 ethsw_id_fdb,
482 ethsw_id_private,
483 ethsw_id_key_end,
484 },
485 .cmd_func_offset = offsetof(struct ethsw_command_func,
486 vlan_learn_set),
487 .keyword_function = NULL,
488 }, {
489 .cmd_keyword = {
490 ethsw_id_ingress,
491 ethsw_id_filtering,
492 ethsw_id_key_end,
493 },
494 .cmd_func_offset = -1,
495 .keyword_function = &ethsw_ingr_fltr_help_key_func,
496 }, {
497 .cmd_keyword = {
498 ethsw_id_ingress,
499 ethsw_id_filtering,
500 ethsw_id_help,
501 ethsw_id_key_end,
502 },
503 .cmd_func_offset = -1,
504 .keyword_function = &ethsw_ingr_fltr_help_key_func,
505 }, {
506 .cmd_keyword = {
507 ethsw_id_ingress,
508 ethsw_id_filtering,
509 ethsw_id_show,
510 ethsw_id_key_end,
511 },
512 .cmd_func_offset = offsetof(struct ethsw_command_func,
513 port_ingr_filt_show),
514 .keyword_function = NULL,
515 }, {
516 .cmd_keyword = {
517 ethsw_id_ingress,
518 ethsw_id_filtering,
519 ethsw_id_enable,
520 ethsw_id_key_end,
521 },
522 .cmd_func_offset = offsetof(struct ethsw_command_func,
523 port_ingr_filt_set),
524 .keyword_function = NULL,
525 }, {
526 .cmd_keyword = {
527 ethsw_id_ingress,
528 ethsw_id_filtering,
529 ethsw_id_disable,
530 ethsw_id_key_end,
531 },
532 .cmd_func_offset = offsetof(struct ethsw_command_func,
533 port_ingr_filt_set),
534 .keyword_function = NULL,
535 },
536 };
537
538 struct keywords_optional {
539 int cmd_keyword[ETHSW_MAX_CMD_PARAMS];
540 } cmd_opt_def[] = {
541 {
542 .cmd_keyword = {
543 ethsw_id_port,
544 ethsw_id_port_no,
545 ethsw_id_key_end,
546 },
547 }, {
548 .cmd_keyword = {
549 ethsw_id_vlan,
550 ethsw_id_vlan_no,
551 ethsw_id_key_end,
552 },
553 }, {
554 .cmd_keyword = {
555 ethsw_id_port,
556 ethsw_id_port_no,
557 ethsw_id_vlan,
558 ethsw_id_vlan_no,
559 ethsw_id_key_end,
560 },
561 },
562 };
563
564 static int keyword_match_gen(enum ethsw_keyword_id key_id, int argc, char
565 *const argv[], int *argc_nr,
566 struct ethsw_command_def *parsed_cmd);
567 static int keyword_match_port(enum ethsw_keyword_id key_id, int argc,
568 char *const argv[], int *argc_nr,
569 struct ethsw_command_def *parsed_cmd);
570 static int keyword_match_vlan(enum ethsw_keyword_id key_id, int argc,
571 char *const argv[], int *argc_nr,
572 struct ethsw_command_def *parsed_cmd);
573 static int keyword_match_pvid(enum ethsw_keyword_id key_id, int argc,
574 char *const argv[], int *argc_nr,
575 struct ethsw_command_def *parsed_cmd);
576 static int keyword_match_mac_addr(enum ethsw_keyword_id key_id, int argc,
577 char *const argv[], int *argc_nr,
578 struct ethsw_command_def *parsed_cmd);
579
580 /*
581 * Define properties for each keyword;
582 * keep the order synced with enum ethsw_keyword_id
583 */
584 struct keyword_def {
585 const char *keyword_name;
586 int (*match)(enum ethsw_keyword_id key_id, int argc, char *const argv[],
587 int *argc_nr, struct ethsw_command_def *parsed_cmd);
588 } keyword[] = {
589 {
590 .keyword_name = "help",
591 .match = &keyword_match_gen,
592 }, {
593 .keyword_name = "show",
594 .match = &keyword_match_gen,
595 }, {
596 .keyword_name = "port",
597 .match = &keyword_match_port
598 }, {
599 .keyword_name = "enable",
600 .match = &keyword_match_gen,
601 }, {
602 .keyword_name = "disable",
603 .match = &keyword_match_gen,
604 }, {
605 .keyword_name = "statistics",
606 .match = &keyword_match_gen,
607 }, {
608 .keyword_name = "clear",
609 .match = &keyword_match_gen,
610 }, {
611 .keyword_name = "learning",
612 .match = &keyword_match_gen,
613 }, {
614 .keyword_name = "auto",
615 .match = &keyword_match_gen,
616 }, {
617 .keyword_name = "vlan",
618 .match = &keyword_match_vlan,
619 }, {
620 .keyword_name = "fdb",
621 .match = &keyword_match_gen,
622 }, {
623 .keyword_name = "add",
624 .match = &keyword_match_mac_addr,
625 }, {
626 .keyword_name = "del",
627 .match = &keyword_match_mac_addr,
628 }, {
629 .keyword_name = "flush",
630 .match = &keyword_match_gen,
631 }, {
632 .keyword_name = "pvid",
633 .match = &keyword_match_pvid,
634 }, {
635 .keyword_name = "untagged",
636 .match = &keyword_match_gen,
637 }, {
638 .keyword_name = "all",
639 .match = &keyword_match_gen,
640 }, {
641 .keyword_name = "none",
642 .match = &keyword_match_gen,
643 }, {
644 .keyword_name = "egress",
645 .match = &keyword_match_gen,
646 }, {
647 .keyword_name = "tag",
648 .match = &keyword_match_gen,
649 }, {
650 .keyword_name = "classified",
651 .match = &keyword_match_gen,
652 }, {
653 .keyword_name = "shared",
654 .match = &keyword_match_gen,
655 }, {
656 .keyword_name = "private",
657 .match = &keyword_match_gen,
658 }, {
659 .keyword_name = "ingress",
660 .match = &keyword_match_gen,
661 }, {
662 .keyword_name = "filtering",
663 .match = &keyword_match_gen,
664 },
665 };
666
667 /*
668 * Function used by an Ethernet Switch driver to set the functions
669 * that must be called by the parser when an ethsw command is given
670 */
671 int ethsw_define_functions(const struct ethsw_command_func *cmd_func)
672 {
673 int i;
674 void **aux_p;
675 int (*cmd_func_aux)(struct ethsw_command_def *);
676
677 if (!cmd_func->ethsw_name)
678 return -EINVAL;
679
680 ethsw_name = cmd_func->ethsw_name;
681
682 for (i = 0; i < ARRAY_SIZE(ethsw_cmd_def); i++) {
683 /*
684 * get the pointer to the function send by the Ethernet Switch
685 * driver that corresponds to the proper ethsw command
686 */
687 if (ethsw_cmd_def[i].keyword_function)
688 continue;
689
690 aux_p = (void *)cmd_func + ethsw_cmd_def[i].cmd_func_offset;
691
692 cmd_func_aux = (int (*)(struct ethsw_command_def *)) *aux_p;
693 ethsw_cmd_def[i].keyword_function = cmd_func_aux;
694 }
695
696 return 0;
697 }
698
699 /* Generic function used to match a keyword only by a string */
700 static int keyword_match_gen(enum ethsw_keyword_id key_id, int argc,
701 char *const argv[], int *argc_nr,
702 struct ethsw_command_def *parsed_cmd)
703 {
704 if (strcmp(argv[*argc_nr], keyword[key_id].keyword_name) == 0) {
705 parsed_cmd->cmd_to_keywords[*argc_nr] = key_id;
706
707 return 1;
708 }
709 return 0;
710 }
711
712 /* Function used to match the command's port */
713 static int keyword_match_port(enum ethsw_keyword_id key_id, int argc,
714 char *const argv[], int *argc_nr,
715 struct ethsw_command_def *parsed_cmd)
716 {
717 unsigned long val;
718
719 if (!keyword_match_gen(key_id, argc, argv, argc_nr, parsed_cmd))
720 return 0;
721
722 if (*argc_nr + 1 >= argc)
723 return 0;
724
725 if (strict_strtoul(argv[*argc_nr + 1], 10, &val) != -EINVAL) {
726 parsed_cmd->port = val;
727 (*argc_nr)++;
728 parsed_cmd->cmd_to_keywords[*argc_nr] = ethsw_id_port_no;
729 return 1;
730 }
731
732 return 0;
733 }
734
735 /* Function used to match the command's vlan */
736 static int keyword_match_vlan(enum ethsw_keyword_id key_id, int argc,
737 char *const argv[], int *argc_nr,
738 struct ethsw_command_def *parsed_cmd)
739 {
740 unsigned long val;
741 int aux;
742
743 if (!keyword_match_gen(key_id, argc, argv, argc_nr, parsed_cmd))
744 return 0;
745
746 if (*argc_nr + 1 >= argc)
747 return 0;
748
749 if (strict_strtoul(argv[*argc_nr + 1], 10, &val) != -EINVAL) {
750 parsed_cmd->vid = val;
751 (*argc_nr)++;
752 parsed_cmd->cmd_to_keywords[*argc_nr] = ethsw_id_vlan_no;
753 return 1;
754 }
755
756 aux = *argc_nr + 1;
757
758 if (keyword_match_gen(ethsw_id_add, argc, argv, &aux, parsed_cmd))
759 parsed_cmd->cmd_to_keywords[*argc_nr + 1] = ethsw_id_add;
760 else if (keyword_match_gen(ethsw_id_del, argc, argv, &aux, parsed_cmd))
761 parsed_cmd->cmd_to_keywords[*argc_nr + 1] = ethsw_id_del;
762 else
763 return 0;
764
765 if (*argc_nr + 2 >= argc)
766 return 0;
767
768 if (strict_strtoul(argv[*argc_nr + 2], 10, &val) != -EINVAL) {
769 parsed_cmd->vid = val;
770 (*argc_nr) += 2;
771 parsed_cmd->cmd_to_keywords[*argc_nr] = ethsw_id_add_del_no;
772 return 1;
773 }
774
775 return 0;
776 }
777
778 /* Function used to match the command's pvid */
779 static int keyword_match_pvid(enum ethsw_keyword_id key_id, int argc,
780 char *const argv[], int *argc_nr,
781 struct ethsw_command_def *parsed_cmd)
782 {
783 unsigned long val;
784
785 if (!keyword_match_gen(key_id, argc, argv, argc_nr, parsed_cmd))
786 return 0;
787
788 if (*argc_nr + 1 >= argc)
789 return 1;
790
791 if (strict_strtoul(argv[*argc_nr + 1], 10, &val) != -EINVAL) {
792 parsed_cmd->vid = val;
793 (*argc_nr)++;
794 parsed_cmd->cmd_to_keywords[*argc_nr] = ethsw_id_pvid_no;
795 }
796
797 return 1;
798 }
799
800 /* Function used to match the command's MAC address */
801 static int keyword_match_mac_addr(enum ethsw_keyword_id key_id, int argc,
802 char *const argv[], int *argc_nr,
803 struct ethsw_command_def *parsed_cmd)
804 {
805 if (!keyword_match_gen(key_id, argc, argv, argc_nr, parsed_cmd))
806 return 0;
807
808 if ((*argc_nr + 1 >= argc) ||
809 !is_broadcast_ethaddr(parsed_cmd->ethaddr))
810 return 1;
811
812 if (eth_validate_ethaddr_str(argv[*argc_nr + 1])) {
813 printf("Invalid MAC address: %s\n", argv[*argc_nr + 1]);
814 return 0;
815 }
816
817 eth_parse_enetaddr(argv[*argc_nr + 1], parsed_cmd->ethaddr);
818
819 if (is_broadcast_ethaddr(parsed_cmd->ethaddr)) {
820 memset(parsed_cmd->ethaddr, 0xFF, sizeof(parsed_cmd->ethaddr));
821 return 0;
822 }
823
824 parsed_cmd->cmd_to_keywords[*argc_nr + 1] = ethsw_id_add_del_mac;
825
826 return 1;
827 }
828
829 /* Finds optional keywords and modifies *argc_va to skip them */
830 static void cmd_keywords_opt_check(const struct ethsw_command_def *parsed_cmd,
831 int *argc_val)
832 {
833 int i;
834 int keyw_opt_matched;
835 int argc_val_max;
836 int const *cmd_keyw_p;
837 int const *cmd_keyw_opt_p;
838
839 /* remember the best match */
840 argc_val_max = *argc_val;
841
842 /*
843 * check if our command's optional keywords match the optional
844 * keywords of an available command
845 */
846 for (i = 0; i < ARRAY_SIZE(ethsw_cmd_def); i++) {
847 keyw_opt_matched = 0;
848 cmd_keyw_p = &parsed_cmd->cmd_to_keywords[keyw_opt_matched];
849 cmd_keyw_opt_p = &cmd_opt_def[i].cmd_keyword[keyw_opt_matched];
850
851 /*
852 * increase the number of keywords that
853 * matched with a command
854 */
855 while (keyw_opt_matched + *argc_val <
856 parsed_cmd->cmd_keywords_nr &&
857 *cmd_keyw_opt_p != ethsw_id_key_end &&
858 *(cmd_keyw_p + *argc_val) == *cmd_keyw_opt_p) {
859 keyw_opt_matched++;
860 cmd_keyw_p++;
861 cmd_keyw_opt_p++;
862 }
863
864 /*
865 * if all our optional command's keywords perfectly match an
866 * optional pattern, then we can move to the next defined
867 * keywords in our command; remember the one that matched the
868 * greatest number of keywords
869 */
870 if (keyw_opt_matched + *argc_val <=
871 parsed_cmd->cmd_keywords_nr &&
872 *cmd_keyw_opt_p == ethsw_id_key_end &&
873 *argc_val + keyw_opt_matched > argc_val_max)
874 argc_val_max = *argc_val + keyw_opt_matched;
875 }
876
877 *argc_val = argc_val_max;
878 }
879
880 /*
881 * Finds the function to call based on keywords and
882 * modifies *argc_va to skip them
883 */
884 static void cmd_keywords_check(struct ethsw_command_def *parsed_cmd,
885 int *argc_val)
886 {
887 int i;
888 int keyw_matched;
889 int *cmd_keyw_p;
890 int *cmd_keyw_def_p;
891
892 /*
893 * check if our command's keywords match the
894 * keywords of an available command
895 */
896 for (i = 0; i < ARRAY_SIZE(ethsw_cmd_def); i++) {
897 keyw_matched = 0;
898 cmd_keyw_p = &parsed_cmd->cmd_to_keywords[keyw_matched];
899 cmd_keyw_def_p = &ethsw_cmd_def[i].cmd_keyword[keyw_matched];
900
901 /*
902 * increase the number of keywords that
903 * matched with a command
904 */
905 while (keyw_matched + *argc_val < parsed_cmd->cmd_keywords_nr &&
906 *cmd_keyw_def_p != ethsw_id_key_end &&
907 *(cmd_keyw_p + *argc_val) == *cmd_keyw_def_p) {
908 keyw_matched++;
909 cmd_keyw_p++;
910 cmd_keyw_def_p++;
911 }
912
913 /*
914 * if all our command's keywords perfectly match an
915 * available command, then we get the function we need to call
916 * to configure the Ethernet Switch
917 */
918 if (keyw_matched && keyw_matched + *argc_val ==
919 parsed_cmd->cmd_keywords_nr &&
920 *cmd_keyw_def_p == ethsw_id_key_end) {
921 *argc_val += keyw_matched;
922 parsed_cmd->cmd_function =
923 ethsw_cmd_def[i].keyword_function;
924 return;
925 }
926 }
927 }
928
929 /* find all the keywords in the command */
930 static int keywords_find(int argc, char * const argv[],
931 struct ethsw_command_def *parsed_cmd)
932 {
933 int i;
934 int j;
935 int argc_val;
936 int rc = CMD_RET_SUCCESS;
937
938 for (i = 1; i < argc; i++) {
939 for (j = 0; j < ethsw_id_count; j++) {
940 if (keyword[j].match(j, argc, argv, &i, parsed_cmd))
941 break;
942 }
943 }
944
945 /* if there is no keyword match for a word, the command is invalid */
946 for (i = 1; i < argc; i++)
947 if (parsed_cmd->cmd_to_keywords[i] == ethsw_id_key_end)
948 rc = CMD_RET_USAGE;
949
950 parsed_cmd->cmd_keywords_nr = argc;
951 argc_val = 1;
952
953 /* get optional parameters first */
954 cmd_keywords_opt_check(parsed_cmd, &argc_val);
955
956 if (argc_val == parsed_cmd->cmd_keywords_nr)
957 return CMD_RET_USAGE;
958
959 /*
960 * check the keywords and if a match is found,
961 * get the function to call
962 */
963 cmd_keywords_check(parsed_cmd, &argc_val);
964
965 /* error if not all commands' parameters were matched */
966 if (argc_val == parsed_cmd->cmd_keywords_nr) {
967 if (!parsed_cmd->cmd_function) {
968 printf("Command not available for: %s\n", ethsw_name);
969 rc = CMD_RET_FAILURE;
970 }
971 } else {
972 rc = CMD_RET_USAGE;
973 }
974
975 return rc;
976 }
977
978 static void command_def_init(struct ethsw_command_def *parsed_cmd)
979 {
980 int i;
981
982 for (i = 0; i < ETHSW_MAX_CMD_PARAMS; i++)
983 parsed_cmd->cmd_to_keywords[i] = ethsw_id_key_end;
984
985 parsed_cmd->port = ETHSW_CMD_PORT_ALL;
986 parsed_cmd->vid = ETHSW_CMD_VLAN_ALL;
987 parsed_cmd->cmd_function = NULL;
988
989 /* We initialize the MAC address with the Broadcast address */
990 memset(parsed_cmd->ethaddr, 0xff, sizeof(parsed_cmd->ethaddr));
991 }
992
993 /* function to interpret commands starting with "ethsw " */
994 static int do_ethsw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
995 {
996 struct ethsw_command_def parsed_cmd;
997 int rc = CMD_RET_SUCCESS;
998
999 if (argc == 1 || argc >= ETHSW_MAX_CMD_PARAMS)
1000 return CMD_RET_USAGE;
1001
1002 command_def_init(&parsed_cmd);
1003
1004 rc = keywords_find(argc, argv, &parsed_cmd);
1005
1006 if (rc == CMD_RET_SUCCESS)
1007 rc = parsed_cmd.cmd_function(&parsed_cmd);
1008
1009 return rc;
1010 }
1011
1012 #define ETHSW_PORT_CONF_HELP "[port <port_no>] { enable | disable | show } " \
1013 "- enable/disable a port; show shows a port's configuration"
1014
1015 U_BOOT_CMD(ethsw, ETHSW_MAX_CMD_PARAMS, 0, do_ethsw,
1016 "Ethernet l2 switch commands",
1017 ETHSW_PORT_CONF_HELP"\n"
1018 ETHSW_PORT_STATS_HELP"\n"
1019 ETHSW_LEARN_HELP"\n"
1020 ETHSW_FDB_HELP"\n"
1021 ETHSW_PVID_HELP"\n"
1022 ETHSW_VLAN_HELP"\n"
1023 ETHSW_PORT_UNTAG_HELP"\n"
1024 ETHSW_EGR_VLAN_TAG_HELP"\n"
1025 ETHSW_VLAN_FDB_HELP"\n"
1026 ETHSW_PORT_INGR_FLTR_HELP"\n"
1027 );
"Das U-Boot" Source Tree