drivers/net/ethernet/marvell/prestera/prestera_hw.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved */
   3
   4 #include <linux/etherdevice.h>
   5 #include <linux/if_bridge.h>
   6 #include <linux/ethtool.h>
   7 #include <linux/list.h>
   8
   9 #include "prestera.h"
  10 #include "prestera_hw.h"
  11 #include "prestera_acl.h"
  12 #include "prestera_counter.h"
  13
  14 #define PRESTERA_SWITCH_INIT_TIMEOUT_MS (30 * 1000)
  15
  16 #define PRESTERA_MIN_MTU 64
  17
  18 enum prestera_cmd_type_t {
  19         PRESTERA_CMD_TYPE_SWITCH_INIT = 0x1,
  20         PRESTERA_CMD_TYPE_SWITCH_ATTR_SET = 0x2,
  21
  22         PRESTERA_CMD_TYPE_PORT_ATTR_SET = 0x100,
  23         PRESTERA_CMD_TYPE_PORT_ATTR_GET = 0x101,
  24         PRESTERA_CMD_TYPE_PORT_INFO_GET = 0x110,
  25
  26         PRESTERA_CMD_TYPE_VLAN_CREATE = 0x200,
  27         PRESTERA_CMD_TYPE_VLAN_DELETE = 0x201,
  28         PRESTERA_CMD_TYPE_VLAN_PORT_SET = 0x202,
  29         PRESTERA_CMD_TYPE_VLAN_PVID_SET = 0x203,
  30
  31         PRESTERA_CMD_TYPE_FDB_ADD = 0x300,
  32         PRESTERA_CMD_TYPE_FDB_DELETE = 0x301,
  33         PRESTERA_CMD_TYPE_FDB_FLUSH_PORT = 0x310,
  34         PRESTERA_CMD_TYPE_FDB_FLUSH_VLAN = 0x311,
  35         PRESTERA_CMD_TYPE_FDB_FLUSH_PORT_VLAN = 0x312,
  36
  37         PRESTERA_CMD_TYPE_BRIDGE_CREATE = 0x400,
  38         PRESTERA_CMD_TYPE_BRIDGE_DELETE = 0x401,
  39         PRESTERA_CMD_TYPE_BRIDGE_PORT_ADD = 0x402,
  40         PRESTERA_CMD_TYPE_BRIDGE_PORT_DELETE = 0x403,
  41
  42         PRESTERA_CMD_TYPE_COUNTER_GET = 0x510,
  43         PRESTERA_CMD_TYPE_COUNTER_ABORT = 0x511,
  44         PRESTERA_CMD_TYPE_COUNTER_TRIGGER = 0x512,
  45         PRESTERA_CMD_TYPE_COUNTER_BLOCK_GET = 0x513,
  46         PRESTERA_CMD_TYPE_COUNTER_BLOCK_RELEASE = 0x514,
  47         PRESTERA_CMD_TYPE_COUNTER_CLEAR = 0x515,
  48
  49         PRESTERA_CMD_TYPE_VTCAM_CREATE = 0x540,
  50         PRESTERA_CMD_TYPE_VTCAM_DESTROY = 0x541,
  51         PRESTERA_CMD_TYPE_VTCAM_RULE_ADD = 0x550,
  52         PRESTERA_CMD_TYPE_VTCAM_RULE_DELETE = 0x551,
  53         PRESTERA_CMD_TYPE_VTCAM_IFACE_BIND = 0x560,
  54         PRESTERA_CMD_TYPE_VTCAM_IFACE_UNBIND = 0x561,
  55
  56         PRESTERA_CMD_TYPE_ROUTER_RIF_CREATE = 0x600,
  57         PRESTERA_CMD_TYPE_ROUTER_RIF_DELETE = 0x601,
  58         PRESTERA_CMD_TYPE_ROUTER_LPM_ADD = 0x610,
  59         PRESTERA_CMD_TYPE_ROUTER_LPM_DELETE = 0x611,
  60         PRESTERA_CMD_TYPE_ROUTER_VR_CREATE = 0x630,
  61         PRESTERA_CMD_TYPE_ROUTER_VR_DELETE = 0x631,
  62
  63         PRESTERA_CMD_TYPE_RXTX_INIT = 0x800,
  64
  65         PRESTERA_CMD_TYPE_LAG_MEMBER_ADD = 0x900,
  66         PRESTERA_CMD_TYPE_LAG_MEMBER_DELETE = 0x901,
  67         PRESTERA_CMD_TYPE_LAG_MEMBER_ENABLE = 0x902,
  68         PRESTERA_CMD_TYPE_LAG_MEMBER_DISABLE = 0x903,
  69
  70         PRESTERA_CMD_TYPE_STP_PORT_SET = 0x1000,
  71
  72         PRESTERA_CMD_TYPE_SPAN_GET = 0x1100,
  73         PRESTERA_CMD_TYPE_SPAN_BIND = 0x1101,
  74         PRESTERA_CMD_TYPE_SPAN_UNBIND = 0x1102,
  75         PRESTERA_CMD_TYPE_SPAN_RELEASE = 0x1103,
  76
  77         PRESTERA_CMD_TYPE_POLICER_CREATE = 0x1500,
  78         PRESTERA_CMD_TYPE_POLICER_RELEASE = 0x1501,
  79         PRESTERA_CMD_TYPE_POLICER_SET = 0x1502,
  80
  81         PRESTERA_CMD_TYPE_CPU_CODE_COUNTERS_GET = 0x2000,
  82
  83         PRESTERA_CMD_TYPE_ACK = 0x10000,
  84         PRESTERA_CMD_TYPE_MAX
  85 };
  86
  87 enum {
  88         PRESTERA_CMD_PORT_ATTR_ADMIN_STATE = 1,
  89         PRESTERA_CMD_PORT_ATTR_MTU = 3,
  90         PRESTERA_CMD_PORT_ATTR_MAC = 4,
  91         PRESTERA_CMD_PORT_ATTR_SPEED = 5,
  92         PRESTERA_CMD_PORT_ATTR_ACCEPT_FRAME_TYPE = 6,
  93         PRESTERA_CMD_PORT_ATTR_LEARNING = 7,
  94         PRESTERA_CMD_PORT_ATTR_FLOOD = 8,
  95         PRESTERA_CMD_PORT_ATTR_CAPABILITY = 9,
  96         PRESTERA_CMD_PORT_ATTR_PHY_MODE = 12,
  97         PRESTERA_CMD_PORT_ATTR_TYPE = 13,
  98         PRESTERA_CMD_PORT_ATTR_STATS = 17,
  99         PRESTERA_CMD_PORT_ATTR_MAC_AUTONEG_RESTART = 18,
 100         PRESTERA_CMD_PORT_ATTR_PHY_AUTONEG_RESTART = 19,
 101         PRESTERA_CMD_PORT_ATTR_MAC_MODE = 22,
 102 };
 103
 104 enum {
 105         PRESTERA_CMD_SWITCH_ATTR_MAC = 1,
 106         PRESTERA_CMD_SWITCH_ATTR_AGEING = 2,
 107 };
 108
 109 enum {
 110         PRESTERA_CMD_ACK_OK,
 111         PRESTERA_CMD_ACK_FAILED,
 112
 113         PRESTERA_CMD_ACK_MAX
 114 };
 115
 116 enum {
 117         PRESTERA_PORT_TP_NA,
 118         PRESTERA_PORT_TP_MDI,
 119         PRESTERA_PORT_TP_MDIX,
 120         PRESTERA_PORT_TP_AUTO,
 121 };
 122
 123 enum {
 124         PRESTERA_PORT_FLOOD_TYPE_UC = 0,
 125         PRESTERA_PORT_FLOOD_TYPE_MC = 1,
 126 };
 127
 128 enum {
 129         PRESTERA_PORT_GOOD_OCTETS_RCV_CNT,
 130         PRESTERA_PORT_BAD_OCTETS_RCV_CNT,
 131         PRESTERA_PORT_MAC_TRANSMIT_ERR_CNT,
 132         PRESTERA_PORT_BRDC_PKTS_RCV_CNT,
 133         PRESTERA_PORT_MC_PKTS_RCV_CNT,
 134         PRESTERA_PORT_PKTS_64L_CNT,
 135         PRESTERA_PORT_PKTS_65TO127L_CNT,
 136         PRESTERA_PORT_PKTS_128TO255L_CNT,
 137         PRESTERA_PORT_PKTS_256TO511L_CNT,
 138         PRESTERA_PORT_PKTS_512TO1023L_CNT,
 139         PRESTERA_PORT_PKTS_1024TOMAXL_CNT,
 140         PRESTERA_PORT_EXCESSIVE_COLLISIONS_CNT,
 141         PRESTERA_PORT_MC_PKTS_SENT_CNT,
 142         PRESTERA_PORT_BRDC_PKTS_SENT_CNT,
 143         PRESTERA_PORT_FC_SENT_CNT,
 144         PRESTERA_PORT_GOOD_FC_RCV_CNT,
 145         PRESTERA_PORT_DROP_EVENTS_CNT,
 146         PRESTERA_PORT_UNDERSIZE_PKTS_CNT,
 147         PRESTERA_PORT_FRAGMENTS_PKTS_CNT,
 148         PRESTERA_PORT_OVERSIZE_PKTS_CNT,
 149         PRESTERA_PORT_JABBER_PKTS_CNT,
 150         PRESTERA_PORT_MAC_RCV_ERROR_CNT,
 151         PRESTERA_PORT_BAD_CRC_CNT,
 152         PRESTERA_PORT_COLLISIONS_CNT,
 153         PRESTERA_PORT_LATE_COLLISIONS_CNT,
 154         PRESTERA_PORT_GOOD_UC_PKTS_RCV_CNT,
 155         PRESTERA_PORT_GOOD_UC_PKTS_SENT_CNT,
 156         PRESTERA_PORT_MULTIPLE_PKTS_SENT_CNT,
 157         PRESTERA_PORT_DEFERRED_PKTS_SENT_CNT,
 158         PRESTERA_PORT_GOOD_OCTETS_SENT_CNT,
 159
 160         PRESTERA_PORT_CNT_MAX
 161 };
 162
 163 enum {
 164         PRESTERA_FC_NONE,
 165         PRESTERA_FC_SYMMETRIC,
 166         PRESTERA_FC_ASYMMETRIC,
 167         PRESTERA_FC_SYMM_ASYMM,
 168 };
 169
 170 enum {
 171         PRESTERA_POLICER_MODE_SR_TCM
 172 };
 173
 174 enum {
 175         PRESTERA_HW_FDB_ENTRY_TYPE_REG_PORT = 0,
 176         PRESTERA_HW_FDB_ENTRY_TYPE_LAG = 1,
 177         PRESTERA_HW_FDB_ENTRY_TYPE_MAX = 2,
 178 };
 179
 180 struct prestera_fw_event_handler {
 181         struct list_head list;
 182         struct rcu_head rcu;
 183         enum prestera_event_type type;
 184         prestera_event_cb_t func;
 185         void *arg;
 186 };
 187
 188 struct prestera_msg_cmd {
 189         __le32 type;
 190 };
 191
 192 struct prestera_msg_ret {
 193         struct prestera_msg_cmd cmd;
 194         __le32 status;
 195 };
 196
 197 struct prestera_msg_common_req {
 198         struct prestera_msg_cmd cmd;
 199 };
 200
 201 struct prestera_msg_common_resp {
 202         struct prestera_msg_ret ret;
 203 };
 204
 205 struct prestera_msg_switch_attr_req {
 206         struct prestera_msg_cmd cmd;
 207         __le32 attr;
 208         union {
 209                 __le32 ageing_timeout_ms;
 210                 struct {
 211                         u8 mac[ETH_ALEN];
 212                         u8 __pad[2];
 213                 };
 214         } param;
 215 };
 216
 217 struct prestera_msg_switch_init_resp {
 218         struct prestera_msg_ret ret;
 219         __le32 port_count;
 220         __le32 mtu_max;
 221         __le32 size_tbl_router_nexthop;
 222         u8 switch_id;
 223         u8 lag_max;
 224         u8 lag_member_max;
 225 };
 226
 227 struct prestera_msg_event_port_param {
 228         union {
 229                 struct {
 230                         __le32 mode;
 231                         __le32 speed;
 232                         u8 oper;
 233                         u8 duplex;
 234                         u8 fc;
 235                         u8 fec;
 236                 } mac;
 237                 struct {
 238                         __le64 lmode_bmap;
 239                         u8 mdix;
 240                         u8 fc;
 241                         u8 __pad[2];
 242                 } __packed phy; /* make sure always 12 bytes size */
 243         };
 244 };
 245
 246 struct prestera_msg_port_cap_param {
 247         __le64 link_mode;
 248         u8 type;
 249         u8 fec;
 250         u8 fc;
 251         u8 transceiver;
 252 };
 253
 254 struct prestera_msg_port_flood_param {
 255         u8 type;
 256         u8 enable;
 257         u8 __pad[2];
 258 };
 259
 260 union prestera_msg_port_param {
 261         __le32 mtu;
 262         __le32 speed;
 263         __le32 link_mode;
 264         u8 admin_state;
 265         u8 oper_state;
 266         u8 mac[ETH_ALEN];
 267         u8 accept_frm_type;
 268         u8 learning;
 269         u8 flood;
 270         u8 type;
 271         u8 duplex;
 272         u8 fec;
 273         u8 fc;
 274         union {
 275                 struct {
 276                         u8 admin;
 277                         u8 fc;
 278                         u8 ap_enable;
 279                         u8 __reserved[5];
 280                         union {
 281                                 struct {
 282                                         __le32 mode;
 283                                         __le32 speed;
 284                                         u8 inband;
 285                                         u8 duplex;
 286                                         u8 fec;
 287                                         u8 fec_supp;
 288                                 } reg_mode;
 289                                 struct {
 290                                         __le32 mode;
 291                                         __le32 speed;
 292                                         u8 fec;
 293                                         u8 fec_supp;
 294                                         u8 __pad[2];
 295                                 } ap_modes[PRESTERA_AP_PORT_MAX];
 296                         };
 297                 } mac;
 298                 struct {
 299                         __le64 modes;
 300                         __le32 mode;
 301                         u8 admin;
 302                         u8 adv_enable;
 303                         u8 mdix;
 304                         u8 __pad;
 305                 } phy;
 306         } link;
 307
 308         struct prestera_msg_port_cap_param cap;
 309         struct prestera_msg_port_flood_param flood_ext;
 310         struct prestera_msg_event_port_param link_evt;
 311 };
 312
 313 struct prestera_msg_port_attr_req {
 314         struct prestera_msg_cmd cmd;
 315         __le32 attr;
 316         __le32 port;
 317         __le32 dev;
 318         union prestera_msg_port_param param;
 319 };
 320
 321 struct prestera_msg_port_attr_resp {
 322         struct prestera_msg_ret ret;
 323         union prestera_msg_port_param param;
 324 };
 325
 326 struct prestera_msg_port_stats_resp {
 327         struct prestera_msg_ret ret;
 328         __le64 stats[PRESTERA_PORT_CNT_MAX];
 329 };
 330
 331 struct prestera_msg_port_info_req {
 332         struct prestera_msg_cmd cmd;
 333         __le32 port;
 334 };
 335
 336 struct prestera_msg_port_info_resp {
 337         struct prestera_msg_ret ret;
 338         __le32 hw_id;
 339         __le32 dev_id;
 340         __le16 fp_id;
 341         u8 pad[2];
 342 };
 343
 344 struct prestera_msg_vlan_req {
 345         struct prestera_msg_cmd cmd;
 346         __le32 port;
 347         __le32 dev;
 348         __le16 vid;
 349         u8 is_member;
 350         u8 is_tagged;
 351 };
 352
 353 struct prestera_msg_fdb_req {
 354         struct prestera_msg_cmd cmd;
 355         __le32 flush_mode;
 356         union {
 357                 struct {
 358                         __le32 port;
 359                         __le32 dev;
 360                 };
 361                 __le16 lag_id;
 362         } dest;
 363         __le16 vid;
 364         u8 dest_type;
 365         u8 dynamic;
 366         u8 mac[ETH_ALEN];
 367         u8 __pad[2];
 368 };
 369
 370 struct prestera_msg_bridge_req {
 371         struct prestera_msg_cmd cmd;
 372         __le32 port;
 373         __le32 dev;
 374         __le16 bridge;
 375         u8 pad[2];
 376 };
 377
 378 struct prestera_msg_bridge_resp {
 379         struct prestera_msg_ret ret;
 380         __le16 bridge;
 381         u8 pad[2];
 382 };
 383
 384 struct prestera_msg_vtcam_create_req {
 385         struct prestera_msg_cmd cmd;
 386         __le32 keymask[__PRESTERA_ACL_RULE_MATCH_TYPE_MAX];
 387         u8 direction;
 388         u8 lookup;
 389         u8 pad[2];
 390 };
 391
 392 struct prestera_msg_vtcam_destroy_req {
 393         struct prestera_msg_cmd cmd;
 394         __le32 vtcam_id;
 395 };
 396
 397 struct prestera_msg_vtcam_rule_add_req {
 398         struct prestera_msg_cmd cmd;
 399         __le32 key[__PRESTERA_ACL_RULE_MATCH_TYPE_MAX];
 400         __le32 keymask[__PRESTERA_ACL_RULE_MATCH_TYPE_MAX];
 401         __le32 vtcam_id;
 402         __le32 prio;
 403         __le32 n_act;
 404 };
 405
 406 struct prestera_msg_vtcam_rule_del_req {
 407         struct prestera_msg_cmd cmd;
 408         __le32 vtcam_id;
 409         __le32 id;
 410 };
 411
 412 struct prestera_msg_vtcam_bind_req {
 413         struct prestera_msg_cmd cmd;
 414         union {
 415                 struct {
 416                         __le32 hw_id;
 417                         __le32 dev_id;
 418                 } port;
 419                 __le32 index;
 420         };
 421         __le32 vtcam_id;
 422         __le16 pcl_id;
 423         __le16 type;
 424 };
 425
 426 struct prestera_msg_vtcam_resp {
 427         struct prestera_msg_ret ret;
 428         __le32 vtcam_id;
 429         __le32 rule_id;
 430 };
 431
 432 struct prestera_msg_acl_action {
 433         __le32 id;
 434         __le32 __reserved;
 435         union {
 436                 struct {
 437                         __le32 index;
 438                 } jump;
 439                 struct {
 440                         __le32 id;
 441                 } police;
 442                 struct {
 443                         __le32 id;
 444                 } count;
 445                 __le32 reserved[6];
 446         };
 447 };
 448
 449 struct prestera_msg_counter_req {
 450         struct prestera_msg_cmd cmd;
 451         __le32 client;
 452         __le32 block_id;
 453         __le32 num_counters;
 454 };
 455
 456 struct prestera_msg_counter_stats {
 457         __le64 packets;
 458         __le64 bytes;
 459 };
 460
 461 struct prestera_msg_counter_resp {
 462         struct prestera_msg_ret ret;
 463         __le32 block_id;
 464         __le32 offset;
 465         __le32 num_counters;
 466         __le32 done;
 467         struct prestera_msg_counter_stats stats[];
 468 };
 469
 470 struct prestera_msg_span_req {
 471         struct prestera_msg_cmd cmd;
 472         __le32 port;
 473         __le32 dev;
 474         u8 id;
 475         u8 pad[3];
 476 };
 477
 478 struct prestera_msg_span_resp {
 479         struct prestera_msg_ret ret;
 480         u8 id;
 481         u8 pad[3];
 482 };
 483
 484 struct prestera_msg_stp_req {
 485         struct prestera_msg_cmd cmd;
 486         __le32 port;
 487         __le32 dev;
 488         __le16 vid;
 489         u8 state;
 490         u8 __pad;
 491 };
 492
 493 struct prestera_msg_rxtx_req {
 494         struct prestera_msg_cmd cmd;
 495         u8 use_sdma;
 496         u8 pad[3];
 497 };
 498
 499 struct prestera_msg_rxtx_resp {
 500         struct prestera_msg_ret ret;
 501         __le32 map_addr;
 502 };
 503
 504 struct prestera_msg_iface {
 505         union {
 506                 struct {
 507                         __le32 dev;
 508                         __le32 port;
 509                 };
 510                 __le16 lag_id;
 511         };
 512         __le16 vr_id;
 513         __le16 vid;
 514         u8 type;
 515         u8 __pad[3];
 516 };
 517
 518 struct prestera_msg_ip_addr {
 519         union {
 520                 __be32 ipv4;
 521                 __be32 ipv6[4];
 522         } u;
 523         u8 v; /* e.g. PRESTERA_IPV4 */
 524         u8 __pad[3];
 525 };
 526
 527 struct prestera_msg_rif_req {
 528         struct prestera_msg_cmd cmd;
 529         struct prestera_msg_iface iif;
 530         __le32 mtu;
 531         __le16 rif_id;
 532         __le16 __reserved;
 533         u8 mac[ETH_ALEN];
 534         u8 __pad[2];
 535 };
 536
 537 struct prestera_msg_rif_resp {
 538         struct prestera_msg_ret ret;
 539         __le16 rif_id;
 540         u8 __pad[2];
 541 };
 542
 543 struct prestera_msg_lpm_req {
 544         struct prestera_msg_cmd cmd;
 545         struct prestera_msg_ip_addr dst;
 546         __le32 grp_id;
 547         __le32 dst_len;
 548         __le16 vr_id;
 549         u8 __pad[2];
 550 };
 551
 552 struct prestera_msg_vr_req {
 553         struct prestera_msg_cmd cmd;
 554         __le16 vr_id;
 555         u8 __pad[2];
 556 };
 557
 558 struct prestera_msg_vr_resp {
 559         struct prestera_msg_ret ret;
 560         __le16 vr_id;
 561         u8 __pad[2];
 562 };
 563
 564 struct prestera_msg_lag_req {
 565         struct prestera_msg_cmd cmd;
 566         __le32 port;
 567         __le32 dev;
 568         __le16 lag_id;
 569         u8 pad[2];
 570 };
 571
 572 struct prestera_msg_cpu_code_counter_req {
 573         struct prestera_msg_cmd cmd;
 574         u8 counter_type;
 575         u8 code;
 576         u8 pad[2];
 577 };
 578
 579 struct mvsw_msg_cpu_code_counter_ret {
 580         struct prestera_msg_ret ret;
 581         __le64 packet_count;
 582 };
 583
 584 struct prestera_msg_policer_req {
 585         struct prestera_msg_cmd cmd;
 586         __le32 id;
 587         union {
 588                 struct {
 589                         __le64 cir;
 590                         __le32 cbs;
 591                 } __packed sr_tcm; /* make sure always 12 bytes size */
 592                 __le32 reserved[6];
 593         };
 594         u8 mode;
 595         u8 type;
 596         u8 pad[2];
 597 };
 598
 599 struct prestera_msg_policer_resp {
 600         struct prestera_msg_ret ret;
 601         __le32 id;
 602 };
 603
 604 struct prestera_msg_event {
 605         __le16 type;
 606         __le16 id;
 607 };
 608
 609 struct prestera_msg_event_port {
 610         struct prestera_msg_event id;
 611         __le32 port_id;
 612         struct prestera_msg_event_port_param param;
 613 };
 614
 615 union prestera_msg_event_fdb_param {
 616         u8 mac[ETH_ALEN];
 617 };
 618
 619 struct prestera_msg_event_fdb {
 620         struct prestera_msg_event id;
 621         __le32 vid;
 622         union {
 623                 __le32 port_id;
 624                 __le16 lag_id;
 625         } dest;
 626         union prestera_msg_event_fdb_param param;
 627         u8 dest_type;
 628 };
 629
 630 static void prestera_hw_build_tests(void)
 631 {
 632         /* check requests */
 633         BUILD_BUG_ON(sizeof(struct prestera_msg_common_req) != 4);
 634         BUILD_BUG_ON(sizeof(struct prestera_msg_switch_attr_req) != 16);
 635         BUILD_BUG_ON(sizeof(struct prestera_msg_port_attr_req) != 144);
 636         BUILD_BUG_ON(sizeof(struct prestera_msg_port_info_req) != 8);
 637         BUILD_BUG_ON(sizeof(struct prestera_msg_vlan_req) != 16);
 638         BUILD_BUG_ON(sizeof(struct prestera_msg_fdb_req) != 28);
 639         BUILD_BUG_ON(sizeof(struct prestera_msg_bridge_req) != 16);
 640         BUILD_BUG_ON(sizeof(struct prestera_msg_span_req) != 16);
 641         BUILD_BUG_ON(sizeof(struct prestera_msg_stp_req) != 16);
 642         BUILD_BUG_ON(sizeof(struct prestera_msg_rxtx_req) != 8);
 643         BUILD_BUG_ON(sizeof(struct prestera_msg_lag_req) != 16);
 644         BUILD_BUG_ON(sizeof(struct prestera_msg_cpu_code_counter_req) != 8);
 645         BUILD_BUG_ON(sizeof(struct prestera_msg_vtcam_create_req) != 84);
 646         BUILD_BUG_ON(sizeof(struct prestera_msg_vtcam_destroy_req) != 8);
 647         BUILD_BUG_ON(sizeof(struct prestera_msg_vtcam_rule_add_req) != 168);
 648         BUILD_BUG_ON(sizeof(struct prestera_msg_vtcam_rule_del_req) != 12);
 649         BUILD_BUG_ON(sizeof(struct prestera_msg_vtcam_bind_req) != 20);
 650         BUILD_BUG_ON(sizeof(struct prestera_msg_acl_action) != 32);
 651         BUILD_BUG_ON(sizeof(struct prestera_msg_counter_req) != 16);
 652         BUILD_BUG_ON(sizeof(struct prestera_msg_counter_stats) != 16);
 653         BUILD_BUG_ON(sizeof(struct prestera_msg_rif_req) != 36);
 654         BUILD_BUG_ON(sizeof(struct prestera_msg_vr_req) != 8);
 655         BUILD_BUG_ON(sizeof(struct prestera_msg_lpm_req) != 36);
 656         BUILD_BUG_ON(sizeof(struct prestera_msg_policer_req) != 36);
 657
 658         /*  structure that are part of req/resp fw messages */
 659         BUILD_BUG_ON(sizeof(struct prestera_msg_iface) != 16);
 660         BUILD_BUG_ON(sizeof(struct prestera_msg_ip_addr) != 20);
 661
 662         /* check responses */
 663         BUILD_BUG_ON(sizeof(struct prestera_msg_common_resp) != 8);
 664         BUILD_BUG_ON(sizeof(struct prestera_msg_switch_init_resp) != 24);
 665         BUILD_BUG_ON(sizeof(struct prestera_msg_port_attr_resp) != 136);
 666         BUILD_BUG_ON(sizeof(struct prestera_msg_port_stats_resp) != 248);
 667         BUILD_BUG_ON(sizeof(struct prestera_msg_port_info_resp) != 20);
 668         BUILD_BUG_ON(sizeof(struct prestera_msg_bridge_resp) != 12);
 669         BUILD_BUG_ON(sizeof(struct prestera_msg_span_resp) != 12);
 670         BUILD_BUG_ON(sizeof(struct prestera_msg_rxtx_resp) != 12);
 671         BUILD_BUG_ON(sizeof(struct prestera_msg_vtcam_resp) != 16);
 672         BUILD_BUG_ON(sizeof(struct prestera_msg_counter_resp) != 24);
 673         BUILD_BUG_ON(sizeof(struct prestera_msg_rif_resp) != 12);
 674         BUILD_BUG_ON(sizeof(struct prestera_msg_vr_resp) != 12);
 675         BUILD_BUG_ON(sizeof(struct prestera_msg_policer_resp) != 12);
 676
 677         /* check events */
 678         BUILD_BUG_ON(sizeof(struct prestera_msg_event_port) != 20);
 679         BUILD_BUG_ON(sizeof(struct prestera_msg_event_fdb) != 20);
 680 }
 681
 682 static u8 prestera_hw_mdix_to_eth(u8 mode);
 683 static void prestera_hw_remote_fc_to_eth(u8 fc, bool *pause, bool *asym_pause);
 684
 685 static int __prestera_cmd_ret(struct prestera_switch *sw,
 686                               enum prestera_cmd_type_t type,
 687                               struct prestera_msg_cmd *cmd, size_t clen,
 688                               struct prestera_msg_ret *ret, size_t rlen,
 689                               int waitms)
 690 {
 691         struct prestera_device *dev = sw->dev;
 692         int err;
 693
 694         cmd->type = __cpu_to_le32(type);
 695
 696         err = dev->send_req(dev, 0, cmd, clen, ret, rlen, waitms);
 697         if (err)
 698                 return err;
 699
 700         if (ret->cmd.type != __cpu_to_le32(PRESTERA_CMD_TYPE_ACK))
 701                 return -EBADE;
 702         if (ret->status != __cpu_to_le32(PRESTERA_CMD_ACK_OK))
 703                 return -EINVAL;
 704
 705         return 0;
 706 }
 707
 708 static int prestera_cmd_ret(struct prestera_switch *sw,
 709                             enum prestera_cmd_type_t type,
 710                             struct prestera_msg_cmd *cmd, size_t clen,
 711                             struct prestera_msg_ret *ret, size_t rlen)
 712 {
 713         return __prestera_cmd_ret(sw, type, cmd, clen, ret, rlen, 0);
 714 }
 715
 716 static int prestera_cmd_ret_wait(struct prestera_switch *sw,
 717                                  enum prestera_cmd_type_t type,
 718                                  struct prestera_msg_cmd *cmd, size_t clen,
 719                                  struct prestera_msg_ret *ret, size_t rlen,
 720                                  int waitms)
 721 {
 722         return __prestera_cmd_ret(sw, type, cmd, clen, ret, rlen, waitms);
 723 }
 724
 725 static int prestera_cmd(struct prestera_switch *sw,
 726                         enum prestera_cmd_type_t type,
 727                         struct prestera_msg_cmd *cmd, size_t clen)
 728 {
 729         struct prestera_msg_common_resp resp;
 730
 731         return prestera_cmd_ret(sw, type, cmd, clen, &resp.ret, sizeof(resp));
 732 }
 733
 734 static int prestera_fw_parse_port_evt(void *msg, struct prestera_event *evt)
 735 {
 736         struct prestera_msg_event_port *hw_evt;
 737
 738         hw_evt = (struct prestera_msg_event_port *)msg;
 739
 740         evt->port_evt.port_id = __le32_to_cpu(hw_evt->port_id);
 741
 742         if (evt->id == PRESTERA_PORT_EVENT_MAC_STATE_CHANGED) {
 743                 evt->port_evt.data.mac.oper = hw_evt->param.mac.oper;
 744                 evt->port_evt.data.mac.mode =
 745                         __le32_to_cpu(hw_evt->param.mac.mode);
 746                 evt->port_evt.data.mac.speed =
 747                         __le32_to_cpu(hw_evt->param.mac.speed);
 748                 evt->port_evt.data.mac.duplex = hw_evt->param.mac.duplex;
 749                 evt->port_evt.data.mac.fc = hw_evt->param.mac.fc;
 750                 evt->port_evt.data.mac.fec = hw_evt->param.mac.fec;
 751         } else {
 752                 return -EINVAL;
 753         }
 754
 755         return 0;
 756 }
 757
 758 static int prestera_fw_parse_fdb_evt(void *msg, struct prestera_event *evt)
 759 {
 760         struct prestera_msg_event_fdb *hw_evt = msg;
 761
 762         switch (hw_evt->dest_type) {
 763         case PRESTERA_HW_FDB_ENTRY_TYPE_REG_PORT:
 764                 evt->fdb_evt.type = PRESTERA_FDB_ENTRY_TYPE_REG_PORT;
 765                 evt->fdb_evt.dest.port_id = __le32_to_cpu(hw_evt->dest.port_id);
 766                 break;
 767         case PRESTERA_HW_FDB_ENTRY_TYPE_LAG:
 768                 evt->fdb_evt.type = PRESTERA_FDB_ENTRY_TYPE_LAG;
 769                 evt->fdb_evt.dest.lag_id = __le16_to_cpu(hw_evt->dest.lag_id);
 770                 break;
 771         default:
 772                 return -EINVAL;
 773         }
 774
 775         evt->fdb_evt.vid = __le32_to_cpu(hw_evt->vid);
 776
 777         ether_addr_copy(evt->fdb_evt.data.mac, hw_evt->param.mac);
 778
 779         return 0;
 780 }
 781
 782 static struct prestera_fw_evt_parser {
 783         int (*func)(void *msg, struct prestera_event *evt);
 784 } fw_event_parsers[PRESTERA_EVENT_TYPE_MAX] = {
 785         [PRESTERA_EVENT_TYPE_PORT] = { .func = prestera_fw_parse_port_evt },
 786         [PRESTERA_EVENT_TYPE_FDB] = { .func = prestera_fw_parse_fdb_evt },
 787 };
 788
 789 static struct prestera_fw_event_handler *
 790 __find_event_handler(const struct prestera_switch *sw,
 791                      enum prestera_event_type type)
 792 {
 793         struct prestera_fw_event_handler *eh;
 794
 795         list_for_each_entry_rcu(eh, &sw->event_handlers, list) {
 796                 if (eh->type == type)
 797                         return eh;
 798         }
 799
 800         return NULL;
 801 }
 802
 803 static int prestera_find_event_handler(const struct prestera_switch *sw,
 804                                        enum prestera_event_type type,
 805                                        struct prestera_fw_event_handler *eh)
 806 {
 807         struct prestera_fw_event_handler *tmp;
 808         int err = 0;
 809
 810         rcu_read_lock();
 811         tmp = __find_event_handler(sw, type);
 812         if (tmp)
 813                 *eh = *tmp;
 814         else
 815                 err = -ENOENT;
 816         rcu_read_unlock();
 817
 818         return err;
 819 }
 820
 821 static int prestera_evt_recv(struct prestera_device *dev, void *buf, size_t size)
 822 {
 823         struct prestera_switch *sw = dev->priv;
 824         struct prestera_msg_event *msg = buf;
 825         struct prestera_fw_event_handler eh;
 826         struct prestera_event evt;
 827         u16 msg_type;
 828         int err;
 829
 830         msg_type = __le16_to_cpu(msg->type);
 831         if (msg_type >= PRESTERA_EVENT_TYPE_MAX)
 832                 return -EINVAL;
 833         if (!fw_event_parsers[msg_type].func)
 834                 return -ENOENT;
 835
 836         err = prestera_find_event_handler(sw, msg_type, &eh);
 837         if (err)
 838                 return err;
 839
 840         evt.id = __le16_to_cpu(msg->id);
 841
 842         err = fw_event_parsers[msg_type].func(buf, &evt);
 843         if (err)
 844                 return err;
 845
 846         eh.func(sw, &evt, eh.arg);
 847
 848         return 0;
 849 }
 850
 851 static void prestera_pkt_recv(struct prestera_device *dev)
 852 {
 853         struct prestera_switch *sw = dev->priv;
 854         struct prestera_fw_event_handler eh;
 855         struct prestera_event ev;
 856         int err;
 857
 858         ev.id = PRESTERA_RXTX_EVENT_RCV_PKT;
 859
 860         err = prestera_find_event_handler(sw, PRESTERA_EVENT_TYPE_RXTX, &eh);
 861         if (err)
 862                 return;
 863
 864         eh.func(sw, &ev, eh.arg);
 865 }
 866
 867 static u8 prestera_hw_mdix_to_eth(u8 mode)
 868 {
 869         switch (mode) {
 870         case PRESTERA_PORT_TP_MDI:
 871                 return ETH_TP_MDI;
 872         case PRESTERA_PORT_TP_MDIX:
 873                 return ETH_TP_MDI_X;
 874         case PRESTERA_PORT_TP_AUTO:
 875                 return ETH_TP_MDI_AUTO;
 876         default:
 877                 return ETH_TP_MDI_INVALID;
 878         }
 879 }
 880
 881 static u8 prestera_hw_mdix_from_eth(u8 mode)
 882 {
 883         switch (mode) {
 884         case ETH_TP_MDI:
 885                 return PRESTERA_PORT_TP_MDI;
 886         case ETH_TP_MDI_X:
 887                 return PRESTERA_PORT_TP_MDIX;
 888         case ETH_TP_MDI_AUTO:
 889                 return PRESTERA_PORT_TP_AUTO;
 890         default:
 891                 return PRESTERA_PORT_TP_NA;
 892         }
 893 }
 894
 895 int prestera_hw_port_info_get(const struct prestera_port *port,
 896                               u32 *dev_id, u32 *hw_id, u16 *fp_id)
 897 {
 898         struct prestera_msg_port_info_req req = {
 899                 .port = __cpu_to_le32(port->id),
 900         };
 901         struct prestera_msg_port_info_resp resp;
 902         int err;
 903
 904         err = prestera_cmd_ret(port->sw, PRESTERA_CMD_TYPE_PORT_INFO_GET,
 905                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
 906         if (err)
 907                 return err;
 908
 909         *dev_id = __le32_to_cpu(resp.dev_id);
 910         *hw_id = __le32_to_cpu(resp.hw_id);
 911         *fp_id = __le16_to_cpu(resp.fp_id);
 912
 913         return 0;
 914 }
 915
 916 int prestera_hw_switch_mac_set(struct prestera_switch *sw, const char *mac)
 917 {
 918         struct prestera_msg_switch_attr_req req = {
 919                 .attr = __cpu_to_le32(PRESTERA_CMD_SWITCH_ATTR_MAC),
 920         };
 921
 922         ether_addr_copy(req.param.mac, mac);
 923
 924         return prestera_cmd(sw, PRESTERA_CMD_TYPE_SWITCH_ATTR_SET,
 925                             &req.cmd, sizeof(req));
 926 }
 927
 928 int prestera_hw_switch_init(struct prestera_switch *sw)
 929 {
 930         struct prestera_msg_switch_init_resp resp;
 931         struct prestera_msg_common_req req;
 932         int err;
 933
 934         INIT_LIST_HEAD(&sw->event_handlers);
 935
 936         prestera_hw_build_tests();
 937
 938         err = prestera_cmd_ret_wait(sw, PRESTERA_CMD_TYPE_SWITCH_INIT,
 939                                     &req.cmd, sizeof(req),
 940                                     &resp.ret, sizeof(resp),
 941                                     PRESTERA_SWITCH_INIT_TIMEOUT_MS);
 942         if (err)
 943                 return err;
 944
 945         sw->dev->recv_msg = prestera_evt_recv;
 946         sw->dev->recv_pkt = prestera_pkt_recv;
 947         sw->port_count = __le32_to_cpu(resp.port_count);
 948         sw->mtu_min = PRESTERA_MIN_MTU;
 949         sw->mtu_max = __le32_to_cpu(resp.mtu_max);
 950         sw->id = resp.switch_id;
 951         sw->lag_member_max = resp.lag_member_max;
 952         sw->lag_max = resp.lag_max;
 953
 954         return 0;
 955 }
 956
 957 void prestera_hw_switch_fini(struct prestera_switch *sw)
 958 {
 959         WARN_ON(!list_empty(&sw->event_handlers));
 960 }
 961
 962 int prestera_hw_switch_ageing_set(struct prestera_switch *sw, u32 ageing_ms)
 963 {
 964         struct prestera_msg_switch_attr_req req = {
 965                 .attr = __cpu_to_le32(PRESTERA_CMD_SWITCH_ATTR_AGEING),
 966                 .param = {
 967                         .ageing_timeout_ms = __cpu_to_le32(ageing_ms),
 968                 },
 969         };
 970
 971         return prestera_cmd(sw, PRESTERA_CMD_TYPE_SWITCH_ATTR_SET,
 972                             &req.cmd, sizeof(req));
 973 }
 974
 975 int prestera_hw_port_mac_mode_get(const struct prestera_port *port,
 976                                   u32 *mode, u32 *speed, u8 *duplex, u8 *fec)
 977 {
 978         struct prestera_msg_port_attr_resp resp;
 979         struct prestera_msg_port_attr_req req = {
 980                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_MAC_MODE),
 981                 .port = __cpu_to_le32(port->hw_id),
 982                 .dev = __cpu_to_le32(port->dev_id)
 983         };
 984         int err;
 985
 986         err = prestera_cmd_ret(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_GET,
 987                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
 988         if (err)
 989                 return err;
 990
 991         if (mode)
 992                 *mode = __le32_to_cpu(resp.param.link_evt.mac.mode);
 993
 994         if (speed)
 995                 *speed = __le32_to_cpu(resp.param.link_evt.mac.speed);
 996
 997         if (duplex)
 998                 *duplex = resp.param.link_evt.mac.duplex;
 999
1000         if (fec)
1001                 *fec = resp.param.link_evt.mac.fec;
1002
1003         return err;
1004 }
1005
1006 int prestera_hw_port_mac_mode_set(const struct prestera_port *port,
1007                                   bool admin, u32 mode, u8 inband,
1008                                   u32 speed, u8 duplex, u8 fec)
1009 {
1010         struct prestera_msg_port_attr_req req = {
1011                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_MAC_MODE),
1012                 .port = __cpu_to_le32(port->hw_id),
1013                 .dev = __cpu_to_le32(port->dev_id),
1014                 .param = {
1015                         .link = {
1016                                 .mac = {
1017                                         .admin = admin,
1018                                         .reg_mode.mode = __cpu_to_le32(mode),
1019                                         .reg_mode.inband = inband,
1020                                         .reg_mode.speed = __cpu_to_le32(speed),
1021                                         .reg_mode.duplex = duplex,
1022                                         .reg_mode.fec = fec
1023                                 }
1024                         }
1025                 }
1026         };
1027
1028         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_SET,
1029                             &req.cmd, sizeof(req));
1030 }
1031
1032 int prestera_hw_port_phy_mode_get(const struct prestera_port *port,
1033                                   u8 *mdix, u64 *lmode_bmap,
1034                                   bool *fc_pause, bool *fc_asym)
1035 {
1036         struct prestera_msg_port_attr_resp resp;
1037         struct prestera_msg_port_attr_req req = {
1038                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_PHY_MODE),
1039                 .port = __cpu_to_le32(port->hw_id),
1040                 .dev = __cpu_to_le32(port->dev_id)
1041         };
1042         int err;
1043
1044         err = prestera_cmd_ret(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_GET,
1045                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
1046         if (err)
1047                 return err;
1048
1049         if (mdix)
1050                 *mdix = prestera_hw_mdix_to_eth(resp.param.link_evt.phy.mdix);
1051
1052         if (lmode_bmap)
1053                 *lmode_bmap = __le64_to_cpu(resp.param.link_evt.phy.lmode_bmap);
1054
1055         if (fc_pause && fc_asym)
1056                 prestera_hw_remote_fc_to_eth(resp.param.link_evt.phy.fc,
1057                                              fc_pause, fc_asym);
1058
1059         return err;
1060 }
1061
1062 int prestera_hw_port_phy_mode_set(const struct prestera_port *port,
1063                                   bool admin, bool adv, u32 mode, u64 modes,
1064                                   u8 mdix)
1065 {
1066         struct prestera_msg_port_attr_req req = {
1067                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_PHY_MODE),
1068                 .port = __cpu_to_le32(port->hw_id),
1069                 .dev = __cpu_to_le32(port->dev_id),
1070                 .param = {
1071                         .link = {
1072                                 .phy = {
1073                                         .admin = admin,
1074                                         .adv_enable = adv ? 1 : 0,
1075                                         .mode = __cpu_to_le32(mode),
1076                                         .modes = __cpu_to_le64(modes),
1077                                 }
1078                         }
1079                 }
1080         };
1081
1082         req.param.link.phy.mdix = prestera_hw_mdix_from_eth(mdix);
1083
1084         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_SET,
1085                             &req.cmd, sizeof(req));
1086 }
1087
1088 int prestera_hw_port_mtu_set(const struct prestera_port *port, u32 mtu)
1089 {
1090         struct prestera_msg_port_attr_req req = {
1091                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_MTU),
1092                 .port = __cpu_to_le32(port->hw_id),
1093                 .dev = __cpu_to_le32(port->dev_id),
1094                 .param = {
1095                         .mtu = __cpu_to_le32(mtu),
1096                 }
1097         };
1098
1099         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_SET,
1100                             &req.cmd, sizeof(req));
1101 }
1102
1103 int prestera_hw_port_mac_set(const struct prestera_port *port, const char *mac)
1104 {
1105         struct prestera_msg_port_attr_req req = {
1106                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_MAC),
1107                 .port = __cpu_to_le32(port->hw_id),
1108                 .dev = __cpu_to_le32(port->dev_id),
1109         };
1110
1111         ether_addr_copy(req.param.mac, mac);
1112
1113         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_SET,
1114                             &req.cmd, sizeof(req));
1115 }
1116
1117 int prestera_hw_port_accept_frm_type(struct prestera_port *port,
1118                                      enum prestera_accept_frm_type type)
1119 {
1120         struct prestera_msg_port_attr_req req = {
1121                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_ACCEPT_FRAME_TYPE),
1122                 .port = __cpu_to_le32(port->hw_id),
1123                 .dev = __cpu_to_le32(port->dev_id),
1124                 .param = {
1125                         .accept_frm_type = type,
1126                 }
1127         };
1128
1129         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_SET,
1130                             &req.cmd, sizeof(req));
1131 }
1132
1133 int prestera_hw_port_cap_get(const struct prestera_port *port,
1134                              struct prestera_port_caps *caps)
1135 {
1136         struct prestera_msg_port_attr_req req = {
1137                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_CAPABILITY),
1138                 .port = __cpu_to_le32(port->hw_id),
1139                 .dev = __cpu_to_le32(port->dev_id),
1140         };
1141         struct prestera_msg_port_attr_resp resp;
1142         int err;
1143
1144         err = prestera_cmd_ret(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_GET,
1145                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
1146         if (err)
1147                 return err;
1148
1149         caps->supp_link_modes = __le64_to_cpu(resp.param.cap.link_mode);
1150         caps->transceiver = resp.param.cap.transceiver;
1151         caps->supp_fec = resp.param.cap.fec;
1152         caps->type = resp.param.cap.type;
1153
1154         return err;
1155 }
1156
1157 static void prestera_hw_remote_fc_to_eth(u8 fc, bool *pause, bool *asym_pause)
1158 {
1159         switch (fc) {
1160         case PRESTERA_FC_SYMMETRIC:
1161                 *pause = true;
1162                 *asym_pause = false;
1163                 break;
1164         case PRESTERA_FC_ASYMMETRIC:
1165                 *pause = false;
1166                 *asym_pause = true;
1167                 break;
1168         case PRESTERA_FC_SYMM_ASYMM:
1169                 *pause = true;
1170                 *asym_pause = true;
1171                 break;
1172         default:
1173                 *pause = false;
1174                 *asym_pause = false;
1175         }
1176 }
1177
1178 int prestera_hw_vtcam_create(struct prestera_switch *sw,
1179                              u8 lookup, const u32 *keymask, u32 *vtcam_id,
1180                              enum prestera_hw_vtcam_direction_t dir)
1181 {
1182         int err;
1183         struct prestera_msg_vtcam_resp resp;
1184         struct prestera_msg_vtcam_create_req req = {
1185                 .lookup = lookup,
1186                 .direction = dir,
1187         };
1188
1189         if (keymask)
1190                 memcpy(req.keymask, keymask, sizeof(req.keymask));
1191         else
1192                 memset(req.keymask, 0, sizeof(req.keymask));
1193
1194         err = prestera_cmd_ret(sw, PRESTERA_CMD_TYPE_VTCAM_CREATE,
1195                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
1196         if (err)
1197                 return err;
1198
1199         *vtcam_id = __le32_to_cpu(resp.vtcam_id);
1200         return 0;
1201 }
1202
1203 int prestera_hw_vtcam_destroy(struct prestera_switch *sw, u32 vtcam_id)
1204 {
1205         struct prestera_msg_vtcam_destroy_req req = {
1206                 .vtcam_id = __cpu_to_le32(vtcam_id),
1207         };
1208
1209         return prestera_cmd(sw, PRESTERA_CMD_TYPE_VTCAM_DESTROY,
1210                             &req.cmd, sizeof(req));
1211 }
1212
1213 static int
1214 prestera_acl_rule_add_put_action(struct prestera_msg_acl_action *action,
1215                                  struct prestera_acl_hw_action_info *info)
1216 {
1217         action->id = __cpu_to_le32(info->id);
1218
1219         switch (info->id) {
1220         case PRESTERA_ACL_RULE_ACTION_ACCEPT:
1221         case PRESTERA_ACL_RULE_ACTION_DROP:
1222         case PRESTERA_ACL_RULE_ACTION_TRAP:
1223                 /* just rule action id, no specific data */
1224                 break;
1225         case PRESTERA_ACL_RULE_ACTION_JUMP:
1226                 action->jump.index = __cpu_to_le32(info->jump.index);
1227                 break;
1228         case PRESTERA_ACL_RULE_ACTION_POLICE:
1229                 action->police.id = __cpu_to_le32(info->police.id);
1230                 break;
1231         case PRESTERA_ACL_RULE_ACTION_COUNT:
1232                 action->count.id = __cpu_to_le32(info->count.id);
1233                 break;
1234         default:
1235                 return -EINVAL;
1236         }
1237
1238         return 0;
1239 }
1240
1241 int prestera_hw_vtcam_rule_add(struct prestera_switch *sw,
1242                                u32 vtcam_id, u32 prio, void *key, void *keymask,
1243                                struct prestera_acl_hw_action_info *act,
1244                                u8 n_act, u32 *rule_id)
1245 {
1246         struct prestera_msg_acl_action *actions_msg;
1247         struct prestera_msg_vtcam_rule_add_req *req;
1248         struct prestera_msg_vtcam_resp resp;
1249         void *buff;
1250         u32 size;
1251         int err;
1252         u8 i;
1253
1254         size = sizeof(*req) + sizeof(*actions_msg) * n_act;
1255
1256         buff = kzalloc(size, GFP_KERNEL);
1257         if (!buff)
1258                 return -ENOMEM;
1259
1260         req = buff;
1261         req->n_act = __cpu_to_le32(n_act);
1262         actions_msg = buff + sizeof(*req);
1263
1264         /* put acl matches into the message */
1265         memcpy(req->key, key, sizeof(req->key));
1266         memcpy(req->keymask, keymask, sizeof(req->keymask));
1267
1268         /* put acl actions into the message */
1269         for (i = 0; i < n_act; i++) {
1270                 err = prestera_acl_rule_add_put_action(&actions_msg[i],
1271                                                        &act[i]);
1272                 if (err)
1273                         goto free_buff;
1274         }
1275
1276         req->vtcam_id = __cpu_to_le32(vtcam_id);
1277         req->prio = __cpu_to_le32(prio);
1278
1279         err = prestera_cmd_ret(sw, PRESTERA_CMD_TYPE_VTCAM_RULE_ADD,
1280                                &req->cmd, size, &resp.ret, sizeof(resp));
1281         if (err)
1282                 goto free_buff;
1283
1284         *rule_id = __le32_to_cpu(resp.rule_id);
1285 free_buff:
1286         kfree(buff);
1287         return err;
1288 }
1289
1290 int prestera_hw_vtcam_rule_del(struct prestera_switch *sw,
1291                                u32 vtcam_id, u32 rule_id)
1292 {
1293         struct prestera_msg_vtcam_rule_del_req req = {
1294                 .vtcam_id = __cpu_to_le32(vtcam_id),
1295                 .id = __cpu_to_le32(rule_id)
1296         };
1297
1298         return prestera_cmd(sw, PRESTERA_CMD_TYPE_VTCAM_RULE_DELETE,
1299                             &req.cmd, sizeof(req));
1300 }
1301
1302 int prestera_hw_vtcam_iface_bind(struct prestera_switch *sw,
1303                                  struct prestera_acl_iface *iface,
1304                                  u32 vtcam_id, u16 pcl_id)
1305 {
1306         struct prestera_msg_vtcam_bind_req req = {
1307                 .vtcam_id = __cpu_to_le32(vtcam_id),
1308                 .type = __cpu_to_le16(iface->type),
1309                 .pcl_id = __cpu_to_le16(pcl_id)
1310         };
1311
1312         if (iface->type == PRESTERA_ACL_IFACE_TYPE_PORT) {
1313                 req.port.dev_id = __cpu_to_le32(iface->port->dev_id);
1314                 req.port.hw_id = __cpu_to_le32(iface->port->hw_id);
1315         } else {
1316                 req.index = __cpu_to_le32(iface->index);
1317         }
1318
1319         return prestera_cmd(sw, PRESTERA_CMD_TYPE_VTCAM_IFACE_BIND,
1320                             &req.cmd, sizeof(req));
1321 }
1322
1323 int prestera_hw_vtcam_iface_unbind(struct prestera_switch *sw,
1324                                    struct prestera_acl_iface *iface,
1325                                    u32 vtcam_id)
1326 {
1327         struct prestera_msg_vtcam_bind_req req = {
1328                 .vtcam_id = __cpu_to_le32(vtcam_id),
1329                 .type = __cpu_to_le16(iface->type)
1330         };
1331
1332         if (iface->type == PRESTERA_ACL_IFACE_TYPE_PORT) {
1333                 req.port.dev_id = __cpu_to_le32(iface->port->dev_id);
1334                 req.port.hw_id = __cpu_to_le32(iface->port->hw_id);
1335         } else {
1336                 req.index = __cpu_to_le32(iface->index);
1337         }
1338
1339         return prestera_cmd(sw, PRESTERA_CMD_TYPE_VTCAM_IFACE_UNBIND,
1340                             &req.cmd, sizeof(req));
1341 }
1342
1343 int prestera_hw_span_get(const struct prestera_port *port, u8 *span_id)
1344 {
1345         struct prestera_msg_span_resp resp;
1346         struct prestera_msg_span_req req = {
1347                 .port = __cpu_to_le32(port->hw_id),
1348                 .dev = __cpu_to_le32(port->dev_id),
1349         };
1350         int err;
1351
1352         err = prestera_cmd_ret(port->sw, PRESTERA_CMD_TYPE_SPAN_GET,
1353                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
1354         if (err)
1355                 return err;
1356
1357         *span_id = resp.id;
1358
1359         return 0;
1360 }
1361
1362 int prestera_hw_span_bind(const struct prestera_port *port, u8 span_id)
1363 {
1364         struct prestera_msg_span_req req = {
1365                 .port = __cpu_to_le32(port->hw_id),
1366                 .dev = __cpu_to_le32(port->dev_id),
1367                 .id = span_id,
1368         };
1369
1370         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_SPAN_BIND,
1371                             &req.cmd, sizeof(req));
1372 }
1373
1374 int prestera_hw_span_unbind(const struct prestera_port *port)
1375 {
1376         struct prestera_msg_span_req req = {
1377                 .port = __cpu_to_le32(port->hw_id),
1378                 .dev = __cpu_to_le32(port->dev_id),
1379         };
1380
1381         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_SPAN_UNBIND,
1382                             &req.cmd, sizeof(req));
1383 }
1384
1385 int prestera_hw_span_release(struct prestera_switch *sw, u8 span_id)
1386 {
1387         struct prestera_msg_span_req req = {
1388                 .id = span_id
1389         };
1390
1391         return prestera_cmd(sw, PRESTERA_CMD_TYPE_SPAN_RELEASE,
1392                             &req.cmd, sizeof(req));
1393 }
1394
1395 int prestera_hw_port_type_get(const struct prestera_port *port, u8 *type)
1396 {
1397         struct prestera_msg_port_attr_req req = {
1398                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_TYPE),
1399                 .port = __cpu_to_le32(port->hw_id),
1400                 .dev = __cpu_to_le32(port->dev_id),
1401         };
1402         struct prestera_msg_port_attr_resp resp;
1403         int err;
1404
1405         err = prestera_cmd_ret(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_GET,
1406                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
1407         if (err)
1408                 return err;
1409
1410         *type = resp.param.type;
1411
1412         return 0;
1413 }
1414
1415 int prestera_hw_port_speed_get(const struct prestera_port *port, u32 *speed)
1416 {
1417         struct prestera_msg_port_attr_req req = {
1418                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_SPEED),
1419                 .port = __cpu_to_le32(port->hw_id),
1420                 .dev = __cpu_to_le32(port->dev_id),
1421         };
1422         struct prestera_msg_port_attr_resp resp;
1423         int err;
1424
1425         err = prestera_cmd_ret(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_GET,
1426                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
1427         if (err)
1428                 return err;
1429
1430         *speed = __le32_to_cpu(resp.param.speed);
1431
1432         return 0;
1433 }
1434
1435 int prestera_hw_port_autoneg_restart(struct prestera_port *port)
1436 {
1437         struct prestera_msg_port_attr_req req = {
1438                 .attr =
1439                     __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_PHY_AUTONEG_RESTART),
1440                 .port = __cpu_to_le32(port->hw_id),
1441                 .dev = __cpu_to_le32(port->dev_id),
1442         };
1443
1444         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_SET,
1445                             &req.cmd, sizeof(req));
1446 }
1447
1448 int prestera_hw_port_stats_get(const struct prestera_port *port,
1449                                struct prestera_port_stats *st)
1450 {
1451         struct prestera_msg_port_attr_req req = {
1452                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_STATS),
1453                 .port = __cpu_to_le32(port->hw_id),
1454                 .dev = __cpu_to_le32(port->dev_id),
1455         };
1456         struct prestera_msg_port_stats_resp resp;
1457         __le64 *hw = resp.stats;
1458         int err;
1459
1460         err = prestera_cmd_ret(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_GET,
1461                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
1462         if (err)
1463                 return err;
1464
1465         st->good_octets_received =
1466                 __le64_to_cpu(hw[PRESTERA_PORT_GOOD_OCTETS_RCV_CNT]);
1467         st->bad_octets_received =
1468                 __le64_to_cpu(hw[PRESTERA_PORT_BAD_OCTETS_RCV_CNT]);
1469         st->mac_trans_error =
1470                 __le64_to_cpu(hw[PRESTERA_PORT_MAC_TRANSMIT_ERR_CNT]);
1471         st->broadcast_frames_received =
1472                 __le64_to_cpu(hw[PRESTERA_PORT_BRDC_PKTS_RCV_CNT]);
1473         st->multicast_frames_received =
1474                 __le64_to_cpu(hw[PRESTERA_PORT_MC_PKTS_RCV_CNT]);
1475         st->frames_64_octets = __le64_to_cpu(hw[PRESTERA_PORT_PKTS_64L_CNT]);
1476         st->frames_65_to_127_octets =
1477                 __le64_to_cpu(hw[PRESTERA_PORT_PKTS_65TO127L_CNT]);
1478         st->frames_128_to_255_octets =
1479                 __le64_to_cpu(hw[PRESTERA_PORT_PKTS_128TO255L_CNT]);
1480         st->frames_256_to_511_octets =
1481                 __le64_to_cpu(hw[PRESTERA_PORT_PKTS_256TO511L_CNT]);
1482         st->frames_512_to_1023_octets =
1483                 __le64_to_cpu(hw[PRESTERA_PORT_PKTS_512TO1023L_CNT]);
1484         st->frames_1024_to_max_octets =
1485                 __le64_to_cpu(hw[PRESTERA_PORT_PKTS_1024TOMAXL_CNT]);
1486         st->excessive_collision =
1487                 __le64_to_cpu(hw[PRESTERA_PORT_EXCESSIVE_COLLISIONS_CNT]);
1488         st->multicast_frames_sent =
1489                 __le64_to_cpu(hw[PRESTERA_PORT_MC_PKTS_SENT_CNT]);
1490         st->broadcast_frames_sent =
1491                 __le64_to_cpu(hw[PRESTERA_PORT_BRDC_PKTS_SENT_CNT]);
1492         st->fc_sent = __le64_to_cpu(hw[PRESTERA_PORT_FC_SENT_CNT]);
1493         st->fc_received = __le64_to_cpu(hw[PRESTERA_PORT_GOOD_FC_RCV_CNT]);
1494         st->buffer_overrun = __le64_to_cpu(hw[PRESTERA_PORT_DROP_EVENTS_CNT]);
1495         st->undersize = __le64_to_cpu(hw[PRESTERA_PORT_UNDERSIZE_PKTS_CNT]);
1496         st->fragments = __le64_to_cpu(hw[PRESTERA_PORT_FRAGMENTS_PKTS_CNT]);
1497         st->oversize = __le64_to_cpu(hw[PRESTERA_PORT_OVERSIZE_PKTS_CNT]);
1498         st->jabber = __le64_to_cpu(hw[PRESTERA_PORT_JABBER_PKTS_CNT]);
1499         st->rx_error_frame_received =
1500                 __le64_to_cpu(hw[PRESTERA_PORT_MAC_RCV_ERROR_CNT]);
1501         st->bad_crc = __le64_to_cpu(hw[PRESTERA_PORT_BAD_CRC_CNT]);
1502         st->collisions = __le64_to_cpu(hw[PRESTERA_PORT_COLLISIONS_CNT]);
1503         st->late_collision =
1504                 __le64_to_cpu(hw[PRESTERA_PORT_LATE_COLLISIONS_CNT]);
1505         st->unicast_frames_received =
1506                 __le64_to_cpu(hw[PRESTERA_PORT_GOOD_UC_PKTS_RCV_CNT]);
1507         st->unicast_frames_sent =
1508                 __le64_to_cpu(hw[PRESTERA_PORT_GOOD_UC_PKTS_SENT_CNT]);
1509         st->sent_multiple =
1510                 __le64_to_cpu(hw[PRESTERA_PORT_MULTIPLE_PKTS_SENT_CNT]);
1511         st->sent_deferred =
1512                 __le64_to_cpu(hw[PRESTERA_PORT_DEFERRED_PKTS_SENT_CNT]);
1513         st->good_octets_sent =
1514                 __le64_to_cpu(hw[PRESTERA_PORT_GOOD_OCTETS_SENT_CNT]);
1515
1516         return 0;
1517 }
1518
1519 int prestera_hw_port_learning_set(struct prestera_port *port, bool enable)
1520 {
1521         struct prestera_msg_port_attr_req req = {
1522                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_LEARNING),
1523                 .port = __cpu_to_le32(port->hw_id),
1524                 .dev = __cpu_to_le32(port->dev_id),
1525                 .param = {
1526                         .learning = enable,
1527                 }
1528         };
1529
1530         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_SET,
1531                             &req.cmd, sizeof(req));
1532 }
1533
1534 static int prestera_hw_port_uc_flood_set(struct prestera_port *port, bool flood)
1535 {
1536         struct prestera_msg_port_attr_req req = {
1537                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_FLOOD),
1538                 .port = __cpu_to_le32(port->hw_id),
1539                 .dev = __cpu_to_le32(port->dev_id),
1540                 .param = {
1541                         .flood_ext = {
1542                                 .type = PRESTERA_PORT_FLOOD_TYPE_UC,
1543                                 .enable = flood,
1544                         }
1545                 }
1546         };
1547
1548         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_SET,
1549                             &req.cmd, sizeof(req));
1550 }
1551
1552 static int prestera_hw_port_mc_flood_set(struct prestera_port *port, bool flood)
1553 {
1554         struct prestera_msg_port_attr_req req = {
1555                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_FLOOD),
1556                 .port = __cpu_to_le32(port->hw_id),
1557                 .dev = __cpu_to_le32(port->dev_id),
1558                 .param = {
1559                         .flood_ext = {
1560                                 .type = PRESTERA_PORT_FLOOD_TYPE_MC,
1561                                 .enable = flood,
1562                         }
1563                 }
1564         };
1565
1566         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_SET,
1567                             &req.cmd, sizeof(req));
1568 }
1569
1570 static int prestera_hw_port_flood_set_v2(struct prestera_port *port, bool flood)
1571 {
1572         struct prestera_msg_port_attr_req req = {
1573                 .attr = __cpu_to_le32(PRESTERA_CMD_PORT_ATTR_FLOOD),
1574                 .port = __cpu_to_le32(port->hw_id),
1575                 .dev = __cpu_to_le32(port->dev_id),
1576                 .param = {
1577                         .flood = flood,
1578                 }
1579         };
1580
1581         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_PORT_ATTR_SET,
1582                             &req.cmd, sizeof(req));
1583 }
1584
1585 int prestera_hw_port_flood_set(struct prestera_port *port, unsigned long mask,
1586                                unsigned long val)
1587 {
1588         int err;
1589
1590         if (port->sw->dev->fw_rev.maj <= 2) {
1591                 if (!(mask & BR_FLOOD))
1592                         return 0;
1593
1594                 return prestera_hw_port_flood_set_v2(port, val & BR_FLOOD);
1595         }
1596
1597         if (mask & BR_FLOOD) {
1598                 err = prestera_hw_port_uc_flood_set(port, val & BR_FLOOD);
1599                 if (err)
1600                         goto err_uc_flood;
1601         }
1602
1603         if (mask & BR_MCAST_FLOOD) {
1604                 err = prestera_hw_port_mc_flood_set(port, val & BR_MCAST_FLOOD);
1605                 if (err)
1606                         goto err_mc_flood;
1607         }
1608
1609         return 0;
1610
1611 err_mc_flood:
1612         prestera_hw_port_mc_flood_set(port, 0);
1613 err_uc_flood:
1614         if (mask & BR_FLOOD)
1615                 prestera_hw_port_uc_flood_set(port, 0);
1616
1617         return err;
1618 }
1619
1620 int prestera_hw_vlan_create(struct prestera_switch *sw, u16 vid)
1621 {
1622         struct prestera_msg_vlan_req req = {
1623                 .vid = __cpu_to_le16(vid),
1624         };
1625
1626         return prestera_cmd(sw, PRESTERA_CMD_TYPE_VLAN_CREATE,
1627                             &req.cmd, sizeof(req));
1628 }
1629
1630 int prestera_hw_vlan_delete(struct prestera_switch *sw, u16 vid)
1631 {
1632         struct prestera_msg_vlan_req req = {
1633                 .vid = __cpu_to_le16(vid),
1634         };
1635
1636         return prestera_cmd(sw, PRESTERA_CMD_TYPE_VLAN_DELETE,
1637                             &req.cmd, sizeof(req));
1638 }
1639
1640 int prestera_hw_vlan_port_set(struct prestera_port *port, u16 vid,
1641                               bool is_member, bool untagged)
1642 {
1643         struct prestera_msg_vlan_req req = {
1644                 .port = __cpu_to_le32(port->hw_id),
1645                 .dev = __cpu_to_le32(port->dev_id),
1646                 .vid = __cpu_to_le16(vid),
1647                 .is_member = is_member,
1648                 .is_tagged = !untagged,
1649         };
1650
1651         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_VLAN_PORT_SET,
1652                             &req.cmd, sizeof(req));
1653 }
1654
1655 int prestera_hw_vlan_port_vid_set(struct prestera_port *port, u16 vid)
1656 {
1657         struct prestera_msg_vlan_req req = {
1658                 .port = __cpu_to_le32(port->hw_id),
1659                 .dev = __cpu_to_le32(port->dev_id),
1660                 .vid = __cpu_to_le16(vid),
1661         };
1662
1663         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_VLAN_PVID_SET,
1664                             &req.cmd, sizeof(req));
1665 }
1666
1667 int prestera_hw_vlan_port_stp_set(struct prestera_port *port, u16 vid, u8 state)
1668 {
1669         struct prestera_msg_stp_req req = {
1670                 .port = __cpu_to_le32(port->hw_id),
1671                 .dev = __cpu_to_le32(port->dev_id),
1672                 .vid = __cpu_to_le16(vid),
1673                 .state = state,
1674         };
1675
1676         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_STP_PORT_SET,
1677                             &req.cmd, sizeof(req));
1678 }
1679
1680 int prestera_hw_fdb_add(struct prestera_port *port, const unsigned char *mac,
1681                         u16 vid, bool dynamic)
1682 {
1683         struct prestera_msg_fdb_req req = {
1684                 .dest = {
1685                         .dev = __cpu_to_le32(port->dev_id),
1686                         .port = __cpu_to_le32(port->hw_id),
1687                 },
1688                 .vid = __cpu_to_le16(vid),
1689                 .dynamic = dynamic,
1690         };
1691
1692         ether_addr_copy(req.mac, mac);
1693
1694         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_FDB_ADD,
1695                             &req.cmd, sizeof(req));
1696 }
1697
1698 int prestera_hw_fdb_del(struct prestera_port *port, const unsigned char *mac,
1699                         u16 vid)
1700 {
1701         struct prestera_msg_fdb_req req = {
1702                 .dest = {
1703                         .dev = __cpu_to_le32(port->dev_id),
1704                         .port = __cpu_to_le32(port->hw_id),
1705                 },
1706                 .vid = __cpu_to_le16(vid),
1707         };
1708
1709         ether_addr_copy(req.mac, mac);
1710
1711         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_FDB_DELETE,
1712                             &req.cmd, sizeof(req));
1713 }
1714
1715 int prestera_hw_lag_fdb_add(struct prestera_switch *sw, u16 lag_id,
1716                             const unsigned char *mac, u16 vid, bool dynamic)
1717 {
1718         struct prestera_msg_fdb_req req = {
1719                 .dest_type = PRESTERA_HW_FDB_ENTRY_TYPE_LAG,
1720                 .dest = {
1721                         .lag_id = __cpu_to_le16(lag_id),
1722                 },
1723                 .vid = __cpu_to_le16(vid),
1724                 .dynamic = dynamic,
1725         };
1726
1727         ether_addr_copy(req.mac, mac);
1728
1729         return prestera_cmd(sw, PRESTERA_CMD_TYPE_FDB_ADD,
1730                             &req.cmd, sizeof(req));
1731 }
1732
1733 int prestera_hw_lag_fdb_del(struct prestera_switch *sw, u16 lag_id,
1734                             const unsigned char *mac, u16 vid)
1735 {
1736         struct prestera_msg_fdb_req req = {
1737                 .dest_type = PRESTERA_HW_FDB_ENTRY_TYPE_LAG,
1738                 .dest = {
1739                         .lag_id = __cpu_to_le16(lag_id),
1740                 },
1741                 .vid = __cpu_to_le16(vid),
1742         };
1743
1744         ether_addr_copy(req.mac, mac);
1745
1746         return prestera_cmd(sw, PRESTERA_CMD_TYPE_FDB_DELETE,
1747                             &req.cmd, sizeof(req));
1748 }
1749
1750 int prestera_hw_fdb_flush_port(struct prestera_port *port, u32 mode)
1751 {
1752         struct prestera_msg_fdb_req req = {
1753                 .dest = {
1754                         .dev = __cpu_to_le32(port->dev_id),
1755                         .port = __cpu_to_le32(port->hw_id),
1756                 },
1757                 .flush_mode = __cpu_to_le32(mode),
1758         };
1759
1760         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_FDB_FLUSH_PORT,
1761                             &req.cmd, sizeof(req));
1762 }
1763
1764 int prestera_hw_fdb_flush_vlan(struct prestera_switch *sw, u16 vid, u32 mode)
1765 {
1766         struct prestera_msg_fdb_req req = {
1767                 .vid = __cpu_to_le16(vid),
1768                 .flush_mode = __cpu_to_le32(mode),
1769         };
1770
1771         return prestera_cmd(sw, PRESTERA_CMD_TYPE_FDB_FLUSH_VLAN,
1772                             &req.cmd, sizeof(req));
1773 }
1774
1775 int prestera_hw_fdb_flush_port_vlan(struct prestera_port *port, u16 vid,
1776                                     u32 mode)
1777 {
1778         struct prestera_msg_fdb_req req = {
1779                 .dest = {
1780                         .dev = __cpu_to_le32(port->dev_id),
1781                         .port = __cpu_to_le32(port->hw_id),
1782                 },
1783                 .vid = __cpu_to_le16(vid),
1784                 .flush_mode = __cpu_to_le32(mode),
1785         };
1786
1787         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_FDB_FLUSH_PORT_VLAN,
1788                             &req.cmd, sizeof(req));
1789 }
1790
1791 int prestera_hw_fdb_flush_lag(struct prestera_switch *sw, u16 lag_id,
1792                               u32 mode)
1793 {
1794         struct prestera_msg_fdb_req req = {
1795                 .dest_type = PRESTERA_HW_FDB_ENTRY_TYPE_LAG,
1796                 .dest = {
1797                         .lag_id = __cpu_to_le16(lag_id),
1798                 },
1799                 .flush_mode = __cpu_to_le32(mode),
1800         };
1801
1802         return prestera_cmd(sw, PRESTERA_CMD_TYPE_FDB_FLUSH_PORT,
1803                             &req.cmd, sizeof(req));
1804 }
1805
1806 int prestera_hw_fdb_flush_lag_vlan(struct prestera_switch *sw,
1807                                    u16 lag_id, u16 vid, u32 mode)
1808 {
1809         struct prestera_msg_fdb_req req = {
1810                 .dest_type = PRESTERA_HW_FDB_ENTRY_TYPE_LAG,
1811                 .dest = {
1812                         .lag_id = __cpu_to_le16(lag_id),
1813                 },
1814                 .vid = __cpu_to_le16(vid),
1815                 .flush_mode = __cpu_to_le32(mode),
1816         };
1817
1818         return prestera_cmd(sw, PRESTERA_CMD_TYPE_FDB_FLUSH_PORT_VLAN,
1819                             &req.cmd, sizeof(req));
1820 }
1821
1822 int prestera_hw_bridge_create(struct prestera_switch *sw, u16 *bridge_id)
1823 {
1824         struct prestera_msg_bridge_resp resp;
1825         struct prestera_msg_bridge_req req;
1826         int err;
1827
1828         err = prestera_cmd_ret(sw, PRESTERA_CMD_TYPE_BRIDGE_CREATE,
1829                                &req.cmd, sizeof(req),
1830                                &resp.ret, sizeof(resp));
1831         if (err)
1832                 return err;
1833
1834         *bridge_id = __le16_to_cpu(resp.bridge);
1835
1836         return 0;
1837 }
1838
1839 int prestera_hw_bridge_delete(struct prestera_switch *sw, u16 bridge_id)
1840 {
1841         struct prestera_msg_bridge_req req = {
1842                 .bridge = __cpu_to_le16(bridge_id),
1843         };
1844
1845         return prestera_cmd(sw, PRESTERA_CMD_TYPE_BRIDGE_DELETE,
1846                             &req.cmd, sizeof(req));
1847 }
1848
1849 int prestera_hw_bridge_port_add(struct prestera_port *port, u16 bridge_id)
1850 {
1851         struct prestera_msg_bridge_req req = {
1852                 .bridge = __cpu_to_le16(bridge_id),
1853                 .port = __cpu_to_le32(port->hw_id),
1854                 .dev = __cpu_to_le32(port->dev_id),
1855         };
1856
1857         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_BRIDGE_PORT_ADD,
1858                             &req.cmd, sizeof(req));
1859 }
1860
1861 int prestera_hw_bridge_port_delete(struct prestera_port *port, u16 bridge_id)
1862 {
1863         struct prestera_msg_bridge_req req = {
1864                 .bridge = __cpu_to_le16(bridge_id),
1865                 .port = __cpu_to_le32(port->hw_id),
1866                 .dev = __cpu_to_le32(port->dev_id),
1867         };
1868
1869         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_BRIDGE_PORT_DELETE,
1870                             &req.cmd, sizeof(req));
1871 }
1872
1873 static int prestera_iface_to_msg(struct prestera_iface *iface,
1874                                  struct prestera_msg_iface *msg_if)
1875 {
1876         switch (iface->type) {
1877         case PRESTERA_IF_PORT_E:
1878         case PRESTERA_IF_VID_E:
1879                 msg_if->port = __cpu_to_le32(iface->dev_port.port_num);
1880                 msg_if->dev = __cpu_to_le32(iface->dev_port.hw_dev_num);
1881                 break;
1882         case PRESTERA_IF_LAG_E:
1883                 msg_if->lag_id = __cpu_to_le16(iface->lag_id);
1884                 break;
1885         default:
1886                 return -EOPNOTSUPP;
1887         }
1888
1889         msg_if->vr_id = __cpu_to_le16(iface->vr_id);
1890         msg_if->vid = __cpu_to_le16(iface->vlan_id);
1891         msg_if->type = iface->type;
1892         return 0;
1893 }
1894
1895 int prestera_hw_rif_create(struct prestera_switch *sw,
1896                            struct prestera_iface *iif, u8 *mac, u16 *rif_id)
1897 {
1898         struct prestera_msg_rif_resp resp;
1899         struct prestera_msg_rif_req req;
1900         int err;
1901
1902         memcpy(req.mac, mac, ETH_ALEN);
1903
1904         err = prestera_iface_to_msg(iif, &req.iif);
1905         if (err)
1906                 return err;
1907
1908         err = prestera_cmd_ret(sw, PRESTERA_CMD_TYPE_ROUTER_RIF_CREATE,
1909                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
1910         if (err)
1911                 return err;
1912
1913         *rif_id = __le16_to_cpu(resp.rif_id);
1914         return err;
1915 }
1916
1917 int prestera_hw_rif_delete(struct prestera_switch *sw, u16 rif_id,
1918                            struct prestera_iface *iif)
1919 {
1920         struct prestera_msg_rif_req req = {
1921                 .rif_id = __cpu_to_le16(rif_id),
1922         };
1923         int err;
1924
1925         err = prestera_iface_to_msg(iif, &req.iif);
1926         if (err)
1927                 return err;
1928
1929         return prestera_cmd(sw, PRESTERA_CMD_TYPE_ROUTER_RIF_DELETE, &req.cmd,
1930                             sizeof(req));
1931 }
1932
1933 int prestera_hw_vr_create(struct prestera_switch *sw, u16 *vr_id)
1934 {
1935         struct prestera_msg_vr_resp resp;
1936         struct prestera_msg_vr_req req;
1937         int err;
1938
1939         err = prestera_cmd_ret(sw, PRESTERA_CMD_TYPE_ROUTER_VR_CREATE,
1940                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
1941         if (err)
1942                 return err;
1943
1944         *vr_id = __le16_to_cpu(resp.vr_id);
1945         return err;
1946 }
1947
1948 int prestera_hw_vr_delete(struct prestera_switch *sw, u16 vr_id)
1949 {
1950         struct prestera_msg_vr_req req = {
1951                 .vr_id = __cpu_to_le16(vr_id),
1952         };
1953
1954         return prestera_cmd(sw, PRESTERA_CMD_TYPE_ROUTER_VR_DELETE, &req.cmd,
1955                             sizeof(req));
1956 }
1957
1958 int prestera_hw_lpm_add(struct prestera_switch *sw, u16 vr_id,
1959                         __be32 dst, u32 dst_len, u32 grp_id)
1960 {
1961         struct prestera_msg_lpm_req req = {
1962                 .dst_len = __cpu_to_le32(dst_len),
1963                 .vr_id = __cpu_to_le16(vr_id),
1964                 .grp_id = __cpu_to_le32(grp_id),
1965                 .dst.u.ipv4 = dst
1966         };
1967
1968         return prestera_cmd(sw, PRESTERA_CMD_TYPE_ROUTER_LPM_ADD, &req.cmd,
1969                             sizeof(req));
1970 }
1971
1972 int prestera_hw_lpm_del(struct prestera_switch *sw, u16 vr_id,
1973                         __be32 dst, u32 dst_len)
1974 {
1975         struct prestera_msg_lpm_req req = {
1976                 .dst_len = __cpu_to_le32(dst_len),
1977                 .vr_id = __cpu_to_le16(vr_id),
1978                 .dst.u.ipv4 = dst
1979         };
1980
1981         return prestera_cmd(sw, PRESTERA_CMD_TYPE_ROUTER_LPM_DELETE, &req.cmd,
1982                             sizeof(req));
1983 }
1984
1985 int prestera_hw_rxtx_init(struct prestera_switch *sw,
1986                           struct prestera_rxtx_params *params)
1987 {
1988         struct prestera_msg_rxtx_resp resp;
1989         struct prestera_msg_rxtx_req req;
1990         int err;
1991
1992         req.use_sdma = params->use_sdma;
1993
1994         err = prestera_cmd_ret(sw, PRESTERA_CMD_TYPE_RXTX_INIT,
1995                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
1996         if (err)
1997                 return err;
1998
1999         params->map_addr = __le32_to_cpu(resp.map_addr);
2000
2001         return 0;
2002 }
2003
2004 int prestera_hw_lag_member_add(struct prestera_port *port, u16 lag_id)
2005 {
2006         struct prestera_msg_lag_req req = {
2007                 .port = __cpu_to_le32(port->hw_id),
2008                 .dev = __cpu_to_le32(port->dev_id),
2009                 .lag_id = __cpu_to_le16(lag_id),
2010         };
2011
2012         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_LAG_MEMBER_ADD,
2013                             &req.cmd, sizeof(req));
2014 }
2015
2016 int prestera_hw_lag_member_del(struct prestera_port *port, u16 lag_id)
2017 {
2018         struct prestera_msg_lag_req req = {
2019                 .port = __cpu_to_le32(port->hw_id),
2020                 .dev = __cpu_to_le32(port->dev_id),
2021                 .lag_id = __cpu_to_le16(lag_id),
2022         };
2023
2024         return prestera_cmd(port->sw, PRESTERA_CMD_TYPE_LAG_MEMBER_DELETE,
2025                             &req.cmd, sizeof(req));
2026 }
2027
2028 int prestera_hw_lag_member_enable(struct prestera_port *port, u16 lag_id,
2029                                   bool enable)
2030 {
2031         struct prestera_msg_lag_req req = {
2032                 .port = __cpu_to_le32(port->hw_id),
2033                 .dev = __cpu_to_le32(port->dev_id),
2034                 .lag_id = __cpu_to_le16(lag_id),
2035         };
2036         u32 cmd;
2037
2038         cmd = enable ? PRESTERA_CMD_TYPE_LAG_MEMBER_ENABLE :
2039                         PRESTERA_CMD_TYPE_LAG_MEMBER_DISABLE;
2040
2041         return prestera_cmd(port->sw, cmd, &req.cmd, sizeof(req));
2042 }
2043
2044 int
2045 prestera_hw_cpu_code_counters_get(struct prestera_switch *sw, u8 code,
2046                                   enum prestera_hw_cpu_code_cnt_t counter_type,
2047                                   u64 *packet_count)
2048 {
2049         struct prestera_msg_cpu_code_counter_req req = {
2050                 .counter_type = counter_type,
2051                 .code = code,
2052         };
2053         struct mvsw_msg_cpu_code_counter_ret resp;
2054         int err;
2055
2056         err = prestera_cmd_ret(sw, PRESTERA_CMD_TYPE_CPU_CODE_COUNTERS_GET,
2057                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
2058         if (err)
2059                 return err;
2060
2061         *packet_count = __le64_to_cpu(resp.packet_count);
2062
2063         return 0;
2064 }
2065
2066 int prestera_hw_event_handler_register(struct prestera_switch *sw,
2067                                        enum prestera_event_type type,
2068                                        prestera_event_cb_t fn,
2069                                        void *arg)
2070 {
2071         struct prestera_fw_event_handler *eh;
2072
2073         eh = __find_event_handler(sw, type);
2074         if (eh)
2075                 return -EEXIST;
2076
2077         eh = kmalloc(sizeof(*eh), GFP_KERNEL);
2078         if (!eh)
2079                 return -ENOMEM;
2080
2081         eh->type = type;
2082         eh->func = fn;
2083         eh->arg = arg;
2084
2085         INIT_LIST_HEAD(&eh->list);
2086
2087         list_add_rcu(&eh->list, &sw->event_handlers);
2088
2089         return 0;
2090 }
2091
2092 void prestera_hw_event_handler_unregister(struct prestera_switch *sw,
2093                                           enum prestera_event_type type,
2094                                           prestera_event_cb_t fn)
2095 {
2096         struct prestera_fw_event_handler *eh;
2097
2098         eh = __find_event_handler(sw, type);
2099         if (!eh)
2100                 return;
2101
2102         list_del_rcu(&eh->list);
2103         kfree_rcu(eh, rcu);
2104 }
2105
2106 int prestera_hw_counter_trigger(struct prestera_switch *sw, u32 block_id)
2107 {
2108         struct prestera_msg_counter_req req = {
2109                 .block_id = __cpu_to_le32(block_id)
2110         };
2111
2112         return prestera_cmd(sw, PRESTERA_CMD_TYPE_COUNTER_TRIGGER,
2113                             &req.cmd, sizeof(req));
2114 }
2115
2116 int prestera_hw_counter_abort(struct prestera_switch *sw)
2117 {
2118         struct prestera_msg_counter_req req;
2119
2120         return prestera_cmd(sw, PRESTERA_CMD_TYPE_COUNTER_ABORT,
2121                             &req.cmd, sizeof(req));
2122 }
2123
2124 int prestera_hw_counters_get(struct prestera_switch *sw, u32 idx,
2125                              u32 *len, bool *done,
2126                              struct prestera_counter_stats *stats)
2127 {
2128         struct prestera_msg_counter_resp *resp;
2129         struct prestera_msg_counter_req req = {
2130                 .block_id = __cpu_to_le32(idx),
2131                 .num_counters = __cpu_to_le32(*len),
2132         };
2133         size_t size = struct_size(resp, stats, *len);
2134         int err, i;
2135
2136         resp = kmalloc(size, GFP_KERNEL);
2137         if (!resp)
2138                 return -ENOMEM;
2139
2140         err = prestera_cmd_ret(sw, PRESTERA_CMD_TYPE_COUNTER_GET,
2141                                &req.cmd, sizeof(req), &resp->ret, size);
2142         if (err)
2143                 goto free_buff;
2144
2145         for (i = 0; i < __le32_to_cpu(resp->num_counters); i++) {
2146                 stats[i].packets += __le64_to_cpu(resp->stats[i].packets);
2147                 stats[i].bytes += __le64_to_cpu(resp->stats[i].bytes);
2148         }
2149
2150         *len = __le32_to_cpu(resp->num_counters);
2151         *done = __le32_to_cpu(resp->done);
2152
2153 free_buff:
2154         kfree(resp);
2155         return err;
2156 }
2157
2158 int prestera_hw_counter_block_get(struct prestera_switch *sw,
2159                                   u32 client, u32 *block_id, u32 *offset,
2160                                   u32 *num_counters)
2161 {
2162         struct prestera_msg_counter_resp resp;
2163         struct prestera_msg_counter_req req = {
2164                 .client = __cpu_to_le32(client)
2165         };
2166         int err;
2167
2168         err = prestera_cmd_ret(sw, PRESTERA_CMD_TYPE_COUNTER_BLOCK_GET,
2169                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
2170         if (err)
2171                 return err;
2172
2173         *block_id = __le32_to_cpu(resp.block_id);
2174         *offset = __le32_to_cpu(resp.offset);
2175         *num_counters = __le32_to_cpu(resp.num_counters);
2176
2177         return 0;
2178 }
2179
2180 int prestera_hw_counter_block_release(struct prestera_switch *sw,
2181                                       u32 block_id)
2182 {
2183         struct prestera_msg_counter_req req = {
2184                 .block_id = __cpu_to_le32(block_id)
2185         };
2186
2187         return prestera_cmd(sw, PRESTERA_CMD_TYPE_COUNTER_BLOCK_RELEASE,
2188                             &req.cmd, sizeof(req));
2189 }
2190
2191 int prestera_hw_counter_clear(struct prestera_switch *sw, u32 block_id,
2192                               u32 counter_id)
2193 {
2194         struct prestera_msg_counter_req req = {
2195                 .block_id = __cpu_to_le32(block_id),
2196                 .num_counters = __cpu_to_le32(counter_id)
2197         };
2198
2199         return prestera_cmd(sw, PRESTERA_CMD_TYPE_COUNTER_CLEAR,
2200                             &req.cmd, sizeof(req));
2201 }
2202
2203 int prestera_hw_policer_create(struct prestera_switch *sw, u8 type,
2204                                u32 *policer_id)
2205 {
2206         struct prestera_msg_policer_resp resp;
2207         struct prestera_msg_policer_req req = {
2208                 .type = type
2209         };
2210         int err;
2211
2212         err = prestera_cmd_ret(sw, PRESTERA_CMD_TYPE_POLICER_CREATE,
2213                                &req.cmd, sizeof(req), &resp.ret, sizeof(resp));
2214         if (err)
2215                 return err;
2216
2217         *policer_id = __le32_to_cpu(resp.id);
2218         return 0;
2219 }
2220
2221 int prestera_hw_policer_release(struct prestera_switch *sw,
2222                                 u32 policer_id)
2223 {
2224         struct prestera_msg_policer_req req = {
2225                 .id = __cpu_to_le32(policer_id)
2226         };
2227
2228         return prestera_cmd(sw, PRESTERA_CMD_TYPE_POLICER_RELEASE,
2229                             &req.cmd, sizeof(req));
2230 }
2231
2232 int prestera_hw_policer_sr_tcm_set(struct prestera_switch *sw,
2233                                    u32 policer_id, u64 cir, u32 cbs)
2234 {
2235         struct prestera_msg_policer_req req = {
2236                 .mode = PRESTERA_POLICER_MODE_SR_TCM,
2237                 .id = __cpu_to_le32(policer_id),
2238                 .sr_tcm = {
2239                         .cir = __cpu_to_le64(cir),
2240                         .cbs = __cpu_to_le32(cbs)
2241                 }
2242         };
2243
2244         return prestera_cmd(sw, PRESTERA_CMD_TYPE_POLICER_SET,
2245                             &req.cmd, sizeof(req));
2246 }