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 mode 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 #define ETHSW_PORT_AGGR_HELP "ethsw [port <port_no>] aggr" \
 118 " { [help] | show | <lag_group_no> } " \
 119 "- get/set LAG group for a port"
 120
 121 static int ethsw_port_aggr_help_key_func(struct ethsw_command_def *parsed_cmd)
 122 {
 123         printf(ETHSW_PORT_AGGR_HELP"\n");
 124
 125         return CMD_RET_SUCCESS;
 126 }
 127
 128 static struct keywords_to_function {
 129         enum ethsw_keyword_id cmd_keyword[ETHSW_MAX_CMD_PARAMS];
 130         int cmd_func_offset;
 131         int (*keyword_function)(struct ethsw_command_def *parsed_cmd);
 132 } ethsw_cmd_def[] = {
 133                 {
 134                         .cmd_keyword = {
 135                                         ethsw_id_enable,
 136                                         ethsw_id_key_end,
 137                         },
 138                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 139                                                     port_enable),
 140                         .keyword_function = NULL,
 141                 }, {
 142                         .cmd_keyword = {
 143                                         ethsw_id_disable,
 144                                         ethsw_id_key_end,
 145                         },
 146                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 147                                                     port_disable),
 148                         .keyword_function = NULL,
 149                 }, {
 150                         .cmd_keyword = {
 151                                         ethsw_id_show,
 152                                         ethsw_id_key_end,
 153                         },
 154                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 155                                                     port_show),
 156                         .keyword_function = NULL,
 157                 }, {
 158                         .cmd_keyword = {
 159                                         ethsw_id_statistics,
 160                                         ethsw_id_help,
 161                                         ethsw_id_key_end,
 162                         },
 163                         .cmd_func_offset = -1,
 164                         .keyword_function = &ethsw_port_stats_help_key_func,
 165                 }, {
 166                         .cmd_keyword = {
 167                                         ethsw_id_statistics,
 168                                         ethsw_id_key_end,
 169                         },
 170                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 171                                                     port_stats),
 172                         .keyword_function = NULL,
 173                 }, {
 174                         .cmd_keyword = {
 175                                         ethsw_id_statistics,
 176                                         ethsw_id_clear,
 177                                         ethsw_id_key_end,
 178                         },
 179                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 180                                                     port_stats_clear),
 181                         .keyword_function = NULL,
 182                 }, {
 183                         .cmd_keyword = {
 184                                         ethsw_id_learning,
 185                                         ethsw_id_key_end,
 186                         },
 187                         .cmd_func_offset = -1,
 188                         .keyword_function = &ethsw_learn_help_key_func,
 189                 }, {
 190                         .cmd_keyword = {
 191                                         ethsw_id_learning,
 192                                         ethsw_id_help,
 193                                         ethsw_id_key_end,
 194                         },
 195                         .cmd_func_offset = -1,
 196                         .keyword_function = &ethsw_learn_help_key_func,
 197                 }, {
 198                         .cmd_keyword = {
 199                                         ethsw_id_learning,
 200                                         ethsw_id_show,
 201                                         ethsw_id_key_end,
 202                         },
 203                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 204                                                     port_learn_show),
 205                         .keyword_function = NULL,
 206                 }, {
 207                         .cmd_keyword = {
 208                                         ethsw_id_learning,
 209                                         ethsw_id_auto,
 210                                         ethsw_id_key_end,
 211                         },
 212                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 213                                                     port_learn),
 214                         .keyword_function = NULL,
 215                 }, {
 216                         .cmd_keyword = {
 217                                         ethsw_id_learning,
 218                                         ethsw_id_disable,
 219                                         ethsw_id_key_end,
 220                         },
 221                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 222                                                     port_learn),
 223                         .keyword_function = NULL,
 224                 }, {
 225                         .cmd_keyword = {
 226                                         ethsw_id_fdb,
 227                                         ethsw_id_key_end,
 228                         },
 229                         .cmd_func_offset = -1,
 230                         .keyword_function = &ethsw_fdb_help_key_func,
 231                 }, {
 232                         .cmd_keyword = {
 233                                         ethsw_id_fdb,
 234                                         ethsw_id_help,
 235                                         ethsw_id_key_end,
 236                         },
 237                         .cmd_func_offset = -1,
 238                         .keyword_function = &ethsw_fdb_help_key_func,
 239                 }, {
 240                         .cmd_keyword = {
 241                                         ethsw_id_fdb,
 242                                         ethsw_id_show,
 243                                         ethsw_id_key_end,
 244                         },
 245                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 246                                                     fdb_show),
 247                         .keyword_function = NULL,
 248                 }, {
 249                         .cmd_keyword = {
 250                                         ethsw_id_fdb,
 251                                         ethsw_id_flush,
 252                                         ethsw_id_key_end,
 253                         },
 254                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 255                                                     fdb_flush),
 256                         .keyword_function = NULL,
 257                 }, {
 258                         .cmd_keyword = {
 259                                         ethsw_id_fdb,
 260                                         ethsw_id_add,
 261                                         ethsw_id_add_del_mac,
 262                                         ethsw_id_key_end,
 263                         },
 264                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 265                                                     fdb_entry_add),
 266                         .keyword_function = NULL,
 267                 }, {
 268                         .cmd_keyword = {
 269                                         ethsw_id_fdb,
 270                                         ethsw_id_del,
 271                                         ethsw_id_add_del_mac,
 272                                         ethsw_id_key_end,
 273                         },
 274                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 275                                                     fdb_entry_del),
 276                         .keyword_function = NULL,
 277                 }, {
 278                         .cmd_keyword = {
 279                                         ethsw_id_pvid,
 280                                         ethsw_id_key_end,
 281                         },
 282                         .cmd_func_offset = -1,
 283                         .keyword_function = &ethsw_pvid_help_key_func,
 284                 }, {
 285                         .cmd_keyword = {
 286                                         ethsw_id_pvid,
 287                                         ethsw_id_help,
 288                                         ethsw_id_key_end,
 289                         },
 290                         .cmd_func_offset = -1,
 291                         .keyword_function = &ethsw_pvid_help_key_func,
 292                 }, {
 293                         .cmd_keyword = {
 294                                         ethsw_id_pvid,
 295                                         ethsw_id_show,
 296                                         ethsw_id_key_end,
 297                         },
 298                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 299                                                     pvid_show),
 300                         .keyword_function = NULL,
 301                 }, {
 302                         .cmd_keyword = {
 303                                         ethsw_id_pvid,
 304                                         ethsw_id_pvid_no,
 305                                         ethsw_id_key_end,
 306                         },
 307                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 308                                                     pvid_set),
 309                         .keyword_function = NULL,
 310                 }, {
 311                         .cmd_keyword = {
 312                                         ethsw_id_vlan,
 313                                         ethsw_id_key_end,
 314                         },
 315                         .cmd_func_offset = -1,
 316                         .keyword_function = &ethsw_vlan_help_key_func,
 317                 }, {
 318                         .cmd_keyword = {
 319                                         ethsw_id_vlan,
 320                                         ethsw_id_help,
 321                                         ethsw_id_key_end,
 322                         },
 323                         .cmd_func_offset = -1,
 324                         .keyword_function = &ethsw_vlan_help_key_func,
 325                 }, {
 326                         .cmd_keyword = {
 327                                         ethsw_id_vlan,
 328                                         ethsw_id_show,
 329                                         ethsw_id_key_end,
 330                         },
 331                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 332                                                     vlan_show),
 333                         .keyword_function = NULL,
 334                 }, {
 335                         .cmd_keyword = {
 336                                         ethsw_id_vlan,
 337                                         ethsw_id_add,
 338                                         ethsw_id_add_del_no,
 339                                         ethsw_id_key_end,
 340                         },
 341                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 342                                                     vlan_set),
 343                         .keyword_function = NULL,
 344                 }, {
 345                         .cmd_keyword = {
 346                                         ethsw_id_vlan,
 347                                         ethsw_id_del,
 348                                         ethsw_id_add_del_no,
 349                                         ethsw_id_key_end,
 350                         },
 351                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 352                                                     vlan_set),
 353                         .keyword_function = NULL,
 354                 }, {
 355                         .cmd_keyword = {
 356                                         ethsw_id_untagged,
 357                                         ethsw_id_key_end,
 358                         },
 359                         .cmd_func_offset = -1,
 360                         .keyword_function = &ethsw_port_untag_help_key_func,
 361                 }, {
 362                         .cmd_keyword = {
 363                                         ethsw_id_untagged,
 364                                         ethsw_id_help,
 365                                         ethsw_id_key_end,
 366                         },
 367                         .cmd_func_offset = -1,
 368                         .keyword_function = &ethsw_port_untag_help_key_func,
 369                 }, {
 370                         .cmd_keyword = {
 371                                         ethsw_id_untagged,
 372                                         ethsw_id_show,
 373                                         ethsw_id_key_end,
 374                         },
 375                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 376                                                     port_untag_show),
 377                         .keyword_function = NULL,
 378                 }, {
 379                         .cmd_keyword = {
 380                                         ethsw_id_untagged,
 381                                         ethsw_id_all,
 382                                         ethsw_id_key_end,
 383                         },
 384                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 385                                                     port_untag_set),
 386                         .keyword_function = NULL,
 387                 }, {
 388                         .cmd_keyword = {
 389                                         ethsw_id_untagged,
 390                                         ethsw_id_none,
 391                                         ethsw_id_key_end,
 392                         },
 393                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 394                                                     port_untag_set),
 395                         .keyword_function = NULL,
 396                 }, {
 397                         .cmd_keyword = {
 398                                         ethsw_id_untagged,
 399                                         ethsw_id_pvid,
 400                                         ethsw_id_key_end,
 401                         },
 402                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 403                                                     port_untag_set),
 404                         .keyword_function = NULL,
 405                 }, {
 406                         .cmd_keyword = {
 407                                         ethsw_id_egress,
 408                                         ethsw_id_tag,
 409                                         ethsw_id_key_end,
 410                         },
 411                         .cmd_func_offset = -1,
 412                         .keyword_function = &ethsw_egr_tag_help_key_func,
 413                 }, {
 414                         .cmd_keyword = {
 415                                         ethsw_id_egress,
 416                                         ethsw_id_tag,
 417                                         ethsw_id_help,
 418                                         ethsw_id_key_end,
 419                         },
 420                         .cmd_func_offset = -1,
 421                         .keyword_function = &ethsw_egr_tag_help_key_func,
 422                 }, {
 423                         .cmd_keyword = {
 424                                         ethsw_id_egress,
 425                                         ethsw_id_tag,
 426                                         ethsw_id_show,
 427                                         ethsw_id_key_end,
 428                         },
 429                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 430                                                     port_egr_vlan_show),
 431                         .keyword_function = NULL,
 432                 }, {
 433                         .cmd_keyword = {
 434                                         ethsw_id_egress,
 435                                         ethsw_id_tag,
 436                                         ethsw_id_pvid,
 437                                         ethsw_id_key_end,
 438                         },
 439                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 440                                                     port_egr_vlan_set),
 441                         .keyword_function = NULL,
 442                 }, {
 443                         .cmd_keyword = {
 444                                         ethsw_id_egress,
 445                                         ethsw_id_tag,
 446                                         ethsw_id_classified,
 447                                         ethsw_id_key_end,
 448                         },
 449                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 450                                                     port_egr_vlan_set),
 451                         .keyword_function = NULL,
 452                 }, {
 453                         .cmd_keyword = {
 454                                         ethsw_id_vlan,
 455                                         ethsw_id_fdb,
 456                                         ethsw_id_key_end,
 457                         },
 458                         .cmd_func_offset = -1,
 459                         .keyword_function = &ethsw_vlan_learn_help_key_func,
 460                 }, {
 461                         .cmd_keyword = {
 462                                         ethsw_id_vlan,
 463                                         ethsw_id_fdb,
 464                                         ethsw_id_help,
 465                                         ethsw_id_key_end,
 466                         },
 467                         .cmd_func_offset = -1,
 468                         .keyword_function = &ethsw_vlan_learn_help_key_func,
 469                 }, {
 470                         .cmd_keyword = {
 471                                         ethsw_id_vlan,
 472                                         ethsw_id_fdb,
 473                                         ethsw_id_show,
 474                                         ethsw_id_key_end,
 475                         },
 476                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 477                                                     vlan_learn_show),
 478                         .keyword_function = NULL,
 479                 }, {
 480                         .cmd_keyword = {
 481                                         ethsw_id_vlan,
 482                                         ethsw_id_fdb,
 483                                         ethsw_id_shared,
 484                                         ethsw_id_key_end,
 485                         },
 486                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 487                                                     vlan_learn_set),
 488                         .keyword_function = NULL,
 489                 }, {
 490                         .cmd_keyword = {
 491                                         ethsw_id_vlan,
 492                                         ethsw_id_fdb,
 493                                         ethsw_id_private,
 494                                         ethsw_id_key_end,
 495                         },
 496                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 497                                                     vlan_learn_set),
 498                         .keyword_function = NULL,
 499                 }, {
 500                         .cmd_keyword = {
 501                                         ethsw_id_ingress,
 502                                         ethsw_id_filtering,
 503                                         ethsw_id_key_end,
 504                         },
 505                         .cmd_func_offset = -1,
 506                         .keyword_function = &ethsw_ingr_fltr_help_key_func,
 507                 }, {
 508                         .cmd_keyword = {
 509                                         ethsw_id_ingress,
 510                                         ethsw_id_filtering,
 511                                         ethsw_id_help,
 512                                         ethsw_id_key_end,
 513                         },
 514                         .cmd_func_offset = -1,
 515                         .keyword_function = &ethsw_ingr_fltr_help_key_func,
 516                 }, {
 517                         .cmd_keyword = {
 518                                         ethsw_id_ingress,
 519                                         ethsw_id_filtering,
 520                                         ethsw_id_show,
 521                                         ethsw_id_key_end,
 522                         },
 523                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 524                                                     port_ingr_filt_show),
 525                         .keyword_function = NULL,
 526                 }, {
 527                         .cmd_keyword = {
 528                                         ethsw_id_ingress,
 529                                         ethsw_id_filtering,
 530                                         ethsw_id_enable,
 531                                         ethsw_id_key_end,
 532                         },
 533                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 534                                                     port_ingr_filt_set),
 535                         .keyword_function = NULL,
 536                 }, {
 537                         .cmd_keyword = {
 538                                         ethsw_id_ingress,
 539                                         ethsw_id_filtering,
 540                                         ethsw_id_disable,
 541                                         ethsw_id_key_end,
 542                         },
 543                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 544                                                     port_ingr_filt_set),
 545                         .keyword_function = NULL,
 546                 }, {
 547                         .cmd_keyword = {
 548                                         ethsw_id_aggr,
 549                                         ethsw_id_key_end,
 550                         },
 551                         .cmd_func_offset = -1,
 552                         .keyword_function = &ethsw_port_aggr_help_key_func,
 553                 }, {
 554                         .cmd_keyword = {
 555                                         ethsw_id_aggr,
 556                                         ethsw_id_help,
 557                                         ethsw_id_key_end,
 558                         },
 559                         .cmd_func_offset = -1,
 560                         .keyword_function = &ethsw_port_aggr_help_key_func,
 561                 }, {
 562                         .cmd_keyword = {
 563                                         ethsw_id_aggr,
 564                                         ethsw_id_show,
 565                                         ethsw_id_key_end,
 566                         },
 567                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 568                                                     port_aggr_show),
 569                         .keyword_function = NULL,
 570                 }, {
 571                         .cmd_keyword = {
 572                                         ethsw_id_aggr,
 573                                         ethsw_id_aggr_no,
 574                                         ethsw_id_key_end,
 575                         },
 576                         .cmd_func_offset = offsetof(struct ethsw_command_func,
 577                                                     port_aggr_set),
 578                         .keyword_function = NULL,
 579                 },
 580 };
 581
 582 struct keywords_optional {
 583         int cmd_keyword[ETHSW_MAX_CMD_PARAMS];
 584 } cmd_opt_def[] = {
 585                 {
 586                                 .cmd_keyword = {
 587                                                 ethsw_id_port,
 588                                                 ethsw_id_port_no,
 589                                                 ethsw_id_key_end,
 590                                 },
 591                 }, {
 592                                 .cmd_keyword = {
 593                                                 ethsw_id_vlan,
 594                                                 ethsw_id_vlan_no,
 595                                                 ethsw_id_key_end,
 596                                 },
 597                 }, {
 598                                 .cmd_keyword = {
 599                                                 ethsw_id_port,
 600                                                 ethsw_id_port_no,
 601                                                 ethsw_id_vlan,
 602                                                 ethsw_id_vlan_no,
 603                                                 ethsw_id_key_end,
 604                                 },
 605                 },
 606 };
 607
 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);
 626
 627 /*
 628  * Define properties for each keyword;
 629  * keep the order synced with enum ethsw_keyword_id
 630  */
 631 struct keyword_def {
 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);
 635 } keyword[] = {
 636                 {
 637                                 .keyword_name = "help",
 638                                 .match = &keyword_match_gen,
 639                 }, {
 640                                 .keyword_name = "show",
 641                                 .match = &keyword_match_gen,
 642                 }, {
 643                                 .keyword_name = "port",
 644                                 .match = &keyword_match_port
 645                 },  {
 646                                 .keyword_name = "enable",
 647                                 .match = &keyword_match_gen,
 648                 }, {
 649                                 .keyword_name = "disable",
 650                                 .match = &keyword_match_gen,
 651                 }, {
 652                                 .keyword_name = "statistics",
 653                                 .match = &keyword_match_gen,
 654                 }, {
 655                                 .keyword_name = "clear",
 656                                 .match = &keyword_match_gen,
 657                 }, {
 658                                 .keyword_name = "learning",
 659                                 .match = &keyword_match_gen,
 660                 }, {
 661                                 .keyword_name = "auto",
 662                                 .match = &keyword_match_gen,
 663                 }, {
 664                                 .keyword_name = "vlan",
 665                                 .match = &keyword_match_vlan,
 666                 }, {
 667                                 .keyword_name = "fdb",
 668                                 .match = &keyword_match_gen,
 669                 }, {
 670                                 .keyword_name = "add",
 671                                 .match = &keyword_match_mac_addr,
 672                 }, {
 673                                 .keyword_name = "del",
 674                                 .match = &keyword_match_mac_addr,
 675                 }, {
 676                                 .keyword_name = "flush",
 677                                 .match = &keyword_match_gen,
 678                 }, {
 679                                 .keyword_name = "pvid",
 680                                 .match = &keyword_match_pvid,
 681                 }, {
 682                                 .keyword_name = "untagged",
 683                                 .match = &keyword_match_gen,
 684                 }, {
 685                                 .keyword_name = "all",
 686                                 .match = &keyword_match_gen,
 687                 }, {
 688                                 .keyword_name = "none",
 689                                 .match = &keyword_match_gen,
 690                 }, {
 691                                 .keyword_name = "egress",
 692                                 .match = &keyword_match_gen,
 693                 }, {
 694                                 .keyword_name = "tag",
 695                                 .match = &keyword_match_gen,
 696                 }, {
 697                                 .keyword_name = "classified",
 698                                 .match = &keyword_match_gen,
 699                 }, {
 700                                 .keyword_name = "shared",
 701                                 .match = &keyword_match_gen,
 702                 }, {
 703                                 .keyword_name = "private",
 704                                 .match = &keyword_match_gen,
 705                 }, {
 706                                 .keyword_name = "ingress",
 707                                 .match = &keyword_match_gen,
 708                 }, {
 709                                 .keyword_name = "filtering",
 710                                 .match = &keyword_match_gen,
 711                 }, {
 712                                 .keyword_name = "aggr",
 713                                 .match = &keyword_match_aggr,
 714                 },
 715 };
 716
 717 /*
 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
 720  */
 721 int ethsw_define_functions(const struct ethsw_command_func *cmd_func)
 722 {
 723         int i;
 724         void **aux_p;
 725         int (*cmd_func_aux)(struct ethsw_command_def *);
 726
 727         if (!cmd_func->ethsw_name)
 728                 return -EINVAL;
 729
 730         ethsw_name = cmd_func->ethsw_name;
 731
 732         for (i = 0; i < ARRAY_SIZE(ethsw_cmd_def); i++) {
 733                 /*
 734                  * get the pointer to the function send by the Ethernet Switch
 735                  * driver that corresponds to the proper ethsw command
 736                  */
 737                 if (ethsw_cmd_def[i].keyword_function)
 738                         continue;
 739
 740                 aux_p = (void *)cmd_func + ethsw_cmd_def[i].cmd_func_offset;
 741
 742                 cmd_func_aux = (int (*)(struct ethsw_command_def *)) *aux_p;
 743                 ethsw_cmd_def[i].keyword_function = cmd_func_aux;
 744         }
 745
 746         return 0;
 747 }
 748
 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)
 753 {
 754         if (strcmp(argv[*argc_nr], keyword[key_id].keyword_name) == 0) {
 755                 parsed_cmd->cmd_to_keywords[*argc_nr] = key_id;
 756
 757                 return 1;
 758         }
 759         return 0;
 760 }
 761
 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)
 766 {
 767         unsigned long val;
 768
 769         if (!keyword_match_gen(key_id, argc, argv, argc_nr, parsed_cmd))
 770                 return 0;
 771
 772         if (*argc_nr + 1 >= argc)
 773                 return 0;
 774
 775         if (strict_strtoul(argv[*argc_nr + 1], 10, &val) != -EINVAL) {
 776                 parsed_cmd->port = val;
 777                 (*argc_nr)++;
 778                 parsed_cmd->cmd_to_keywords[*argc_nr] = ethsw_id_port_no;
 779                 return 1;
 780         }
 781
 782         return 0;
 783 }
 784
 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)
 789 {
 790         unsigned long val;
 791         int aux;
 792
 793         if (!keyword_match_gen(key_id, argc, argv, argc_nr, parsed_cmd))
 794                 return 0;
 795
 796         if (*argc_nr + 1 >= argc)
 797                 return 0;
 798
 799         if (strict_strtoul(argv[*argc_nr + 1], 10, &val) != -EINVAL) {
 800                 parsed_cmd->vid = val;
 801                 (*argc_nr)++;
 802                 parsed_cmd->cmd_to_keywords[*argc_nr] = ethsw_id_vlan_no;
 803                 return 1;
 804         }
 805
 806         aux = *argc_nr + 1;
 807
 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;
 812         else
 813                 return 0;
 814
 815         if (*argc_nr + 2 >= argc)
 816                 return 0;
 817
 818         if (strict_strtoul(argv[*argc_nr + 2], 10, &val) != -EINVAL) {
 819                 parsed_cmd->vid = val;
 820                 (*argc_nr) += 2;
 821                 parsed_cmd->cmd_to_keywords[*argc_nr] = ethsw_id_add_del_no;
 822                 return 1;
 823         }
 824
 825         return 0;
 826 }
 827
 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)
 832 {
 833         unsigned long val;
 834
 835         if (!keyword_match_gen(key_id, argc, argv, argc_nr, parsed_cmd))
 836                 return 0;
 837
 838         if (*argc_nr + 1 >= argc)
 839                 return 1;
 840
 841         if (strict_strtoul(argv[*argc_nr + 1], 10, &val) != -EINVAL) {
 842                 parsed_cmd->vid = val;
 843                 (*argc_nr)++;
 844                 parsed_cmd->cmd_to_keywords[*argc_nr] = ethsw_id_pvid_no;
 845         }
 846
 847         return 1;
 848 }
 849
 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)
 854 {
 855         if (!keyword_match_gen(key_id, argc, argv, argc_nr, parsed_cmd))
 856                 return 0;
 857
 858         if ((*argc_nr + 1 >= argc) ||
 859             !is_broadcast_ethaddr(parsed_cmd->ethaddr))
 860                 return 1;
 861
 862         if (eth_validate_ethaddr_str(argv[*argc_nr + 1])) {
 863                 printf("Invalid MAC address: %s\n", argv[*argc_nr + 1]);
 864                 return 0;
 865         }
 866
 867         eth_parse_enetaddr(argv[*argc_nr + 1], parsed_cmd->ethaddr);
 868
 869         if (is_broadcast_ethaddr(parsed_cmd->ethaddr)) {
 870                 memset(parsed_cmd->ethaddr, 0xFF, sizeof(parsed_cmd->ethaddr));
 871                 return 0;
 872         }
 873
 874         parsed_cmd->cmd_to_keywords[*argc_nr + 1] = ethsw_id_add_del_mac;
 875
 876         return 1;
 877 }
 878
 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)
 883 {
 884         unsigned long val;
 885
 886         if (!keyword_match_gen(key_id, argc, argv, argc_nr, parsed_cmd))
 887                 return 0;
 888
 889         if (*argc_nr + 1 >= argc)
 890                 return 1;
 891
 892         if (strict_strtoul(argv[*argc_nr + 1], 10, &val) != -EINVAL) {
 893                 parsed_cmd->aggr_grp = val;
 894                 (*argc_nr)++;
 895                 parsed_cmd->cmd_to_keywords[*argc_nr] = ethsw_id_aggr_no;
 896         }
 897
 898         return 1;
 899 }
 900
 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,
 903                                    int *argc_val)
 904 {
 905         int i;
 906         int keyw_opt_matched;
 907         int argc_val_max;
 908         int const *cmd_keyw_p;
 909         int const *cmd_keyw_opt_p;
 910
 911         /* remember the best match */
 912         argc_val_max = *argc_val;
 913
 914         /*
 915          * check if our command's optional keywords match the optional
 916          * keywords of an available command
 917          */
 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];
 922
 923                 /*
 924                  * increase the number of keywords that
 925                  * matched with a command
 926                  */
 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) {
 931                         keyw_opt_matched++;
 932                         cmd_keyw_p++;
 933                         cmd_keyw_opt_p++;
 934                 }
 935
 936                 /*
 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
 941                  */
 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;
 947         }
 948
 949         *argc_val = argc_val_max;
 950 }
 951
 952 /*
 953  * Finds the function to call based on keywords and
 954  * modifies *argc_va to skip them
 955  */
 956 static void cmd_keywords_check(struct ethsw_command_def *parsed_cmd,
 957                                int *argc_val)
 958 {
 959         int i;
 960         int keyw_matched;
 961         int *cmd_keyw_p;
 962         int *cmd_keyw_def_p;
 963
 964         /*
 965          * check if our command's keywords match the
 966          * keywords of an available command
 967          */
 968         for (i = 0; i < ARRAY_SIZE(ethsw_cmd_def); i++) {
 969                 keyw_matched = 0;
 970                 cmd_keyw_p = &parsed_cmd->cmd_to_keywords[keyw_matched];
 971                 cmd_keyw_def_p = &ethsw_cmd_def[i].cmd_keyword[keyw_matched];
 972
 973                 /*
 974                  * increase the number of keywords that
 975                  * matched with a command
 976                  */
 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) {
 980                         keyw_matched++;
 981                         cmd_keyw_p++;
 982                         cmd_keyw_def_p++;
 983                 }
 984
 985                 /*
 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
 989                  */
 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;
 996                         return;
 997                 }
 998         }
 999 }
1000
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)
1004 {
1005         int i;
1006         int j;
1007         int argc_val;
1008         int rc = CMD_RET_SUCCESS;
1009
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))
1013                                 break;
1014                 }
1015         }
1016
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)
1020                         rc = CMD_RET_USAGE;
1021
1022         parsed_cmd->cmd_keywords_nr = argc;
1023         argc_val = 1;
1024
1025         /* get optional parameters first */
1026         cmd_keywords_opt_check(parsed_cmd, &argc_val);
1027
1028         if (argc_val == parsed_cmd->cmd_keywords_nr)
1029                 return CMD_RET_USAGE;
1030
1031         /*
1032          * check the keywords and if a match is found,
1033          * get the function to call
1034          */
1035         cmd_keywords_check(parsed_cmd, &argc_val);
1036
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;
1042                 }
1043         } else {
1044                 rc = CMD_RET_USAGE;
1045         }
1046
1047         return rc;
1048 }
1049
1050 static void command_def_init(struct ethsw_command_def *parsed_cmd)
1051 {
1052         int i;
1053
1054         for (i = 0; i < ETHSW_MAX_CMD_PARAMS; i++)
1055                 parsed_cmd->cmd_to_keywords[i] = ethsw_id_key_end;
1056
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;
1061
1062         /* We initialize the MAC address with the Broadcast address */
1063         memset(parsed_cmd->ethaddr, 0xff, sizeof(parsed_cmd->ethaddr));
1064 }
1065
1066 /* function to interpret commands starting with "ethsw " */
1067 static int do_ethsw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1068 {
1069         struct ethsw_command_def parsed_cmd;
1070         int rc = CMD_RET_SUCCESS;
1071
1072         if (argc == 1 || argc >= ETHSW_MAX_CMD_PARAMS)
1073                 return CMD_RET_USAGE;
1074
1075         command_def_init(&parsed_cmd);
1076
1077         rc = keywords_find(argc, argv, &parsed_cmd);
1078
1079         if (rc == CMD_RET_SUCCESS)
1080                 rc = parsed_cmd.cmd_function(&parsed_cmd);
1081
1082         return rc;
1083 }
1084
1085 #define ETHSW_PORT_CONF_HELP "[port <port_no>] { enable | disable | show } " \
1086 "- enable/disable a port; show a port's configuration"
1087
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"
1093            ETHSW_FDB_HELP"\n"
1094            ETHSW_PVID_HELP"\n"
1095            ETHSW_VLAN_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"
1101 );