drivers/net/ethernet/rocker/rocker_ofdpa.c

   1 /*
   2  * drivers/net/ethernet/rocker/rocker_ofdpa.c - Rocker switch OF-DPA-like
   3  *                                              implementation
   4  * Copyright (c) 2014 Scott Feldman <sfeldma@gmail.com>
   5  * Copyright (c) 2014-2016 Jiri Pirko <jiri@mellanox.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <linux/types.h>
  15 #include <linux/spinlock.h>
  16 #include <linux/hashtable.h>
  17 #include <linux/crc32.h>
  18 #include <linux/netdevice.h>
  19 #include <linux/inetdevice.h>
  20 #include <linux/if_vlan.h>
  21 #include <linux/if_bridge.h>
  22 #include <net/neighbour.h>
  23 #include <net/switchdev.h>
  24 #include <net/ip_fib.h>
  25 #include <net/arp.h>
  26
  27 #include "rocker.h"
  28 #include "rocker_tlv.h"
  29
  30 struct ofdpa_flow_tbl_key {
  31         u32 priority;
  32         enum rocker_of_dpa_table_id tbl_id;
  33         union {
  34                 struct {
  35                         u32 in_pport;
  36                         u32 in_pport_mask;
  37                         enum rocker_of_dpa_table_id goto_tbl;
  38                 } ig_port;
  39                 struct {
  40                         u32 in_pport;
  41                         __be16 vlan_id;
  42                         __be16 vlan_id_mask;
  43                         enum rocker_of_dpa_table_id goto_tbl;
  44                         bool untagged;
  45                         __be16 new_vlan_id;
  46                 } vlan;
  47                 struct {
  48                         u32 in_pport;
  49                         u32 in_pport_mask;
  50                         __be16 eth_type;
  51                         u8 eth_dst[ETH_ALEN];
  52                         u8 eth_dst_mask[ETH_ALEN];
  53                         __be16 vlan_id;
  54                         __be16 vlan_id_mask;
  55                         enum rocker_of_dpa_table_id goto_tbl;
  56                         bool copy_to_cpu;
  57                 } term_mac;
  58                 struct {
  59                         __be16 eth_type;
  60                         __be32 dst4;
  61                         __be32 dst4_mask;
  62                         enum rocker_of_dpa_table_id goto_tbl;
  63                         u32 group_id;
  64                 } ucast_routing;
  65                 struct {
  66                         u8 eth_dst[ETH_ALEN];
  67                         u8 eth_dst_mask[ETH_ALEN];
  68                         int has_eth_dst;
  69                         int has_eth_dst_mask;
  70                         __be16 vlan_id;
  71                         u32 tunnel_id;
  72                         enum rocker_of_dpa_table_id goto_tbl;
  73                         u32 group_id;
  74                         bool copy_to_cpu;
  75                 } bridge;
  76                 struct {
  77                         u32 in_pport;
  78                         u32 in_pport_mask;
  79                         u8 eth_src[ETH_ALEN];
  80                         u8 eth_src_mask[ETH_ALEN];
  81                         u8 eth_dst[ETH_ALEN];
  82                         u8 eth_dst_mask[ETH_ALEN];
  83                         __be16 eth_type;
  84                         __be16 vlan_id;
  85                         __be16 vlan_id_mask;
  86                         u8 ip_proto;
  87                         u8 ip_proto_mask;
  88                         u8 ip_tos;
  89                         u8 ip_tos_mask;
  90                         u32 group_id;
  91                 } acl;
  92         };
  93 };
  94
  95 struct ofdpa_flow_tbl_entry {
  96         struct hlist_node entry;
  97         u32 cmd;
  98         u64 cookie;
  99         struct ofdpa_flow_tbl_key key;
 100         size_t key_len;
 101         u32 key_crc32; /* key */
 102         struct fib_info *fi;
 103 };
 104
 105 struct ofdpa_group_tbl_entry {
 106         struct hlist_node entry;
 107         u32 cmd;
 108         u32 group_id; /* key */
 109         u16 group_count;
 110         u32 *group_ids;
 111         union {
 112                 struct {
 113                         u8 pop_vlan;
 114                 } l2_interface;
 115                 struct {
 116                         u8 eth_src[ETH_ALEN];
 117                         u8 eth_dst[ETH_ALEN];
 118                         __be16 vlan_id;
 119                         u32 group_id;
 120                 } l2_rewrite;
 121                 struct {
 122                         u8 eth_src[ETH_ALEN];
 123                         u8 eth_dst[ETH_ALEN];
 124                         __be16 vlan_id;
 125                         bool ttl_check;
 126                         u32 group_id;
 127                 } l3_unicast;
 128         };
 129 };
 130
 131 struct ofdpa_fdb_tbl_entry {
 132         struct hlist_node entry;
 133         u32 key_crc32; /* key */
 134         bool learned;
 135         unsigned long touched;
 136         struct ofdpa_fdb_tbl_key {
 137                 struct ofdpa_port *ofdpa_port;
 138                 u8 addr[ETH_ALEN];
 139                 __be16 vlan_id;
 140         } key;
 141 };
 142
 143 struct ofdpa_internal_vlan_tbl_entry {
 144         struct hlist_node entry;
 145         int ifindex; /* key */
 146         u32 ref_count;
 147         __be16 vlan_id;
 148 };
 149
 150 struct ofdpa_neigh_tbl_entry {
 151         struct hlist_node entry;
 152         __be32 ip_addr; /* key */
 153         struct net_device *dev;
 154         u32 ref_count;
 155         u32 index;
 156         u8 eth_dst[ETH_ALEN];
 157         bool ttl_check;
 158 };
 159
 160 enum {
 161         OFDPA_CTRL_LINK_LOCAL_MCAST,
 162         OFDPA_CTRL_LOCAL_ARP,
 163         OFDPA_CTRL_IPV4_MCAST,
 164         OFDPA_CTRL_IPV6_MCAST,
 165         OFDPA_CTRL_DFLT_BRIDGING,
 166         OFDPA_CTRL_DFLT_OVS,
 167         OFDPA_CTRL_MAX,
 168 };
 169
 170 #define OFDPA_INTERNAL_VLAN_ID_BASE     0x0f00
 171 #define OFDPA_N_INTERNAL_VLANS          255
 172 #define OFDPA_VLAN_BITMAP_LEN           BITS_TO_LONGS(VLAN_N_VID)
 173 #define OFDPA_INTERNAL_VLAN_BITMAP_LEN  BITS_TO_LONGS(OFDPA_N_INTERNAL_VLANS)
 174 #define OFDPA_UNTAGGED_VID 0
 175
 176 struct ofdpa {
 177         struct rocker *rocker;
 178         DECLARE_HASHTABLE(flow_tbl, 16);
 179         spinlock_t flow_tbl_lock;               /* for flow tbl accesses */
 180         u64 flow_tbl_next_cookie;
 181         DECLARE_HASHTABLE(group_tbl, 16);
 182         spinlock_t group_tbl_lock;              /* for group tbl accesses */
 183         struct timer_list fdb_cleanup_timer;
 184         DECLARE_HASHTABLE(fdb_tbl, 16);
 185         spinlock_t fdb_tbl_lock;                /* for fdb tbl accesses */
 186         unsigned long internal_vlan_bitmap[OFDPA_INTERNAL_VLAN_BITMAP_LEN];
 187         DECLARE_HASHTABLE(internal_vlan_tbl, 8);
 188         spinlock_t internal_vlan_tbl_lock;      /* for vlan tbl accesses */
 189         DECLARE_HASHTABLE(neigh_tbl, 16);
 190         spinlock_t neigh_tbl_lock;              /* for neigh tbl accesses */
 191         u32 neigh_tbl_next_index;
 192         unsigned long ageing_time;
 193         bool fib_aborted;
 194 };
 195
 196 struct ofdpa_port {
 197         struct ofdpa *ofdpa;
 198         struct rocker_port *rocker_port;
 199         struct net_device *dev;
 200         u32 pport;
 201         struct net_device *bridge_dev;
 202         __be16 internal_vlan_id;
 203         int stp_state;
 204         u32 brport_flags;
 205         unsigned long ageing_time;
 206         bool ctrls[OFDPA_CTRL_MAX];
 207         unsigned long vlan_bitmap[OFDPA_VLAN_BITMAP_LEN];
 208 };
 209
 210 static const u8 zero_mac[ETH_ALEN]   = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 211 static const u8 ff_mac[ETH_ALEN]     = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 212 static const u8 ll_mac[ETH_ALEN]     = { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x00 };
 213 static const u8 ll_mask[ETH_ALEN]    = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0 };
 214 static const u8 mcast_mac[ETH_ALEN]  = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 };
 215 static const u8 ipv4_mcast[ETH_ALEN] = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00 };
 216 static const u8 ipv4_mask[ETH_ALEN]  = { 0xff, 0xff, 0xff, 0x80, 0x00, 0x00 };
 217 static const u8 ipv6_mcast[ETH_ALEN] = { 0x33, 0x33, 0x00, 0x00, 0x00, 0x00 };
 218 static const u8 ipv6_mask[ETH_ALEN]  = { 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 };
 219
 220 /* Rocker priority levels for flow table entries.  Higher
 221  * priority match takes precedence over lower priority match.
 222  */
 223
 224 enum {
 225         OFDPA_PRIORITY_UNKNOWN = 0,
 226         OFDPA_PRIORITY_IG_PORT = 1,
 227         OFDPA_PRIORITY_VLAN = 1,
 228         OFDPA_PRIORITY_TERM_MAC_UCAST = 0,
 229         OFDPA_PRIORITY_TERM_MAC_MCAST = 1,
 230         OFDPA_PRIORITY_BRIDGING_VLAN_DFLT_EXACT = 1,
 231         OFDPA_PRIORITY_BRIDGING_VLAN_DFLT_WILD = 2,
 232         OFDPA_PRIORITY_BRIDGING_VLAN = 3,
 233         OFDPA_PRIORITY_BRIDGING_TENANT_DFLT_EXACT = 1,
 234         OFDPA_PRIORITY_BRIDGING_TENANT_DFLT_WILD = 2,
 235         OFDPA_PRIORITY_BRIDGING_TENANT = 3,
 236         OFDPA_PRIORITY_ACL_CTRL = 3,
 237         OFDPA_PRIORITY_ACL_NORMAL = 2,
 238         OFDPA_PRIORITY_ACL_DFLT = 1,
 239 };
 240
 241 static bool ofdpa_vlan_id_is_internal(__be16 vlan_id)
 242 {
 243         u16 start = OFDPA_INTERNAL_VLAN_ID_BASE;
 244         u16 end = 0xffe;
 245         u16 _vlan_id = ntohs(vlan_id);
 246
 247         return (_vlan_id >= start && _vlan_id <= end);
 248 }
 249
 250 static __be16 ofdpa_port_vid_to_vlan(const struct ofdpa_port *ofdpa_port,
 251                                      u16 vid, bool *pop_vlan)
 252 {
 253         __be16 vlan_id;
 254
 255         if (pop_vlan)
 256                 *pop_vlan = false;
 257         vlan_id = htons(vid);
 258         if (!vlan_id) {
 259                 vlan_id = ofdpa_port->internal_vlan_id;
 260                 if (pop_vlan)
 261                         *pop_vlan = true;
 262         }
 263
 264         return vlan_id;
 265 }
 266
 267 static u16 ofdpa_port_vlan_to_vid(const struct ofdpa_port *ofdpa_port,
 268                                   __be16 vlan_id)
 269 {
 270         if (ofdpa_vlan_id_is_internal(vlan_id))
 271                 return 0;
 272
 273         return ntohs(vlan_id);
 274 }
 275
 276 static bool ofdpa_port_is_slave(const struct ofdpa_port *ofdpa_port,
 277                                 const char *kind)
 278 {
 279         return ofdpa_port->bridge_dev &&
 280                 !strcmp(ofdpa_port->bridge_dev->rtnl_link_ops->kind, kind);
 281 }
 282
 283 static bool ofdpa_port_is_bridged(const struct ofdpa_port *ofdpa_port)
 284 {
 285         return ofdpa_port_is_slave(ofdpa_port, "bridge");
 286 }
 287
 288 static bool ofdpa_port_is_ovsed(const struct ofdpa_port *ofdpa_port)
 289 {
 290         return ofdpa_port_is_slave(ofdpa_port, "openvswitch");
 291 }
 292
 293 #define OFDPA_OP_FLAG_REMOVE            BIT(0)
 294 #define OFDPA_OP_FLAG_NOWAIT            BIT(1)
 295 #define OFDPA_OP_FLAG_LEARNED           BIT(2)
 296 #define OFDPA_OP_FLAG_REFRESH           BIT(3)
 297
 298 static bool ofdpa_flags_nowait(int flags)
 299 {
 300         return flags & OFDPA_OP_FLAG_NOWAIT;
 301 }
 302
 303 static void *__ofdpa_mem_alloc(struct switchdev_trans *trans, int flags,
 304                                size_t size)
 305 {
 306         struct switchdev_trans_item *elem = NULL;
 307         gfp_t gfp_flags = (flags & OFDPA_OP_FLAG_NOWAIT) ?
 308                           GFP_ATOMIC : GFP_KERNEL;
 309
 310         /* If in transaction prepare phase, allocate the memory
 311          * and enqueue it on a transaction.  If in transaction
 312          * commit phase, dequeue the memory from the transaction
 313          * rather than re-allocating the memory.  The idea is the
 314          * driver code paths for prepare and commit are identical
 315          * so the memory allocated in the prepare phase is the
 316          * memory used in the commit phase.
 317          */
 318
 319         if (!trans) {
 320                 elem = kzalloc(size + sizeof(*elem), gfp_flags);
 321         } else if (switchdev_trans_ph_prepare(trans)) {
 322                 elem = kzalloc(size + sizeof(*elem), gfp_flags);
 323                 if (!elem)
 324                         return NULL;
 325                 switchdev_trans_item_enqueue(trans, elem, kfree, elem);
 326         } else {
 327                 elem = switchdev_trans_item_dequeue(trans);
 328         }
 329
 330         return elem ? elem + 1 : NULL;
 331 }
 332
 333 static void *ofdpa_kzalloc(struct switchdev_trans *trans, int flags,
 334                            size_t size)
 335 {
 336         return __ofdpa_mem_alloc(trans, flags, size);
 337 }
 338
 339 static void *ofdpa_kcalloc(struct switchdev_trans *trans, int flags,
 340                            size_t n, size_t size)
 341 {
 342         return __ofdpa_mem_alloc(trans, flags, n * size);
 343 }
 344
 345 static void ofdpa_kfree(struct switchdev_trans *trans, const void *mem)
 346 {
 347         struct switchdev_trans_item *elem;
 348
 349         /* Frees are ignored if in transaction prepare phase.  The
 350          * memory remains on the per-port list until freed in the
 351          * commit phase.
 352          */
 353
 354         if (switchdev_trans_ph_prepare(trans))
 355                 return;
 356
 357         elem = (struct switchdev_trans_item *) mem - 1;
 358         kfree(elem);
 359 }
 360
 361 /*************************************************************
 362  * Flow, group, FDB, internal VLAN and neigh command prepares
 363  *************************************************************/
 364
 365 static int
 366 ofdpa_cmd_flow_tbl_add_ig_port(struct rocker_desc_info *desc_info,
 367                                const struct ofdpa_flow_tbl_entry *entry)
 368 {
 369         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_IN_PPORT,
 370                                entry->key.ig_port.in_pport))
 371                 return -EMSGSIZE;
 372         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_IN_PPORT_MASK,
 373                                entry->key.ig_port.in_pport_mask))
 374                 return -EMSGSIZE;
 375         if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_OF_DPA_GOTO_TABLE_ID,
 376                                entry->key.ig_port.goto_tbl))
 377                 return -EMSGSIZE;
 378
 379         return 0;
 380 }
 381
 382 static int
 383 ofdpa_cmd_flow_tbl_add_vlan(struct rocker_desc_info *desc_info,
 384                             const struct ofdpa_flow_tbl_entry *entry)
 385 {
 386         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_IN_PPORT,
 387                                entry->key.vlan.in_pport))
 388                 return -EMSGSIZE;
 389         if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID,
 390                                 entry->key.vlan.vlan_id))
 391                 return -EMSGSIZE;
 392         if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID_MASK,
 393                                 entry->key.vlan.vlan_id_mask))
 394                 return -EMSGSIZE;
 395         if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_OF_DPA_GOTO_TABLE_ID,
 396                                entry->key.vlan.goto_tbl))
 397                 return -EMSGSIZE;
 398         if (entry->key.vlan.untagged &&
 399             rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_NEW_VLAN_ID,
 400                                 entry->key.vlan.new_vlan_id))
 401                 return -EMSGSIZE;
 402
 403         return 0;
 404 }
 405
 406 static int
 407 ofdpa_cmd_flow_tbl_add_term_mac(struct rocker_desc_info *desc_info,
 408                                 const struct ofdpa_flow_tbl_entry *entry)
 409 {
 410         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_IN_PPORT,
 411                                entry->key.term_mac.in_pport))
 412                 return -EMSGSIZE;
 413         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_IN_PPORT_MASK,
 414                                entry->key.term_mac.in_pport_mask))
 415                 return -EMSGSIZE;
 416         if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_ETHERTYPE,
 417                                 entry->key.term_mac.eth_type))
 418                 return -EMSGSIZE;
 419         if (rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC,
 420                            ETH_ALEN, entry->key.term_mac.eth_dst))
 421                 return -EMSGSIZE;
 422         if (rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC_MASK,
 423                            ETH_ALEN, entry->key.term_mac.eth_dst_mask))
 424                 return -EMSGSIZE;
 425         if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID,
 426                                 entry->key.term_mac.vlan_id))
 427                 return -EMSGSIZE;
 428         if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID_MASK,
 429                                 entry->key.term_mac.vlan_id_mask))
 430                 return -EMSGSIZE;
 431         if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_OF_DPA_GOTO_TABLE_ID,
 432                                entry->key.term_mac.goto_tbl))
 433                 return -EMSGSIZE;
 434         if (entry->key.term_mac.copy_to_cpu &&
 435             rocker_tlv_put_u8(desc_info, ROCKER_TLV_OF_DPA_COPY_CPU_ACTION,
 436                               entry->key.term_mac.copy_to_cpu))
 437                 return -EMSGSIZE;
 438
 439         return 0;
 440 }
 441
 442 static int
 443 ofdpa_cmd_flow_tbl_add_ucast_routing(struct rocker_desc_info *desc_info,
 444                                      const struct ofdpa_flow_tbl_entry *entry)
 445 {
 446         if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_ETHERTYPE,
 447                                 entry->key.ucast_routing.eth_type))
 448                 return -EMSGSIZE;
 449         if (rocker_tlv_put_be32(desc_info, ROCKER_TLV_OF_DPA_DST_IP,
 450                                 entry->key.ucast_routing.dst4))
 451                 return -EMSGSIZE;
 452         if (rocker_tlv_put_be32(desc_info, ROCKER_TLV_OF_DPA_DST_IP_MASK,
 453                                 entry->key.ucast_routing.dst4_mask))
 454                 return -EMSGSIZE;
 455         if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_OF_DPA_GOTO_TABLE_ID,
 456                                entry->key.ucast_routing.goto_tbl))
 457                 return -EMSGSIZE;
 458         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_GROUP_ID,
 459                                entry->key.ucast_routing.group_id))
 460                 return -EMSGSIZE;
 461
 462         return 0;
 463 }
 464
 465 static int
 466 ofdpa_cmd_flow_tbl_add_bridge(struct rocker_desc_info *desc_info,
 467                               const struct ofdpa_flow_tbl_entry *entry)
 468 {
 469         if (entry->key.bridge.has_eth_dst &&
 470             rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC,
 471                            ETH_ALEN, entry->key.bridge.eth_dst))
 472                 return -EMSGSIZE;
 473         if (entry->key.bridge.has_eth_dst_mask &&
 474             rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC_MASK,
 475                            ETH_ALEN, entry->key.bridge.eth_dst_mask))
 476                 return -EMSGSIZE;
 477         if (entry->key.bridge.vlan_id &&
 478             rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID,
 479                                 entry->key.bridge.vlan_id))
 480                 return -EMSGSIZE;
 481         if (entry->key.bridge.tunnel_id &&
 482             rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_TUNNEL_ID,
 483                                entry->key.bridge.tunnel_id))
 484                 return -EMSGSIZE;
 485         if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_OF_DPA_GOTO_TABLE_ID,
 486                                entry->key.bridge.goto_tbl))
 487                 return -EMSGSIZE;
 488         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_GROUP_ID,
 489                                entry->key.bridge.group_id))
 490                 return -EMSGSIZE;
 491         if (entry->key.bridge.copy_to_cpu &&
 492             rocker_tlv_put_u8(desc_info, ROCKER_TLV_OF_DPA_COPY_CPU_ACTION,
 493                               entry->key.bridge.copy_to_cpu))
 494                 return -EMSGSIZE;
 495
 496         return 0;
 497 }
 498
 499 static int
 500 ofdpa_cmd_flow_tbl_add_acl(struct rocker_desc_info *desc_info,
 501                            const struct ofdpa_flow_tbl_entry *entry)
 502 {
 503         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_IN_PPORT,
 504                                entry->key.acl.in_pport))
 505                 return -EMSGSIZE;
 506         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_IN_PPORT_MASK,
 507                                entry->key.acl.in_pport_mask))
 508                 return -EMSGSIZE;
 509         if (rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_SRC_MAC,
 510                            ETH_ALEN, entry->key.acl.eth_src))
 511                 return -EMSGSIZE;
 512         if (rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_SRC_MAC_MASK,
 513                            ETH_ALEN, entry->key.acl.eth_src_mask))
 514                 return -EMSGSIZE;
 515         if (rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC,
 516                            ETH_ALEN, entry->key.acl.eth_dst))
 517                 return -EMSGSIZE;
 518         if (rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC_MASK,
 519                            ETH_ALEN, entry->key.acl.eth_dst_mask))
 520                 return -EMSGSIZE;
 521         if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_ETHERTYPE,
 522                                 entry->key.acl.eth_type))
 523                 return -EMSGSIZE;
 524         if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID,
 525                                 entry->key.acl.vlan_id))
 526                 return -EMSGSIZE;
 527         if (rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID_MASK,
 528                                 entry->key.acl.vlan_id_mask))
 529                 return -EMSGSIZE;
 530
 531         switch (ntohs(entry->key.acl.eth_type)) {
 532         case ETH_P_IP:
 533         case ETH_P_IPV6:
 534                 if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_OF_DPA_IP_PROTO,
 535                                       entry->key.acl.ip_proto))
 536                         return -EMSGSIZE;
 537                 if (rocker_tlv_put_u8(desc_info,
 538                                       ROCKER_TLV_OF_DPA_IP_PROTO_MASK,
 539                                       entry->key.acl.ip_proto_mask))
 540                         return -EMSGSIZE;
 541                 if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_OF_DPA_IP_DSCP,
 542                                       entry->key.acl.ip_tos & 0x3f))
 543                         return -EMSGSIZE;
 544                 if (rocker_tlv_put_u8(desc_info,
 545                                       ROCKER_TLV_OF_DPA_IP_DSCP_MASK,
 546                                       entry->key.acl.ip_tos_mask & 0x3f))
 547                         return -EMSGSIZE;
 548                 if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_OF_DPA_IP_ECN,
 549                                       (entry->key.acl.ip_tos & 0xc0) >> 6))
 550                         return -EMSGSIZE;
 551                 if (rocker_tlv_put_u8(desc_info,
 552                                       ROCKER_TLV_OF_DPA_IP_ECN_MASK,
 553                                       (entry->key.acl.ip_tos_mask & 0xc0) >> 6))
 554                         return -EMSGSIZE;
 555                 break;
 556         }
 557
 558         if (entry->key.acl.group_id != ROCKER_GROUP_NONE &&
 559             rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_GROUP_ID,
 560                                entry->key.acl.group_id))
 561                 return -EMSGSIZE;
 562
 563         return 0;
 564 }
 565
 566 static int ofdpa_cmd_flow_tbl_add(const struct rocker_port *rocker_port,
 567                                   struct rocker_desc_info *desc_info,
 568                                   void *priv)
 569 {
 570         const struct ofdpa_flow_tbl_entry *entry = priv;
 571         struct rocker_tlv *cmd_info;
 572         int err = 0;
 573
 574         if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE, entry->cmd))
 575                 return -EMSGSIZE;
 576         cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
 577         if (!cmd_info)
 578                 return -EMSGSIZE;
 579         if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_OF_DPA_TABLE_ID,
 580                                entry->key.tbl_id))
 581                 return -EMSGSIZE;
 582         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_PRIORITY,
 583                                entry->key.priority))
 584                 return -EMSGSIZE;
 585         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_HARDTIME, 0))
 586                 return -EMSGSIZE;
 587         if (rocker_tlv_put_u64(desc_info, ROCKER_TLV_OF_DPA_COOKIE,
 588                                entry->cookie))
 589                 return -EMSGSIZE;
 590
 591         switch (entry->key.tbl_id) {
 592         case ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT:
 593                 err = ofdpa_cmd_flow_tbl_add_ig_port(desc_info, entry);
 594                 break;
 595         case ROCKER_OF_DPA_TABLE_ID_VLAN:
 596                 err = ofdpa_cmd_flow_tbl_add_vlan(desc_info, entry);
 597                 break;
 598         case ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC:
 599                 err = ofdpa_cmd_flow_tbl_add_term_mac(desc_info, entry);
 600                 break;
 601         case ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING:
 602                 err = ofdpa_cmd_flow_tbl_add_ucast_routing(desc_info, entry);
 603                 break;
 604         case ROCKER_OF_DPA_TABLE_ID_BRIDGING:
 605                 err = ofdpa_cmd_flow_tbl_add_bridge(desc_info, entry);
 606                 break;
 607         case ROCKER_OF_DPA_TABLE_ID_ACL_POLICY:
 608                 err = ofdpa_cmd_flow_tbl_add_acl(desc_info, entry);
 609                 break;
 610         default:
 611                 err = -ENOTSUPP;
 612                 break;
 613         }
 614
 615         if (err)
 616                 return err;
 617
 618         rocker_tlv_nest_end(desc_info, cmd_info);
 619
 620         return 0;
 621 }
 622
 623 static int ofdpa_cmd_flow_tbl_del(const struct rocker_port *rocker_port,
 624                                   struct rocker_desc_info *desc_info,
 625                                   void *priv)
 626 {
 627         const struct ofdpa_flow_tbl_entry *entry = priv;
 628         struct rocker_tlv *cmd_info;
 629
 630         if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE, entry->cmd))
 631                 return -EMSGSIZE;
 632         cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
 633         if (!cmd_info)
 634                 return -EMSGSIZE;
 635         if (rocker_tlv_put_u64(desc_info, ROCKER_TLV_OF_DPA_COOKIE,
 636                                entry->cookie))
 637                 return -EMSGSIZE;
 638         rocker_tlv_nest_end(desc_info, cmd_info);
 639
 640         return 0;
 641 }
 642
 643 static int
 644 ofdpa_cmd_group_tbl_add_l2_interface(struct rocker_desc_info *desc_info,
 645                                      struct ofdpa_group_tbl_entry *entry)
 646 {
 647         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_OUT_PPORT,
 648                                ROCKER_GROUP_PORT_GET(entry->group_id)))
 649                 return -EMSGSIZE;
 650         if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_OF_DPA_POP_VLAN,
 651                               entry->l2_interface.pop_vlan))
 652                 return -EMSGSIZE;
 653
 654         return 0;
 655 }
 656
 657 static int
 658 ofdpa_cmd_group_tbl_add_l2_rewrite(struct rocker_desc_info *desc_info,
 659                                    const struct ofdpa_group_tbl_entry *entry)
 660 {
 661         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_GROUP_ID_LOWER,
 662                                entry->l2_rewrite.group_id))
 663                 return -EMSGSIZE;
 664         if (!is_zero_ether_addr(entry->l2_rewrite.eth_src) &&
 665             rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_SRC_MAC,
 666                            ETH_ALEN, entry->l2_rewrite.eth_src))
 667                 return -EMSGSIZE;
 668         if (!is_zero_ether_addr(entry->l2_rewrite.eth_dst) &&
 669             rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC,
 670                            ETH_ALEN, entry->l2_rewrite.eth_dst))
 671                 return -EMSGSIZE;
 672         if (entry->l2_rewrite.vlan_id &&
 673             rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID,
 674                                 entry->l2_rewrite.vlan_id))
 675                 return -EMSGSIZE;
 676
 677         return 0;
 678 }
 679
 680 static int
 681 ofdpa_cmd_group_tbl_add_group_ids(struct rocker_desc_info *desc_info,
 682                                   const struct ofdpa_group_tbl_entry *entry)
 683 {
 684         int i;
 685         struct rocker_tlv *group_ids;
 686
 687         if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_OF_DPA_GROUP_COUNT,
 688                                entry->group_count))
 689                 return -EMSGSIZE;
 690
 691         group_ids = rocker_tlv_nest_start(desc_info,
 692                                           ROCKER_TLV_OF_DPA_GROUP_IDS);
 693         if (!group_ids)
 694                 return -EMSGSIZE;
 695
 696         for (i = 0; i < entry->group_count; i++)
 697                 /* Note TLV array is 1-based */
 698                 if (rocker_tlv_put_u32(desc_info, i + 1, entry->group_ids[i]))
 699                         return -EMSGSIZE;
 700
 701         rocker_tlv_nest_end(desc_info, group_ids);
 702
 703         return 0;
 704 }
 705
 706 static int
 707 ofdpa_cmd_group_tbl_add_l3_unicast(struct rocker_desc_info *desc_info,
 708                                    const struct ofdpa_group_tbl_entry *entry)
 709 {
 710         if (!is_zero_ether_addr(entry->l3_unicast.eth_src) &&
 711             rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_SRC_MAC,
 712                            ETH_ALEN, entry->l3_unicast.eth_src))
 713                 return -EMSGSIZE;
 714         if (!is_zero_ether_addr(entry->l3_unicast.eth_dst) &&
 715             rocker_tlv_put(desc_info, ROCKER_TLV_OF_DPA_DST_MAC,
 716                            ETH_ALEN, entry->l3_unicast.eth_dst))
 717                 return -EMSGSIZE;
 718         if (entry->l3_unicast.vlan_id &&
 719             rocker_tlv_put_be16(desc_info, ROCKER_TLV_OF_DPA_VLAN_ID,
 720                                 entry->l3_unicast.vlan_id))
 721                 return -EMSGSIZE;
 722         if (rocker_tlv_put_u8(desc_info, ROCKER_TLV_OF_DPA_TTL_CHECK,
 723                               entry->l3_unicast.ttl_check))
 724                 return -EMSGSIZE;
 725         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_GROUP_ID_LOWER,
 726                                entry->l3_unicast.group_id))
 727                 return -EMSGSIZE;
 728
 729         return 0;
 730 }
 731
 732 static int ofdpa_cmd_group_tbl_add(const struct rocker_port *rocker_port,
 733                                    struct rocker_desc_info *desc_info,
 734                                    void *priv)
 735 {
 736         struct ofdpa_group_tbl_entry *entry = priv;
 737         struct rocker_tlv *cmd_info;
 738         int err = 0;
 739
 740         if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE, entry->cmd))
 741                 return -EMSGSIZE;
 742         cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
 743         if (!cmd_info)
 744                 return -EMSGSIZE;
 745
 746         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_GROUP_ID,
 747                                entry->group_id))
 748                 return -EMSGSIZE;
 749
 750         switch (ROCKER_GROUP_TYPE_GET(entry->group_id)) {
 751         case ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE:
 752                 err = ofdpa_cmd_group_tbl_add_l2_interface(desc_info, entry);
 753                 break;
 754         case ROCKER_OF_DPA_GROUP_TYPE_L2_REWRITE:
 755                 err = ofdpa_cmd_group_tbl_add_l2_rewrite(desc_info, entry);
 756                 break;
 757         case ROCKER_OF_DPA_GROUP_TYPE_L2_FLOOD:
 758         case ROCKER_OF_DPA_GROUP_TYPE_L2_MCAST:
 759                 err = ofdpa_cmd_group_tbl_add_group_ids(desc_info, entry);
 760                 break;
 761         case ROCKER_OF_DPA_GROUP_TYPE_L3_UCAST:
 762                 err = ofdpa_cmd_group_tbl_add_l3_unicast(desc_info, entry);
 763                 break;
 764         default:
 765                 err = -ENOTSUPP;
 766                 break;
 767         }
 768
 769         if (err)
 770                 return err;
 771
 772         rocker_tlv_nest_end(desc_info, cmd_info);
 773
 774         return 0;
 775 }
 776
 777 static int ofdpa_cmd_group_tbl_del(const struct rocker_port *rocker_port,
 778                                    struct rocker_desc_info *desc_info,
 779                                    void *priv)
 780 {
 781         const struct ofdpa_group_tbl_entry *entry = priv;
 782         struct rocker_tlv *cmd_info;
 783
 784         if (rocker_tlv_put_u16(desc_info, ROCKER_TLV_CMD_TYPE, entry->cmd))
 785                 return -EMSGSIZE;
 786         cmd_info = rocker_tlv_nest_start(desc_info, ROCKER_TLV_CMD_INFO);
 787         if (!cmd_info)
 788                 return -EMSGSIZE;
 789         if (rocker_tlv_put_u32(desc_info, ROCKER_TLV_OF_DPA_GROUP_ID,
 790                                entry->group_id))
 791                 return -EMSGSIZE;
 792         rocker_tlv_nest_end(desc_info, cmd_info);
 793
 794         return 0;
 795 }
 796
 797 /***************************************************
 798  * Flow, group, FDB, internal VLAN and neigh tables
 799  ***************************************************/
 800
 801 static struct ofdpa_flow_tbl_entry *
 802 ofdpa_flow_tbl_find(const struct ofdpa *ofdpa,
 803                     const struct ofdpa_flow_tbl_entry *match)
 804 {
 805         struct ofdpa_flow_tbl_entry *found;
 806         size_t key_len = match->key_len ? match->key_len : sizeof(found->key);
 807
 808         hash_for_each_possible(ofdpa->flow_tbl, found,
 809                                entry, match->key_crc32) {
 810                 if (memcmp(&found->key, &match->key, key_len) == 0)
 811                         return found;
 812         }
 813
 814         return NULL;
 815 }
 816
 817 static int ofdpa_flow_tbl_add(struct ofdpa_port *ofdpa_port,
 818                               struct switchdev_trans *trans, int flags,
 819                               struct ofdpa_flow_tbl_entry *match)
 820 {
 821         struct ofdpa *ofdpa = ofdpa_port->ofdpa;
 822         struct ofdpa_flow_tbl_entry *found;
 823         size_t key_len = match->key_len ? match->key_len : sizeof(found->key);
 824         unsigned long lock_flags;
 825
 826         match->key_crc32 = crc32(~0, &match->key, key_len);
 827
 828         spin_lock_irqsave(&ofdpa->flow_tbl_lock, lock_flags);
 829
 830         found = ofdpa_flow_tbl_find(ofdpa, match);
 831
 832         if (found) {
 833                 match->cookie = found->cookie;
 834                 if (!switchdev_trans_ph_prepare(trans))
 835                         hash_del(&found->entry);
 836                 ofdpa_kfree(trans, found);
 837                 found = match;
 838                 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_MOD;
 839         } else {
 840                 found = match;
 841                 found->cookie = ofdpa->flow_tbl_next_cookie++;
 842                 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_ADD;
 843         }
 844
 845         if (!switchdev_trans_ph_prepare(trans))
 846                 hash_add(ofdpa->flow_tbl, &found->entry, found->key_crc32);
 847
 848         spin_unlock_irqrestore(&ofdpa->flow_tbl_lock, lock_flags);
 849
 850         if (!switchdev_trans_ph_prepare(trans))
 851                 return rocker_cmd_exec(ofdpa_port->rocker_port,
 852                                        ofdpa_flags_nowait(flags),
 853                                        ofdpa_cmd_flow_tbl_add,
 854                                        found, NULL, NULL);
 855         return 0;
 856 }
 857
 858 static int ofdpa_flow_tbl_del(struct ofdpa_port *ofdpa_port,
 859                               struct switchdev_trans *trans, int flags,
 860                               struct ofdpa_flow_tbl_entry *match)
 861 {
 862         struct ofdpa *ofdpa = ofdpa_port->ofdpa;
 863         struct ofdpa_flow_tbl_entry *found;
 864         size_t key_len = match->key_len ? match->key_len : sizeof(found->key);
 865         unsigned long lock_flags;
 866         int err = 0;
 867
 868         match->key_crc32 = crc32(~0, &match->key, key_len);
 869
 870         spin_lock_irqsave(&ofdpa->flow_tbl_lock, lock_flags);
 871
 872         found = ofdpa_flow_tbl_find(ofdpa, match);
 873
 874         if (found) {
 875                 if (!switchdev_trans_ph_prepare(trans))
 876                         hash_del(&found->entry);
 877                 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_DEL;
 878         }
 879
 880         spin_unlock_irqrestore(&ofdpa->flow_tbl_lock, lock_flags);
 881
 882         ofdpa_kfree(trans, match);
 883
 884         if (found) {
 885                 if (!switchdev_trans_ph_prepare(trans))
 886                         err = rocker_cmd_exec(ofdpa_port->rocker_port,
 887                                               ofdpa_flags_nowait(flags),
 888                                               ofdpa_cmd_flow_tbl_del,
 889                                               found, NULL, NULL);
 890                 ofdpa_kfree(trans, found);
 891         }
 892
 893         return err;
 894 }
 895
 896 static int ofdpa_flow_tbl_do(struct ofdpa_port *ofdpa_port,
 897                              struct switchdev_trans *trans, int flags,
 898                              struct ofdpa_flow_tbl_entry *entry)
 899 {
 900         if (flags & OFDPA_OP_FLAG_REMOVE)
 901                 return ofdpa_flow_tbl_del(ofdpa_port, trans, flags, entry);
 902         else
 903                 return ofdpa_flow_tbl_add(ofdpa_port, trans, flags, entry);
 904 }
 905
 906 static int ofdpa_flow_tbl_ig_port(struct ofdpa_port *ofdpa_port,
 907                                   struct switchdev_trans *trans, int flags,
 908                                   u32 in_pport, u32 in_pport_mask,
 909                                   enum rocker_of_dpa_table_id goto_tbl)
 910 {
 911         struct ofdpa_flow_tbl_entry *entry;
 912
 913         entry = ofdpa_kzalloc(trans, flags, sizeof(*entry));
 914         if (!entry)
 915                 return -ENOMEM;
 916
 917         entry->key.priority = OFDPA_PRIORITY_IG_PORT;
 918         entry->key.tbl_id = ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT;
 919         entry->key.ig_port.in_pport = in_pport;
 920         entry->key.ig_port.in_pport_mask = in_pport_mask;
 921         entry->key.ig_port.goto_tbl = goto_tbl;
 922
 923         return ofdpa_flow_tbl_do(ofdpa_port, trans, flags, entry);
 924 }
 925
 926 static int ofdpa_flow_tbl_vlan(struct ofdpa_port *ofdpa_port,
 927                                struct switchdev_trans *trans, int flags,
 928                                u32 in_pport, __be16 vlan_id,
 929                                __be16 vlan_id_mask,
 930                                enum rocker_of_dpa_table_id goto_tbl,
 931                                bool untagged, __be16 new_vlan_id)
 932 {
 933         struct ofdpa_flow_tbl_entry *entry;
 934
 935         entry = ofdpa_kzalloc(trans, flags, sizeof(*entry));
 936         if (!entry)
 937                 return -ENOMEM;
 938
 939         entry->key.priority = OFDPA_PRIORITY_VLAN;
 940         entry->key.tbl_id = ROCKER_OF_DPA_TABLE_ID_VLAN;
 941         entry->key.vlan.in_pport = in_pport;
 942         entry->key.vlan.vlan_id = vlan_id;
 943         entry->key.vlan.vlan_id_mask = vlan_id_mask;
 944         entry->key.vlan.goto_tbl = goto_tbl;
 945
 946         entry->key.vlan.untagged = untagged;
 947         entry->key.vlan.new_vlan_id = new_vlan_id;
 948
 949         return ofdpa_flow_tbl_do(ofdpa_port, trans, flags, entry);
 950 }
 951
 952 static int ofdpa_flow_tbl_term_mac(struct ofdpa_port *ofdpa_port,
 953                                    struct switchdev_trans *trans,
 954                                    u32 in_pport, u32 in_pport_mask,
 955                                    __be16 eth_type, const u8 *eth_dst,
 956                                    const u8 *eth_dst_mask, __be16 vlan_id,
 957                                    __be16 vlan_id_mask, bool copy_to_cpu,
 958                                    int flags)
 959 {
 960         struct ofdpa_flow_tbl_entry *entry;
 961
 962         entry = ofdpa_kzalloc(trans, flags, sizeof(*entry));
 963         if (!entry)
 964                 return -ENOMEM;
 965
 966         if (is_multicast_ether_addr(eth_dst)) {
 967                 entry->key.priority = OFDPA_PRIORITY_TERM_MAC_MCAST;
 968                 entry->key.term_mac.goto_tbl =
 969                          ROCKER_OF_DPA_TABLE_ID_MULTICAST_ROUTING;
 970         } else {
 971                 entry->key.priority = OFDPA_PRIORITY_TERM_MAC_UCAST;
 972                 entry->key.term_mac.goto_tbl =
 973                          ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING;
 974         }
 975
 976         entry->key.tbl_id = ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC;
 977         entry->key.term_mac.in_pport = in_pport;
 978         entry->key.term_mac.in_pport_mask = in_pport_mask;
 979         entry->key.term_mac.eth_type = eth_type;
 980         ether_addr_copy(entry->key.term_mac.eth_dst, eth_dst);
 981         ether_addr_copy(entry->key.term_mac.eth_dst_mask, eth_dst_mask);
 982         entry->key.term_mac.vlan_id = vlan_id;
 983         entry->key.term_mac.vlan_id_mask = vlan_id_mask;
 984         entry->key.term_mac.copy_to_cpu = copy_to_cpu;
 985
 986         return ofdpa_flow_tbl_do(ofdpa_port, trans, flags, entry);
 987 }
 988
 989 static int ofdpa_flow_tbl_bridge(struct ofdpa_port *ofdpa_port,
 990                                  struct switchdev_trans *trans, int flags,
 991                                  const u8 *eth_dst, const u8 *eth_dst_mask,
 992                                  __be16 vlan_id, u32 tunnel_id,
 993                                  enum rocker_of_dpa_table_id goto_tbl,
 994                                  u32 group_id, bool copy_to_cpu)
 995 {
 996         struct ofdpa_flow_tbl_entry *entry;
 997         u32 priority;
 998         bool vlan_bridging = !!vlan_id;
 999         bool dflt = !eth_dst || (eth_dst && eth_dst_mask);
1000         bool wild = false;
1001
1002         entry = ofdpa_kzalloc(trans, flags, sizeof(*entry));
1003         if (!entry)
1004                 return -ENOMEM;
1005
1006         entry->key.tbl_id = ROCKER_OF_DPA_TABLE_ID_BRIDGING;
1007
1008         if (eth_dst) {
1009                 entry->key.bridge.has_eth_dst = 1;
1010                 ether_addr_copy(entry->key.bridge.eth_dst, eth_dst);
1011         }
1012         if (eth_dst_mask) {
1013                 entry->key.bridge.has_eth_dst_mask = 1;
1014                 ether_addr_copy(entry->key.bridge.eth_dst_mask, eth_dst_mask);
1015                 if (!ether_addr_equal(eth_dst_mask, ff_mac))
1016                         wild = true;
1017         }
1018
1019         priority = OFDPA_PRIORITY_UNKNOWN;
1020         if (vlan_bridging && dflt && wild)
1021                 priority = OFDPA_PRIORITY_BRIDGING_VLAN_DFLT_WILD;
1022         else if (vlan_bridging && dflt && !wild)
1023                 priority = OFDPA_PRIORITY_BRIDGING_VLAN_DFLT_EXACT;
1024         else if (vlan_bridging && !dflt)
1025                 priority = OFDPA_PRIORITY_BRIDGING_VLAN;
1026         else if (!vlan_bridging && dflt && wild)
1027                 priority = OFDPA_PRIORITY_BRIDGING_TENANT_DFLT_WILD;
1028         else if (!vlan_bridging && dflt && !wild)
1029                 priority = OFDPA_PRIORITY_BRIDGING_TENANT_DFLT_EXACT;
1030         else if (!vlan_bridging && !dflt)
1031                 priority = OFDPA_PRIORITY_BRIDGING_TENANT;
1032
1033         entry->key.priority = priority;
1034         entry->key.bridge.vlan_id = vlan_id;
1035         entry->key.bridge.tunnel_id = tunnel_id;
1036         entry->key.bridge.goto_tbl = goto_tbl;
1037         entry->key.bridge.group_id = group_id;
1038         entry->key.bridge.copy_to_cpu = copy_to_cpu;
1039
1040         return ofdpa_flow_tbl_do(ofdpa_port, trans, flags, entry);
1041 }
1042
1043 static int ofdpa_flow_tbl_ucast4_routing(struct ofdpa_port *ofdpa_port,
1044                                          struct switchdev_trans *trans,
1045                                          __be16 eth_type, __be32 dst,
1046                                          __be32 dst_mask, u32 priority,
1047                                          enum rocker_of_dpa_table_id goto_tbl,
1048                                          u32 group_id, struct fib_info *fi,
1049                                          int flags)
1050 {
1051         struct ofdpa_flow_tbl_entry *entry;
1052
1053         entry = ofdpa_kzalloc(trans, flags, sizeof(*entry));
1054         if (!entry)
1055                 return -ENOMEM;
1056
1057         entry->key.tbl_id = ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING;
1058         entry->key.priority = priority;
1059         entry->key.ucast_routing.eth_type = eth_type;
1060         entry->key.ucast_routing.dst4 = dst;
1061         entry->key.ucast_routing.dst4_mask = dst_mask;
1062         entry->key.ucast_routing.goto_tbl = goto_tbl;
1063         entry->key.ucast_routing.group_id = group_id;
1064         entry->key_len = offsetof(struct ofdpa_flow_tbl_key,
1065                                   ucast_routing.group_id);
1066         entry->fi = fi;
1067
1068         return ofdpa_flow_tbl_do(ofdpa_port, trans, flags, entry);
1069 }
1070
1071 static int ofdpa_flow_tbl_acl(struct ofdpa_port *ofdpa_port,
1072                               struct switchdev_trans *trans, int flags,
1073                               u32 in_pport, u32 in_pport_mask,
1074                               const u8 *eth_src, const u8 *eth_src_mask,
1075                               const u8 *eth_dst, const u8 *eth_dst_mask,
1076                               __be16 eth_type, __be16 vlan_id,
1077                               __be16 vlan_id_mask, u8 ip_proto,
1078                               u8 ip_proto_mask, u8 ip_tos, u8 ip_tos_mask,
1079                               u32 group_id)
1080 {
1081         u32 priority;
1082         struct ofdpa_flow_tbl_entry *entry;
1083
1084         entry = ofdpa_kzalloc(trans, flags, sizeof(*entry));
1085         if (!entry)
1086                 return -ENOMEM;
1087
1088         priority = OFDPA_PRIORITY_ACL_NORMAL;
1089         if (eth_dst && eth_dst_mask) {
1090                 if (ether_addr_equal(eth_dst_mask, mcast_mac))
1091                         priority = OFDPA_PRIORITY_ACL_DFLT;
1092                 else if (is_link_local_ether_addr(eth_dst))
1093                         priority = OFDPA_PRIORITY_ACL_CTRL;
1094         }
1095
1096         entry->key.priority = priority;
1097         entry->key.tbl_id = ROCKER_OF_DPA_TABLE_ID_ACL_POLICY;
1098         entry->key.acl.in_pport = in_pport;
1099         entry->key.acl.in_pport_mask = in_pport_mask;
1100
1101         if (eth_src)
1102                 ether_addr_copy(entry->key.acl.eth_src, eth_src);
1103         if (eth_src_mask)
1104                 ether_addr_copy(entry->key.acl.eth_src_mask, eth_src_mask);
1105         if (eth_dst)
1106                 ether_addr_copy(entry->key.acl.eth_dst, eth_dst);
1107         if (eth_dst_mask)
1108                 ether_addr_copy(entry->key.acl.eth_dst_mask, eth_dst_mask);
1109
1110         entry->key.acl.eth_type = eth_type;
1111         entry->key.acl.vlan_id = vlan_id;
1112         entry->key.acl.vlan_id_mask = vlan_id_mask;
1113         entry->key.acl.ip_proto = ip_proto;
1114         entry->key.acl.ip_proto_mask = ip_proto_mask;
1115         entry->key.acl.ip_tos = ip_tos;
1116         entry->key.acl.ip_tos_mask = ip_tos_mask;
1117         entry->key.acl.group_id = group_id;
1118
1119         return ofdpa_flow_tbl_do(ofdpa_port, trans, flags, entry);
1120 }
1121
1122 static struct ofdpa_group_tbl_entry *
1123 ofdpa_group_tbl_find(const struct ofdpa *ofdpa,
1124                      const struct ofdpa_group_tbl_entry *match)
1125 {
1126         struct ofdpa_group_tbl_entry *found;
1127
1128         hash_for_each_possible(ofdpa->group_tbl, found,
1129                                entry, match->group_id) {
1130                 if (found->group_id == match->group_id)
1131                         return found;
1132         }
1133
1134         return NULL;
1135 }
1136
1137 static void ofdpa_group_tbl_entry_free(struct switchdev_trans *trans,
1138                                        struct ofdpa_group_tbl_entry *entry)
1139 {
1140         switch (ROCKER_GROUP_TYPE_GET(entry->group_id)) {
1141         case ROCKER_OF_DPA_GROUP_TYPE_L2_FLOOD:
1142         case ROCKER_OF_DPA_GROUP_TYPE_L2_MCAST:
1143                 ofdpa_kfree(trans, entry->group_ids);
1144                 break;
1145         default:
1146                 break;
1147         }
1148         ofdpa_kfree(trans, entry);
1149 }
1150
1151 static int ofdpa_group_tbl_add(struct ofdpa_port *ofdpa_port,
1152                                struct switchdev_trans *trans, int flags,
1153                                struct ofdpa_group_tbl_entry *match)
1154 {
1155         struct ofdpa *ofdpa = ofdpa_port->ofdpa;
1156         struct ofdpa_group_tbl_entry *found;
1157         unsigned long lock_flags;
1158
1159         spin_lock_irqsave(&ofdpa->group_tbl_lock, lock_flags);
1160
1161         found = ofdpa_group_tbl_find(ofdpa, match);
1162
1163         if (found) {
1164                 if (!switchdev_trans_ph_prepare(trans))
1165                         hash_del(&found->entry);
1166                 ofdpa_group_tbl_entry_free(trans, found);
1167                 found = match;
1168                 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_MOD;
1169         } else {
1170                 found = match;
1171                 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_ADD;
1172         }
1173
1174         if (!switchdev_trans_ph_prepare(trans))
1175                 hash_add(ofdpa->group_tbl, &found->entry, found->group_id);
1176
1177         spin_unlock_irqrestore(&ofdpa->group_tbl_lock, lock_flags);
1178
1179         if (!switchdev_trans_ph_prepare(trans))
1180                 return rocker_cmd_exec(ofdpa_port->rocker_port,
1181                                        ofdpa_flags_nowait(flags),
1182                                        ofdpa_cmd_group_tbl_add,
1183                                        found, NULL, NULL);
1184         return 0;
1185 }
1186
1187 static int ofdpa_group_tbl_del(struct ofdpa_port *ofdpa_port,
1188                                struct switchdev_trans *trans, int flags,
1189                                struct ofdpa_group_tbl_entry *match)
1190 {
1191         struct ofdpa *ofdpa = ofdpa_port->ofdpa;
1192         struct ofdpa_group_tbl_entry *found;
1193         unsigned long lock_flags;
1194         int err = 0;
1195
1196         spin_lock_irqsave(&ofdpa->group_tbl_lock, lock_flags);
1197
1198         found = ofdpa_group_tbl_find(ofdpa, match);
1199
1200         if (found) {
1201                 if (!switchdev_trans_ph_prepare(trans))
1202                         hash_del(&found->entry);
1203                 found->cmd = ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_DEL;
1204         }
1205
1206         spin_unlock_irqrestore(&ofdpa->group_tbl_lock, lock_flags);
1207
1208         ofdpa_group_tbl_entry_free(trans, match);
1209
1210         if (found) {
1211                 if (!switchdev_trans_ph_prepare(trans))
1212                         err = rocker_cmd_exec(ofdpa_port->rocker_port,
1213                                               ofdpa_flags_nowait(flags),
1214                                               ofdpa_cmd_group_tbl_del,
1215                                               found, NULL, NULL);
1216                 ofdpa_group_tbl_entry_free(trans, found);
1217         }
1218
1219         return err;
1220 }
1221
1222 static int ofdpa_group_tbl_do(struct ofdpa_port *ofdpa_port,
1223                               struct switchdev_trans *trans, int flags,
1224                               struct ofdpa_group_tbl_entry *entry)
1225 {
1226         if (flags & OFDPA_OP_FLAG_REMOVE)
1227                 return ofdpa_group_tbl_del(ofdpa_port, trans, flags, entry);
1228         else
1229                 return ofdpa_group_tbl_add(ofdpa_port, trans, flags, entry);
1230 }
1231
1232 static int ofdpa_group_l2_interface(struct ofdpa_port *ofdpa_port,
1233                                     struct switchdev_trans *trans, int flags,
1234                                     __be16 vlan_id, u32 out_pport,
1235                                     int pop_vlan)
1236 {
1237         struct ofdpa_group_tbl_entry *entry;
1238
1239         entry = ofdpa_kzalloc(trans, flags, sizeof(*entry));
1240         if (!entry)
1241                 return -ENOMEM;
1242
1243         entry->group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, out_pport);
1244         entry->l2_interface.pop_vlan = pop_vlan;
1245
1246         return ofdpa_group_tbl_do(ofdpa_port, trans, flags, entry);
1247 }
1248
1249 static int ofdpa_group_l2_fan_out(struct ofdpa_port *ofdpa_port,
1250                                   struct switchdev_trans *trans,
1251                                   int flags, u8 group_count,
1252                                   const u32 *group_ids, u32 group_id)
1253 {
1254         struct ofdpa_group_tbl_entry *entry;
1255
1256         entry = ofdpa_kzalloc(trans, flags, sizeof(*entry));
1257         if (!entry)
1258                 return -ENOMEM;
1259
1260         entry->group_id = group_id;
1261         entry->group_count = group_count;
1262
1263         entry->group_ids = ofdpa_kcalloc(trans, flags,
1264                                          group_count, sizeof(u32));
1265         if (!entry->group_ids) {
1266                 ofdpa_kfree(trans, entry);
1267                 return -ENOMEM;
1268         }
1269         memcpy(entry->group_ids, group_ids, group_count * sizeof(u32));
1270
1271         return ofdpa_group_tbl_do(ofdpa_port, trans, flags, entry);
1272 }
1273
1274 static int ofdpa_group_l2_flood(struct ofdpa_port *ofdpa_port,
1275                                 struct switchdev_trans *trans, int flags,
1276                                 __be16 vlan_id, u8 group_count,
1277                                 const u32 *group_ids, u32 group_id)
1278 {
1279         return ofdpa_group_l2_fan_out(ofdpa_port, trans, flags,
1280                                       group_count, group_ids,
1281                                       group_id);
1282 }
1283
1284 static int ofdpa_group_l3_unicast(struct ofdpa_port *ofdpa_port,
1285                                   struct switchdev_trans *trans, int flags,
1286                                   u32 index, const u8 *src_mac, const u8 *dst_mac,
1287                                   __be16 vlan_id, bool ttl_check, u32 pport)
1288 {
1289         struct ofdpa_group_tbl_entry *entry;
1290
1291         entry = ofdpa_kzalloc(trans, flags, sizeof(*entry));
1292         if (!entry)
1293                 return -ENOMEM;
1294
1295         entry->group_id = ROCKER_GROUP_L3_UNICAST(index);
1296         if (src_mac)
1297                 ether_addr_copy(entry->l3_unicast.eth_src, src_mac);
1298         if (dst_mac)
1299                 ether_addr_copy(entry->l3_unicast.eth_dst, dst_mac);
1300         entry->l3_unicast.vlan_id = vlan_id;
1301         entry->l3_unicast.ttl_check = ttl_check;
1302         entry->l3_unicast.group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, pport);
1303
1304         return ofdpa_group_tbl_do(ofdpa_port, trans, flags, entry);
1305 }
1306
1307 static struct ofdpa_neigh_tbl_entry *
1308 ofdpa_neigh_tbl_find(const struct ofdpa *ofdpa, __be32 ip_addr)
1309 {
1310         struct ofdpa_neigh_tbl_entry *found;
1311
1312         hash_for_each_possible(ofdpa->neigh_tbl, found,
1313                                entry, be32_to_cpu(ip_addr))
1314                 if (found->ip_addr == ip_addr)
1315                         return found;
1316
1317         return NULL;
1318 }
1319
1320 static void ofdpa_neigh_add(struct ofdpa *ofdpa,
1321                             struct switchdev_trans *trans,
1322                             struct ofdpa_neigh_tbl_entry *entry)
1323 {
1324         if (!switchdev_trans_ph_commit(trans))
1325                 entry->index = ofdpa->neigh_tbl_next_index++;
1326         if (switchdev_trans_ph_prepare(trans))
1327                 return;
1328         entry->ref_count++;
1329         hash_add(ofdpa->neigh_tbl, &entry->entry,
1330                  be32_to_cpu(entry->ip_addr));
1331 }
1332
1333 static void ofdpa_neigh_del(struct switchdev_trans *trans,
1334                             struct ofdpa_neigh_tbl_entry *entry)
1335 {
1336         if (switchdev_trans_ph_prepare(trans))
1337                 return;
1338         if (--entry->ref_count == 0) {
1339                 hash_del(&entry->entry);
1340                 ofdpa_kfree(trans, entry);
1341         }
1342 }
1343
1344 static void ofdpa_neigh_update(struct ofdpa_neigh_tbl_entry *entry,
1345                                struct switchdev_trans *trans,
1346                                const u8 *eth_dst, bool ttl_check)
1347 {
1348         if (eth_dst) {
1349                 ether_addr_copy(entry->eth_dst, eth_dst);
1350                 entry->ttl_check = ttl_check;
1351         } else if (!switchdev_trans_ph_prepare(trans)) {
1352                 entry->ref_count++;
1353         }
1354 }
1355
1356 static int ofdpa_port_ipv4_neigh(struct ofdpa_port *ofdpa_port,
1357                                  struct switchdev_trans *trans,
1358                                  int flags, __be32 ip_addr, const u8 *eth_dst)
1359 {
1360         struct ofdpa *ofdpa = ofdpa_port->ofdpa;
1361         struct ofdpa_neigh_tbl_entry *entry;
1362         struct ofdpa_neigh_tbl_entry *found;
1363         unsigned long lock_flags;
1364         __be16 eth_type = htons(ETH_P_IP);
1365         enum rocker_of_dpa_table_id goto_tbl =
1366                         ROCKER_OF_DPA_TABLE_ID_ACL_POLICY;
1367         u32 group_id;
1368         u32 priority = 0;
1369         bool adding = !(flags & OFDPA_OP_FLAG_REMOVE);
1370         bool updating;
1371         bool removing;
1372         int err = 0;
1373
1374         entry = ofdpa_kzalloc(trans, flags, sizeof(*entry));
1375         if (!entry)
1376                 return -ENOMEM;
1377
1378         spin_lock_irqsave(&ofdpa->neigh_tbl_lock, lock_flags);
1379
1380         found = ofdpa_neigh_tbl_find(ofdpa, ip_addr);
1381
1382         updating = found && adding;
1383         removing = found && !adding;
1384         adding = !found && adding;
1385
1386         if (adding) {
1387                 entry->ip_addr = ip_addr;
1388                 entry->dev = ofdpa_port->dev;
1389                 ether_addr_copy(entry->eth_dst, eth_dst);
1390                 entry->ttl_check = true;
1391                 ofdpa_neigh_add(ofdpa, trans, entry);
1392         } else if (removing) {
1393                 memcpy(entry, found, sizeof(*entry));
1394                 ofdpa_neigh_del(trans, found);
1395         } else if (updating) {
1396                 ofdpa_neigh_update(found, trans, eth_dst, true);
1397                 memcpy(entry, found, sizeof(*entry));
1398         } else {
1399                 err = -ENOENT;
1400         }
1401
1402         spin_unlock_irqrestore(&ofdpa->neigh_tbl_lock, lock_flags);
1403
1404         if (err)
1405                 goto err_out;
1406
1407         /* For each active neighbor, we have an L3 unicast group and
1408          * a /32 route to the neighbor, which uses the L3 unicast
1409          * group.  The L3 unicast group can also be referred to by
1410          * other routes' nexthops.
1411          */
1412
1413         err = ofdpa_group_l3_unicast(ofdpa_port, trans, flags,
1414                                      entry->index,
1415                                      ofdpa_port->dev->dev_addr,
1416                                      entry->eth_dst,
1417                                      ofdpa_port->internal_vlan_id,
1418                                      entry->ttl_check,
1419                                      ofdpa_port->pport);
1420         if (err) {
1421                 netdev_err(ofdpa_port->dev, "Error (%d) L3 unicast group index %d\n",
1422                            err, entry->index);
1423                 goto err_out;
1424         }
1425
1426         if (adding || removing) {
1427                 group_id = ROCKER_GROUP_L3_UNICAST(entry->index);
1428                 err = ofdpa_flow_tbl_ucast4_routing(ofdpa_port, trans,
1429                                                     eth_type, ip_addr,
1430                                                     inet_make_mask(32),
1431                                                     priority, goto_tbl,
1432                                                     group_id, NULL, flags);
1433
1434                 if (err)
1435                         netdev_err(ofdpa_port->dev, "Error (%d) /32 unicast route %pI4 group 0x%08x\n",
1436                                    err, &entry->ip_addr, group_id);
1437         }
1438
1439 err_out:
1440         if (!adding)
1441                 ofdpa_kfree(trans, entry);
1442
1443         return err;
1444 }
1445
1446 static int ofdpa_port_ipv4_resolve(struct ofdpa_port *ofdpa_port,
1447                                    struct switchdev_trans *trans,
1448                                    __be32 ip_addr)
1449 {
1450         struct net_device *dev = ofdpa_port->dev;
1451         struct neighbour *n = __ipv4_neigh_lookup(dev, (__force u32)ip_addr);
1452         int err = 0;
1453
1454         if (!n) {
1455                 n = neigh_create(&arp_tbl, &ip_addr, dev);
1456                 if (IS_ERR(n))
1457                         return PTR_ERR(n);
1458         }
1459
1460         /* If the neigh is already resolved, then go ahead and
1461          * install the entry, otherwise start the ARP process to
1462          * resolve the neigh.
1463          */
1464
1465         if (n->nud_state & NUD_VALID)
1466                 err = ofdpa_port_ipv4_neigh(ofdpa_port, trans, 0,
1467                                             ip_addr, n->ha);
1468         else
1469                 neigh_event_send(n, NULL);
1470
1471         neigh_release(n);
1472         return err;
1473 }
1474
1475 static int ofdpa_port_ipv4_nh(struct ofdpa_port *ofdpa_port,
1476                               struct switchdev_trans *trans, int flags,
1477                               __be32 ip_addr, u32 *index)
1478 {
1479         struct ofdpa *ofdpa = ofdpa_port->ofdpa;
1480         struct ofdpa_neigh_tbl_entry *entry;
1481         struct ofdpa_neigh_tbl_entry *found;
1482         unsigned long lock_flags;
1483         bool adding = !(flags & OFDPA_OP_FLAG_REMOVE);
1484         bool updating;
1485         bool removing;
1486         bool resolved = true;
1487         int err = 0;
1488
1489         entry = ofdpa_kzalloc(trans, flags, sizeof(*entry));
1490         if (!entry)
1491                 return -ENOMEM;
1492
1493         spin_lock_irqsave(&ofdpa->neigh_tbl_lock, lock_flags);
1494
1495         found = ofdpa_neigh_tbl_find(ofdpa, ip_addr);
1496
1497         updating = found && adding;
1498         removing = found && !adding;
1499         adding = !found && adding;
1500
1501         if (adding) {
1502                 entry->ip_addr = ip_addr;
1503                 entry->dev = ofdpa_port->dev;
1504                 ofdpa_neigh_add(ofdpa, trans, entry);
1505                 *index = entry->index;
1506                 resolved = false;
1507         } else if (removing) {
1508                 ofdpa_neigh_del(trans, found);
1509                 *index = found->index;
1510         } else if (updating) {
1511                 ofdpa_neigh_update(found, trans, NULL, false);
1512                 resolved = !is_zero_ether_addr(found->eth_dst);
1513                 *index = found->index;
1514         } else {
1515                 err = -ENOENT;
1516         }
1517
1518         spin_unlock_irqrestore(&ofdpa->neigh_tbl_lock, lock_flags);
1519
1520         if (!adding)
1521                 ofdpa_kfree(trans, entry);
1522
1523         if (err)
1524                 return err;
1525
1526         /* Resolved means neigh ip_addr is resolved to neigh mac. */
1527
1528         if (!resolved)
1529                 err = ofdpa_port_ipv4_resolve(ofdpa_port, trans, ip_addr);
1530
1531         return err;
1532 }
1533
1534 static struct ofdpa_port *ofdpa_port_get(const struct ofdpa *ofdpa,
1535                                          int port_index)
1536 {
1537         struct rocker_port *rocker_port;
1538
1539         rocker_port = ofdpa->rocker->ports[port_index];
1540         return rocker_port ? rocker_port->wpriv : NULL;
1541 }
1542
1543 static int ofdpa_port_vlan_flood_group(struct ofdpa_port *ofdpa_port,
1544                                        struct switchdev_trans *trans,
1545                                        int flags, __be16 vlan_id)
1546 {
1547         struct ofdpa_port *p;
1548         const struct ofdpa *ofdpa = ofdpa_port->ofdpa;
1549         unsigned int port_count = ofdpa->rocker->port_count;
1550         u32 group_id = ROCKER_GROUP_L2_FLOOD(vlan_id, 0);
1551         u32 *group_ids;
1552         u8 group_count = 0;
1553         int err = 0;
1554         int i;
1555
1556         group_ids = ofdpa_kcalloc(trans, flags, port_count, sizeof(u32));
1557         if (!group_ids)
1558                 return -ENOMEM;
1559
1560         /* Adjust the flood group for this VLAN.  The flood group
1561          * references an L2 interface group for each port in this
1562          * VLAN.
1563          */
1564
1565         for (i = 0; i < port_count; i++) {
1566                 p = ofdpa_port_get(ofdpa, i);
1567                 if (!p)
1568                         continue;
1569                 if (!ofdpa_port_is_bridged(p))
1570                         continue;
1571                 if (test_bit(ntohs(vlan_id), p->vlan_bitmap)) {
1572                         group_ids[group_count++] =
1573                                 ROCKER_GROUP_L2_INTERFACE(vlan_id, p->pport);
1574                 }
1575         }
1576
1577         /* If there are no bridged ports in this VLAN, we're done */
1578         if (group_count == 0)
1579                 goto no_ports_in_vlan;
1580
1581         err = ofdpa_group_l2_flood(ofdpa_port, trans, flags, vlan_id,
1582                                    group_count, group_ids, group_id);
1583         if (err)
1584                 netdev_err(ofdpa_port->dev, "Error (%d) port VLAN l2 flood group\n", err);
1585
1586 no_ports_in_vlan:
1587         ofdpa_kfree(trans, group_ids);
1588         return err;
1589 }
1590
1591 static int ofdpa_port_vlan_l2_groups(struct ofdpa_port *ofdpa_port,
1592                                      struct switchdev_trans *trans, int flags,
1593                                      __be16 vlan_id, bool pop_vlan)
1594 {
1595         const struct ofdpa *ofdpa = ofdpa_port->ofdpa;
1596         unsigned int port_count = ofdpa->rocker->port_count;
1597         struct ofdpa_port *p;
1598         bool adding = !(flags & OFDPA_OP_FLAG_REMOVE);
1599         u32 out_pport;
1600         int ref = 0;
1601         int err;
1602         int i;
1603
1604         /* An L2 interface group for this port in this VLAN, but
1605          * only when port STP state is LEARNING|FORWARDING.
1606          */
1607
1608         if (ofdpa_port->stp_state == BR_STATE_LEARNING ||
1609             ofdpa_port->stp_state == BR_STATE_FORWARDING) {
1610                 out_pport = ofdpa_port->pport;
1611                 err = ofdpa_group_l2_interface(ofdpa_port, trans, flags,
1612                                                vlan_id, out_pport, pop_vlan);
1613                 if (err) {
1614                         netdev_err(ofdpa_port->dev, "Error (%d) port VLAN l2 group for pport %d\n",
1615                                    err, out_pport);
1616                         return err;
1617                 }
1618         }
1619
1620         /* An L2 interface group for this VLAN to CPU port.
1621          * Add when first port joins this VLAN and destroy when
1622          * last port leaves this VLAN.
1623          */
1624
1625         for (i = 0; i < port_count; i++) {
1626                 p = ofdpa_port_get(ofdpa, i);
1627                 if (p && test_bit(ntohs(vlan_id), p->vlan_bitmap))
1628                         ref++;
1629         }
1630
1631         if ((!adding || ref != 1) && (adding || ref != 0))
1632                 return 0;
1633
1634         out_pport = 0;
1635         err = ofdpa_group_l2_interface(ofdpa_port, trans, flags,
1636                                        vlan_id, out_pport, pop_vlan);
1637         if (err) {
1638                 netdev_err(ofdpa_port->dev, "Error (%d) port VLAN l2 group for CPU port\n", err);
1639                 return err;
1640         }
1641
1642         return 0;
1643 }
1644
1645 static struct ofdpa_ctrl {
1646         const u8 *eth_dst;
1647         const u8 *eth_dst_mask;
1648         __be16 eth_type;
1649         bool acl;
1650         bool bridge;
1651         bool term;
1652         bool copy_to_cpu;
1653 } ofdpa_ctrls[] = {
1654         [OFDPA_CTRL_LINK_LOCAL_MCAST] = {
1655                 /* pass link local multicast pkts up to CPU for filtering */
1656                 .eth_dst = ll_mac,
1657                 .eth_dst_mask = ll_mask,
1658                 .acl = true,
1659         },
1660         [OFDPA_CTRL_LOCAL_ARP] = {
1661                 /* pass local ARP pkts up to CPU */
1662                 .eth_dst = zero_mac,
1663                 .eth_dst_mask = zero_mac,
1664                 .eth_type = htons(ETH_P_ARP),
1665                 .acl = true,
1666         },
1667         [OFDPA_CTRL_IPV4_MCAST] = {
1668                 /* pass IPv4 mcast pkts up to CPU, RFC 1112 */
1669                 .eth_dst = ipv4_mcast,
1670                 .eth_dst_mask = ipv4_mask,
1671                 .eth_type = htons(ETH_P_IP),
1672                 .term  = true,
1673                 .copy_to_cpu = true,
1674         },
1675         [OFDPA_CTRL_IPV6_MCAST] = {
1676                 /* pass IPv6 mcast pkts up to CPU, RFC 2464 */
1677                 .eth_dst = ipv6_mcast,
1678                 .eth_dst_mask = ipv6_mask,
1679                 .eth_type = htons(ETH_P_IPV6),
1680                 .term  = true,
1681                 .copy_to_cpu = true,
1682         },
1683         [OFDPA_CTRL_DFLT_BRIDGING] = {
1684                 /* flood any pkts on vlan */
1685                 .bridge = true,
1686                 .copy_to_cpu = true,
1687         },
1688         [OFDPA_CTRL_DFLT_OVS] = {
1689                 /* pass all pkts up to CPU */
1690                 .eth_dst = zero_mac,
1691                 .eth_dst_mask = zero_mac,
1692                 .acl = true,
1693         },
1694 };
1695
1696 static int ofdpa_port_ctrl_vlan_acl(struct ofdpa_port *ofdpa_port,
1697                                     struct switchdev_trans *trans, int flags,
1698                                     const struct ofdpa_ctrl *ctrl, __be16 vlan_id)
1699 {
1700         u32 in_pport = ofdpa_port->pport;
1701         u32 in_pport_mask = 0xffffffff;
1702         u32 out_pport = 0;
1703         const u8 *eth_src = NULL;
1704         const u8 *eth_src_mask = NULL;
1705         __be16 vlan_id_mask = htons(0xffff);
1706         u8 ip_proto = 0;
1707         u8 ip_proto_mask = 0;
1708         u8 ip_tos = 0;
1709         u8 ip_tos_mask = 0;
1710         u32 group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, out_pport);
1711         int err;
1712
1713         err = ofdpa_flow_tbl_acl(ofdpa_port, trans, flags,
1714                                  in_pport, in_pport_mask,
1715                                  eth_src, eth_src_mask,
1716                                  ctrl->eth_dst, ctrl->eth_dst_mask,
1717                                  ctrl->eth_type,
1718                                  vlan_id, vlan_id_mask,
1719                                  ip_proto, ip_proto_mask,
1720                                  ip_tos, ip_tos_mask,
1721                                  group_id);
1722
1723         if (err)
1724                 netdev_err(ofdpa_port->dev, "Error (%d) ctrl ACL\n", err);
1725
1726         return err;
1727 }
1728
1729 static int ofdpa_port_ctrl_vlan_bridge(struct ofdpa_port *ofdpa_port,
1730                                        struct switchdev_trans *trans,
1731                                        int flags,
1732                                        const struct ofdpa_ctrl *ctrl,
1733                                        __be16 vlan_id)
1734 {
1735         enum rocker_of_dpa_table_id goto_tbl =
1736                         ROCKER_OF_DPA_TABLE_ID_ACL_POLICY;
1737         u32 group_id = ROCKER_GROUP_L2_FLOOD(vlan_id, 0);
1738         u32 tunnel_id = 0;
1739         int err;
1740
1741         if (!ofdpa_port_is_bridged(ofdpa_port))
1742                 return 0;
1743
1744         err = ofdpa_flow_tbl_bridge(ofdpa_port, trans, flags,
1745                                     ctrl->eth_dst, ctrl->eth_dst_mask,
1746                                     vlan_id, tunnel_id,
1747                                     goto_tbl, group_id, ctrl->copy_to_cpu);
1748
1749         if (err)
1750                 netdev_err(ofdpa_port->dev, "Error (%d) ctrl FLOOD\n", err);
1751
1752         return err;
1753 }
1754
1755 static int ofdpa_port_ctrl_vlan_term(struct ofdpa_port *ofdpa_port,
1756                                      struct switchdev_trans *trans, int flags,
1757                                      const struct ofdpa_ctrl *ctrl, __be16 vlan_id)
1758 {
1759         u32 in_pport_mask = 0xffffffff;
1760         __be16 vlan_id_mask = htons(0xffff);
1761         int err;
1762
1763         if (ntohs(vlan_id) == 0)
1764                 vlan_id = ofdpa_port->internal_vlan_id;
1765
1766         err = ofdpa_flow_tbl_term_mac(ofdpa_port, trans,
1767                                       ofdpa_port->pport, in_pport_mask,
1768                                       ctrl->eth_type, ctrl->eth_dst,
1769                                       ctrl->eth_dst_mask, vlan_id,
1770                                       vlan_id_mask, ctrl->copy_to_cpu,
1771                                       flags);
1772
1773         if (err)
1774                 netdev_err(ofdpa_port->dev, "Error (%d) ctrl term\n", err);
1775
1776         return err;
1777 }
1778
1779 static int ofdpa_port_ctrl_vlan(struct ofdpa_port *ofdpa_port,
1780                                 struct switchdev_trans *trans, int flags,
1781                                 const struct ofdpa_ctrl *ctrl, __be16 vlan_id)
1782 {
1783         if (ctrl->acl)
1784                 return ofdpa_port_ctrl_vlan_acl(ofdpa_port, trans, flags,
1785                                                 ctrl, vlan_id);
1786         if (ctrl->bridge)
1787                 return ofdpa_port_ctrl_vlan_bridge(ofdpa_port, trans, flags,
1788                                                    ctrl, vlan_id);
1789
1790         if (ctrl->term)
1791                 return ofdpa_port_ctrl_vlan_term(ofdpa_port, trans, flags,
1792                                                  ctrl, vlan_id);
1793
1794         return -EOPNOTSUPP;
1795 }
1796
1797 static int ofdpa_port_ctrl_vlan_add(struct ofdpa_port *ofdpa_port,
1798                                     struct switchdev_trans *trans, int flags,
1799                                     __be16 vlan_id)
1800 {
1801         int err = 0;
1802         int i;
1803
1804         for (i = 0; i < OFDPA_CTRL_MAX; i++) {
1805                 if (ofdpa_port->ctrls[i]) {
1806                         err = ofdpa_port_ctrl_vlan(ofdpa_port, trans, flags,
1807                                                    &ofdpa_ctrls[i], vlan_id);
1808                         if (err)
1809                                 return err;
1810                 }
1811         }
1812
1813         return err;
1814 }
1815
1816 static int ofdpa_port_ctrl(struct ofdpa_port *ofdpa_port,
1817                            struct switchdev_trans *trans, int flags,
1818                            const struct ofdpa_ctrl *ctrl)
1819 {
1820         u16 vid;
1821         int err = 0;
1822
1823         for (vid = 1; vid < VLAN_N_VID; vid++) {
1824                 if (!test_bit(vid, ofdpa_port->vlan_bitmap))
1825                         continue;
1826                 err = ofdpa_port_ctrl_vlan(ofdpa_port, trans, flags,
1827                                            ctrl, htons(vid));
1828                 if (err)
1829                         break;
1830         }
1831
1832         return err;
1833 }
1834
1835 static int ofdpa_port_vlan(struct ofdpa_port *ofdpa_port,
1836                            struct switchdev_trans *trans, int flags, u16 vid)
1837 {
1838         enum rocker_of_dpa_table_id goto_tbl =
1839                         ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC;
1840         u32 in_pport = ofdpa_port->pport;
1841         __be16 vlan_id = htons(vid);
1842         __be16 vlan_id_mask = htons(0xffff);
1843         __be16 internal_vlan_id;
1844         bool untagged;
1845         bool adding = !(flags & OFDPA_OP_FLAG_REMOVE);
1846         int err;
1847
1848         internal_vlan_id = ofdpa_port_vid_to_vlan(ofdpa_port, vid, &untagged);
1849
1850         if (adding &&
1851             test_bit(ntohs(internal_vlan_id), ofdpa_port->vlan_bitmap))
1852                 return 0; /* already added */
1853         else if (!adding &&
1854                  !test_bit(ntohs(internal_vlan_id), ofdpa_port->vlan_bitmap))
1855                 return 0; /* already removed */
1856
1857         change_bit(ntohs(internal_vlan_id), ofdpa_port->vlan_bitmap);
1858
1859         if (adding) {
1860                 err = ofdpa_port_ctrl_vlan_add(ofdpa_port, trans, flags,
1861                                                internal_vlan_id);
1862                 if (err) {
1863                         netdev_err(ofdpa_port->dev, "Error (%d) port ctrl vlan add\n", err);
1864                         goto err_out;
1865                 }
1866         }
1867
1868         err = ofdpa_port_vlan_l2_groups(ofdpa_port, trans, flags,
1869                                         internal_vlan_id, untagged);
1870         if (err) {
1871                 netdev_err(ofdpa_port->dev, "Error (%d) port VLAN l2 groups\n", err);
1872                 goto err_out;
1873         }
1874
1875         err = ofdpa_port_vlan_flood_group(ofdpa_port, trans, flags,
1876                                           internal_vlan_id);
1877         if (err) {
1878                 netdev_err(ofdpa_port->dev, "Error (%d) port VLAN l2 flood group\n", err);
1879                 goto err_out;
1880         }
1881
1882         err = ofdpa_flow_tbl_vlan(ofdpa_port, trans, flags,
1883                                   in_pport, vlan_id, vlan_id_mask,
1884                                   goto_tbl, untagged, internal_vlan_id);
1885         if (err)
1886                 netdev_err(ofdpa_port->dev, "Error (%d) port VLAN table\n", err);
1887
1888 err_out:
1889         if (switchdev_trans_ph_prepare(trans))
1890                 change_bit(ntohs(internal_vlan_id), ofdpa_port->vlan_bitmap);
1891
1892         return err;
1893 }
1894
1895 static int ofdpa_port_ig_tbl(struct ofdpa_port *ofdpa_port,
1896                              struct switchdev_trans *trans, int flags)
1897 {
1898         enum rocker_of_dpa_table_id goto_tbl;
1899         u32 in_pport;
1900         u32 in_pport_mask;
1901         int err;
1902
1903         /* Normal Ethernet Frames.  Matches pkts from any local physical
1904          * ports.  Goto VLAN tbl.
1905          */
1906
1907         in_pport = 0;
1908         in_pport_mask = 0xffff0000;
1909         goto_tbl = ROCKER_OF_DPA_TABLE_ID_VLAN;
1910
1911         err = ofdpa_flow_tbl_ig_port(ofdpa_port, trans, flags,
1912                                      in_pport, in_pport_mask,
1913                                      goto_tbl);
1914         if (err)
1915                 netdev_err(ofdpa_port->dev, "Error (%d) ingress port table entry\n", err);
1916
1917         return err;
1918 }
1919
1920 struct ofdpa_fdb_learn_work {
1921         struct work_struct work;
1922         struct ofdpa_port *ofdpa_port;
1923         struct switchdev_trans *trans;
1924         int flags;
1925         u8 addr[ETH_ALEN];
1926         u16 vid;
1927 };
1928
1929 static void ofdpa_port_fdb_learn_work(struct work_struct *work)
1930 {
1931         const struct ofdpa_fdb_learn_work *lw =
1932                 container_of(work, struct ofdpa_fdb_learn_work, work);
1933         bool removing = (lw->flags & OFDPA_OP_FLAG_REMOVE);
1934         bool learned = (lw->flags & OFDPA_OP_FLAG_LEARNED);
1935         struct switchdev_notifier_fdb_info info;
1936
1937         info.addr = lw->addr;
1938         info.vid = lw->vid;
1939
1940         rtnl_lock();
1941         if (learned && removing)
1942                 call_switchdev_notifiers(SWITCHDEV_FDB_DEL,
1943                                          lw->ofdpa_port->dev, &info.info);
1944         else if (learned && !removing)
1945                 call_switchdev_notifiers(SWITCHDEV_FDB_ADD,
1946                                          lw->ofdpa_port->dev, &info.info);
1947         rtnl_unlock();
1948
1949         ofdpa_kfree(lw->trans, work);
1950 }
1951
1952 static int ofdpa_port_fdb_learn(struct ofdpa_port *ofdpa_port,
1953                                 struct switchdev_trans *trans, int flags,
1954                                 const u8 *addr, __be16 vlan_id)
1955 {
1956         struct ofdpa_fdb_learn_work *lw;
1957         enum rocker_of_dpa_table_id goto_tbl =
1958                         ROCKER_OF_DPA_TABLE_ID_ACL_POLICY;
1959         u32 out_pport = ofdpa_port->pport;
1960         u32 tunnel_id = 0;
1961         u32 group_id = ROCKER_GROUP_NONE;
1962         bool syncing = !!(ofdpa_port->brport_flags & BR_LEARNING_SYNC);
1963         bool copy_to_cpu = false;
1964         int err;
1965
1966         if (ofdpa_port_is_bridged(ofdpa_port))
1967                 group_id = ROCKER_GROUP_L2_INTERFACE(vlan_id, out_pport);
1968
1969         if (!(flags & OFDPA_OP_FLAG_REFRESH)) {
1970                 err = ofdpa_flow_tbl_bridge(ofdpa_port, trans, flags, addr,
1971                                             NULL, vlan_id, tunnel_id, goto_tbl,
1972                                             group_id, copy_to_cpu);
1973                 if (err)
1974                         return err;
1975         }
1976
1977         if (!syncing)
1978                 return 0;
1979
1980         if (!ofdpa_port_is_bridged(ofdpa_port))
1981                 return 0;
1982
1983         lw = ofdpa_kzalloc(trans, flags, sizeof(*lw));
1984         if (!lw)
1985                 return -ENOMEM;
1986
1987         INIT_WORK(&lw->work, ofdpa_port_fdb_learn_work);
1988
1989         lw->ofdpa_port = ofdpa_port;
1990         lw->trans = trans;
1991         lw->flags = flags;
1992         ether_addr_copy(lw->addr, addr);
1993         lw->vid = ofdpa_port_vlan_to_vid(ofdpa_port, vlan_id);
1994
1995         if (switchdev_trans_ph_prepare(trans))
1996                 ofdpa_kfree(trans, lw);
1997         else
1998                 schedule_work(&lw->work);
1999
2000         return 0;
2001 }
2002
2003 static struct ofdpa_fdb_tbl_entry *
2004 ofdpa_fdb_tbl_find(const struct ofdpa *ofdpa,
2005                    const struct ofdpa_fdb_tbl_entry *match)
2006 {
2007         struct ofdpa_fdb_tbl_entry *found;
2008
2009         hash_for_each_possible(ofdpa->fdb_tbl, found, entry, match->key_crc32)
2010                 if (memcmp(&found->key, &match->key, sizeof(found->key)) == 0)
2011                         return found;
2012
2013         return NULL;
2014 }
2015
2016 static int ofdpa_port_fdb(struct ofdpa_port *ofdpa_port,
2017                           struct switchdev_trans *trans,
2018                           const unsigned char *addr,
2019                           __be16 vlan_id, int flags)
2020 {
2021         struct ofdpa *ofdpa = ofdpa_port->ofdpa;
2022         struct ofdpa_fdb_tbl_entry *fdb;
2023         struct ofdpa_fdb_tbl_entry *found;
2024         bool removing = (flags & OFDPA_OP_FLAG_REMOVE);
2025         unsigned long lock_flags;
2026
2027         fdb = ofdpa_kzalloc(trans, flags, sizeof(*fdb));
2028         if (!fdb)
2029                 return -ENOMEM;
2030
2031         fdb->learned = (flags & OFDPA_OP_FLAG_LEARNED);
2032         fdb->touched = jiffies;
2033         fdb->key.ofdpa_port = ofdpa_port;
2034         ether_addr_copy(fdb->key.addr, addr);
2035         fdb->key.vlan_id = vlan_id;
2036         fdb->key_crc32 = crc32(~0, &fdb->key, sizeof(fdb->key));
2037
2038         spin_lock_irqsave(&ofdpa->fdb_tbl_lock, lock_flags);
2039
2040         found = ofdpa_fdb_tbl_find(ofdpa, fdb);
2041
2042         if (found) {
2043                 found->touched = jiffies;
2044                 if (removing) {
2045                         ofdpa_kfree(trans, fdb);
2046                         if (!switchdev_trans_ph_prepare(trans))
2047                                 hash_del(&found->entry);
2048                 }
2049         } else if (!removing) {
2050                 if (!switchdev_trans_ph_prepare(trans))
2051                         hash_add(ofdpa->fdb_tbl, &fdb->entry,
2052                                  fdb->key_crc32);
2053         }
2054
2055         spin_unlock_irqrestore(&ofdpa->fdb_tbl_lock, lock_flags);
2056
2057         /* Check if adding and already exists, or removing and can't find */
2058         if (!found != !removing) {
2059                 ofdpa_kfree(trans, fdb);
2060                 if (!found && removing)
2061                         return 0;
2062                 /* Refreshing existing to update aging timers */
2063                 flags |= OFDPA_OP_FLAG_REFRESH;
2064         }
2065
2066         return ofdpa_port_fdb_learn(ofdpa_port, trans, flags, addr, vlan_id);
2067 }
2068
2069 static int ofdpa_port_fdb_flush(struct ofdpa_port *ofdpa_port,
2070                                 struct switchdev_trans *trans, int flags)
2071 {
2072         struct ofdpa *ofdpa = ofdpa_port->ofdpa;
2073         struct ofdpa_fdb_tbl_entry *found;
2074         unsigned long lock_flags;
2075         struct hlist_node *tmp;
2076         int bkt;
2077         int err = 0;
2078
2079         if (ofdpa_port->stp_state == BR_STATE_LEARNING ||
2080             ofdpa_port->stp_state == BR_STATE_FORWARDING)
2081                 return 0;
2082
2083         flags |= OFDPA_OP_FLAG_NOWAIT | OFDPA_OP_FLAG_REMOVE;
2084
2085         spin_lock_irqsave(&ofdpa->fdb_tbl_lock, lock_flags);
2086
2087         hash_for_each_safe(ofdpa->fdb_tbl, bkt, tmp, found, entry) {
2088                 if (found->key.ofdpa_port != ofdpa_port)
2089                         continue;
2090                 if (!found->learned)
2091                         continue;
2092                 err = ofdpa_port_fdb_learn(ofdpa_port, trans, flags,
2093                                            found->key.addr,
2094                                            found->key.vlan_id);
2095                 if (err)
2096                         goto err_out;
2097                 if (!switchdev_trans_ph_prepare(trans))
2098                         hash_del(&found->entry);
2099         }
2100
2101 err_out:
2102         spin_unlock_irqrestore(&ofdpa->fdb_tbl_lock, lock_flags);
2103
2104         return err;
2105 }
2106
2107 static void ofdpa_fdb_cleanup(unsigned long data)
2108 {
2109         struct ofdpa *ofdpa = (struct ofdpa *)data;
2110         struct ofdpa_port *ofdpa_port;
2111         struct ofdpa_fdb_tbl_entry *entry;
2112         struct hlist_node *tmp;
2113         unsigned long next_timer = jiffies + ofdpa->ageing_time;
2114         unsigned long expires;
2115         unsigned long lock_flags;
2116         int flags = OFDPA_OP_FLAG_NOWAIT | OFDPA_OP_FLAG_REMOVE |
2117                     OFDPA_OP_FLAG_LEARNED;
2118         int bkt;
2119
2120         spin_lock_irqsave(&ofdpa->fdb_tbl_lock, lock_flags);
2121
2122         hash_for_each_safe(ofdpa->fdb_tbl, bkt, tmp, entry, entry) {
2123                 if (!entry->learned)
2124                         continue;
2125                 ofdpa_port = entry->key.ofdpa_port;
2126                 expires = entry->touched + ofdpa_port->ageing_time;
2127                 if (time_before_eq(expires, jiffies)) {
2128                         ofdpa_port_fdb_learn(ofdpa_port, NULL,
2129                                              flags, entry->key.addr,
2130                                              entry->key.vlan_id);
2131                         hash_del(&entry->entry);
2132                 } else if (time_before(expires, next_timer)) {
2133                         next_timer = expires;
2134                 }
2135         }
2136
2137         spin_unlock_irqrestore(&ofdpa->fdb_tbl_lock, lock_flags);
2138
2139         mod_timer(&ofdpa->fdb_cleanup_timer, round_jiffies_up(next_timer));
2140 }
2141
2142 static int ofdpa_port_router_mac(struct ofdpa_port *ofdpa_port,
2143                                  struct switchdev_trans *trans, int flags,
2144                                  __be16 vlan_id)
2145 {
2146         u32 in_pport_mask = 0xffffffff;
2147         __be16 eth_type;
2148         const u8 *dst_mac_mask = ff_mac;
2149         __be16 vlan_id_mask = htons(0xffff);
2150         bool copy_to_cpu = false;
2151         int err;
2152
2153         if (ntohs(vlan_id) == 0)
2154                 vlan_id = ofdpa_port->internal_vlan_id;
2155
2156         eth_type = htons(ETH_P_IP);
2157         err = ofdpa_flow_tbl_term_mac(ofdpa_port, trans,
2158                                       ofdpa_port->pport, in_pport_mask,
2159                                       eth_type, ofdpa_port->dev->dev_addr,
2160                                       dst_mac_mask, vlan_id, vlan_id_mask,
2161                                       copy_to_cpu, flags);
2162         if (err)
2163                 return err;
2164
2165         eth_type = htons(ETH_P_IPV6);
2166         err = ofdpa_flow_tbl_term_mac(ofdpa_port, trans,
2167                                       ofdpa_port->pport, in_pport_mask,
2168                                       eth_type, ofdpa_port->dev->dev_addr,
2169                                       dst_mac_mask, vlan_id, vlan_id_mask,
2170                                       copy_to_cpu, flags);
2171
2172         return err;
2173 }
2174
2175 static int ofdpa_port_fwding(struct ofdpa_port *ofdpa_port,
2176                              struct switchdev_trans *trans, int flags)
2177 {
2178         bool pop_vlan;
2179         u32 out_pport;
2180         __be16 vlan_id;
2181         u16 vid;
2182         int err;
2183
2184         /* Port will be forwarding-enabled if its STP state is LEARNING
2185          * or FORWARDING.  Traffic from CPU can still egress, regardless of
2186          * port STP state.  Use L2 interface group on port VLANs as a way
2187          * to toggle port forwarding: if forwarding is disabled, L2
2188          * interface group will not exist.
2189          */
2190
2191         if (ofdpa_port->stp_state != BR_STATE_LEARNING &&
2192             ofdpa_port->stp_state != BR_STATE_FORWARDING)
2193                 flags |= OFDPA_OP_FLAG_REMOVE;
2194
2195         out_pport = ofdpa_port->pport;
2196         for (vid = 1; vid < VLAN_N_VID; vid++) {
2197                 if (!test_bit(vid, ofdpa_port->vlan_bitmap))
2198                         continue;
2199                 vlan_id = htons(vid);
2200                 pop_vlan = ofdpa_vlan_id_is_internal(vlan_id);
2201                 err = ofdpa_group_l2_interface(ofdpa_port, trans, flags,
2202                                                vlan_id, out_pport, pop_vlan);
2203                 if (err) {
2204                         netdev_err(ofdpa_port->dev, "Error (%d) port VLAN l2 group for pport %d\n",
2205                                    err, out_pport);
2206                         return err;
2207                 }
2208         }
2209
2210         return 0;
2211 }
2212
2213 static int ofdpa_port_stp_update(struct ofdpa_port *ofdpa_port,
2214                                  struct switchdev_trans *trans,
2215                                  int flags, u8 state)
2216 {
2217         bool want[OFDPA_CTRL_MAX] = { 0, };
2218         bool prev_ctrls[OFDPA_CTRL_MAX];
2219         u8 uninitialized_var(prev_state);
2220         int err;
2221         int i;
2222
2223         if (switchdev_trans_ph_prepare(trans)) {
2224                 memcpy(prev_ctrls, ofdpa_port->ctrls, sizeof(prev_ctrls));
2225                 prev_state = ofdpa_port->stp_state;
2226         }
2227
2228         if (ofdpa_port->stp_state == state)
2229                 return 0;
2230
2231         ofdpa_port->stp_state = state;
2232
2233         switch (state) {
2234         case BR_STATE_DISABLED:
2235                 /* port is completely disabled */
2236                 break;
2237         case BR_STATE_LISTENING:
2238         case BR_STATE_BLOCKING:
2239                 want[OFDPA_CTRL_LINK_LOCAL_MCAST] = true;
2240                 break;
2241         case BR_STATE_LEARNING:
2242         case BR_STATE_FORWARDING:
2243                 if (!ofdpa_port_is_ovsed(ofdpa_port))
2244                         want[OFDPA_CTRL_LINK_LOCAL_MCAST] = true;
2245                 want[OFDPA_CTRL_IPV4_MCAST] = true;
2246                 want[OFDPA_CTRL_IPV6_MCAST] = true;
2247                 if (ofdpa_port_is_bridged(ofdpa_port))
2248                         want[OFDPA_CTRL_DFLT_BRIDGING] = true;
2249                 else if (ofdpa_port_is_ovsed(ofdpa_port))
2250                         want[OFDPA_CTRL_DFLT_OVS] = true;
2251                 else
2252                         want[OFDPA_CTRL_LOCAL_ARP] = true;
2253                 break;
2254         }
2255
2256         for (i = 0; i < OFDPA_CTRL_MAX; i++) {
2257                 if (want[i] != ofdpa_port->ctrls[i]) {
2258                         int ctrl_flags = flags |
2259                                          (want[i] ? 0 : OFDPA_OP_FLAG_REMOVE);
2260                         err = ofdpa_port_ctrl(ofdpa_port, trans, ctrl_flags,
2261                                               &ofdpa_ctrls[i]);
2262                         if (err)
2263                                 goto err_out;
2264                         ofdpa_port->ctrls[i] = want[i];
2265                 }
2266         }
2267
2268         err = ofdpa_port_fdb_flush(ofdpa_port, trans, flags);
2269         if (err)
2270                 goto err_out;
2271
2272         err = ofdpa_port_fwding(ofdpa_port, trans, flags);
2273
2274 err_out:
2275         if (switchdev_trans_ph_prepare(trans)) {
2276                 memcpy(ofdpa_port->ctrls, prev_ctrls, sizeof(prev_ctrls));
2277                 ofdpa_port->stp_state = prev_state;
2278         }
2279
2280         return err;
2281 }
2282
2283 static int ofdpa_port_fwd_enable(struct ofdpa_port *ofdpa_port, int flags)
2284 {
2285         if (ofdpa_port_is_bridged(ofdpa_port))
2286                 /* bridge STP will enable port */
2287                 return 0;
2288
2289         /* port is not bridged, so simulate going to FORWARDING state */
2290         return ofdpa_port_stp_update(ofdpa_port, NULL, flags,
2291                                      BR_STATE_FORWARDING);
2292 }
2293
2294 static int ofdpa_port_fwd_disable(struct ofdpa_port *ofdpa_port, int flags)
2295 {
2296         if (ofdpa_port_is_bridged(ofdpa_port))
2297                 /* bridge STP will disable port */
2298                 return 0;
2299
2300         /* port is not bridged, so simulate going to DISABLED state */
2301         return ofdpa_port_stp_update(ofdpa_port, NULL, flags,
2302                                      BR_STATE_DISABLED);
2303 }
2304
2305 static int ofdpa_port_vlan_add(struct ofdpa_port *ofdpa_port,
2306                                struct switchdev_trans *trans,
2307                                u16 vid, u16 flags)
2308 {
2309         int err;
2310
2311         /* XXX deal with flags for PVID and untagged */
2312
2313         err = ofdpa_port_vlan(ofdpa_port, trans, 0, vid);
2314         if (err)
2315                 return err;
2316
2317         err = ofdpa_port_router_mac(ofdpa_port, trans, 0, htons(vid));
2318         if (err)
2319                 ofdpa_port_vlan(ofdpa_port, trans,
2320                                 OFDPA_OP_FLAG_REMOVE, vid);
2321
2322         return err;
2323 }
2324
2325 static int ofdpa_port_vlan_del(struct ofdpa_port *ofdpa_port,
2326                                u16 vid, u16 flags)
2327 {
2328         int err;
2329
2330         err = ofdpa_port_router_mac(ofdpa_port, NULL,
2331                                     OFDPA_OP_FLAG_REMOVE, htons(vid));
2332         if (err)
2333                 return err;
2334
2335         return ofdpa_port_vlan(ofdpa_port, NULL,
2336                                OFDPA_OP_FLAG_REMOVE, vid);
2337 }
2338
2339 static struct ofdpa_internal_vlan_tbl_entry *
2340 ofdpa_internal_vlan_tbl_find(const struct ofdpa *ofdpa, int ifindex)
2341 {
2342         struct ofdpa_internal_vlan_tbl_entry *found;
2343
2344         hash_for_each_possible(ofdpa->internal_vlan_tbl, found,
2345                                entry, ifindex) {
2346                 if (found->ifindex == ifindex)
2347                         return found;
2348         }
2349
2350         return NULL;
2351 }
2352
2353 static __be16 ofdpa_port_internal_vlan_id_get(struct ofdpa_port *ofdpa_port,
2354                                               int ifindex)
2355 {
2356         struct ofdpa *ofdpa = ofdpa_port->ofdpa;
2357         struct ofdpa_internal_vlan_tbl_entry *entry;
2358         struct ofdpa_internal_vlan_tbl_entry *found;
2359         unsigned long lock_flags;
2360         int i;
2361
2362         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
2363         if (!entry)
2364                 return 0;
2365
2366         entry->ifindex = ifindex;
2367
2368         spin_lock_irqsave(&ofdpa->internal_vlan_tbl_lock, lock_flags);
2369
2370         found = ofdpa_internal_vlan_tbl_find(ofdpa, ifindex);
2371         if (found) {
2372                 kfree(entry);
2373                 goto found;
2374         }
2375
2376         found = entry;
2377         hash_add(ofdpa->internal_vlan_tbl, &found->entry, found->ifindex);
2378
2379         for (i = 0; i < OFDPA_N_INTERNAL_VLANS; i++) {
2380                 if (test_and_set_bit(i, ofdpa->internal_vlan_bitmap))
2381                         continue;
2382                 found->vlan_id = htons(OFDPA_INTERNAL_VLAN_ID_BASE + i);
2383                 goto found;
2384         }
2385
2386         netdev_err(ofdpa_port->dev, "Out of internal VLAN IDs\n");
2387
2388 found:
2389         found->ref_count++;
2390         spin_unlock_irqrestore(&ofdpa->internal_vlan_tbl_lock, lock_flags);
2391
2392         return found->vlan_id;
2393 }
2394
2395 static int ofdpa_port_fib_ipv4(struct ofdpa_port *ofdpa_port,
2396                                struct switchdev_trans *trans, __be32 dst,
2397                                int dst_len, struct fib_info *fi,
2398                                u32 tb_id, int flags)
2399 {
2400         const struct fib_nh *nh;
2401         __be16 eth_type = htons(ETH_P_IP);
2402         __be32 dst_mask = inet_make_mask(dst_len);
2403         __be16 internal_vlan_id = ofdpa_port->internal_vlan_id;
2404         u32 priority = fi->fib_priority;
2405         enum rocker_of_dpa_table_id goto_tbl =
2406                 ROCKER_OF_DPA_TABLE_ID_ACL_POLICY;
2407         u32 group_id;
2408         bool nh_on_port;
2409         bool has_gw;
2410         u32 index;
2411         int err;
2412
2413         /* XXX support ECMP */
2414
2415         nh = fi->fib_nh;
2416         nh_on_port = (fi->fib_dev == ofdpa_port->dev);
2417         has_gw = !!nh->nh_gw;
2418
2419         if (has_gw && nh_on_port) {
2420                 err = ofdpa_port_ipv4_nh(ofdpa_port, trans, flags,
2421                                          nh->nh_gw, &index);
2422                 if (err)
2423                         return err;
2424
2425                 group_id = ROCKER_GROUP_L3_UNICAST(index);
2426         } else {
2427                 /* Send to CPU for processing */
2428                 group_id = ROCKER_GROUP_L2_INTERFACE(internal_vlan_id, 0);
2429         }
2430
2431         err = ofdpa_flow_tbl_ucast4_routing(ofdpa_port, trans, eth_type, dst,
2432                                             dst_mask, priority, goto_tbl,
2433                                             group_id, fi, flags);
2434         if (err)
2435                 netdev_err(ofdpa_port->dev, "Error (%d) IPv4 route %pI4\n",
2436                            err, &dst);
2437
2438         return err;
2439 }
2440
2441 static void
2442 ofdpa_port_internal_vlan_id_put(const struct ofdpa_port *ofdpa_port,
2443                                 int ifindex)
2444 {
2445         struct ofdpa *ofdpa = ofdpa_port->ofdpa;
2446         struct ofdpa_internal_vlan_tbl_entry *found;
2447         unsigned long lock_flags;
2448         unsigned long bit;
2449
2450         spin_lock_irqsave(&ofdpa->internal_vlan_tbl_lock, lock_flags);
2451
2452         found = ofdpa_internal_vlan_tbl_find(ofdpa, ifindex);
2453         if (!found) {
2454                 netdev_err(ofdpa_port->dev,
2455                            "ifindex (%d) not found in internal VLAN tbl\n",
2456                            ifindex);
2457                 goto not_found;
2458         }
2459
2460         if (--found->ref_count <= 0) {
2461                 bit = ntohs(found->vlan_id) - OFDPA_INTERNAL_VLAN_ID_BASE;
2462                 clear_bit(bit, ofdpa->internal_vlan_bitmap);
2463                 hash_del(&found->entry);
2464                 kfree(found);
2465         }
2466
2467 not_found:
2468         spin_unlock_irqrestore(&ofdpa->internal_vlan_tbl_lock, lock_flags);
2469 }
2470
2471 /**********************************
2472  * Rocker world ops implementation
2473  **********************************/
2474
2475 static int ofdpa_init(struct rocker *rocker)
2476 {
2477         struct ofdpa *ofdpa = rocker->wpriv;
2478
2479         ofdpa->rocker = rocker;
2480
2481         hash_init(ofdpa->flow_tbl);
2482         spin_lock_init(&ofdpa->flow_tbl_lock);
2483
2484         hash_init(ofdpa->group_tbl);
2485         spin_lock_init(&ofdpa->group_tbl_lock);
2486
2487         hash_init(ofdpa->fdb_tbl);
2488         spin_lock_init(&ofdpa->fdb_tbl_lock);
2489
2490         hash_init(ofdpa->internal_vlan_tbl);
2491         spin_lock_init(&ofdpa->internal_vlan_tbl_lock);
2492
2493         hash_init(ofdpa->neigh_tbl);
2494         spin_lock_init(&ofdpa->neigh_tbl_lock);
2495
2496         setup_timer(&ofdpa->fdb_cleanup_timer, ofdpa_fdb_cleanup,
2497                     (unsigned long) ofdpa);
2498         mod_timer(&ofdpa->fdb_cleanup_timer, jiffies);
2499
2500         ofdpa->ageing_time = BR_DEFAULT_AGEING_TIME;
2501
2502         return 0;
2503 }
2504
2505 static void ofdpa_fini(struct rocker *rocker)
2506 {
2507         struct ofdpa *ofdpa = rocker->wpriv;
2508
2509         unsigned long flags;
2510         struct ofdpa_flow_tbl_entry *flow_entry;
2511         struct ofdpa_group_tbl_entry *group_entry;
2512         struct ofdpa_fdb_tbl_entry *fdb_entry;
2513         struct ofdpa_internal_vlan_tbl_entry *internal_vlan_entry;
2514         struct ofdpa_neigh_tbl_entry *neigh_entry;
2515         struct hlist_node *tmp;
2516         int bkt;
2517
2518         del_timer_sync(&ofdpa->fdb_cleanup_timer);
2519
2520         spin_lock_irqsave(&ofdpa->flow_tbl_lock, flags);
2521         hash_for_each_safe(ofdpa->flow_tbl, bkt, tmp, flow_entry, entry)
2522                 hash_del(&flow_entry->entry);
2523         spin_unlock_irqrestore(&ofdpa->flow_tbl_lock, flags);
2524
2525         spin_lock_irqsave(&ofdpa->group_tbl_lock, flags);
2526         hash_for_each_safe(ofdpa->group_tbl, bkt, tmp, group_entry, entry)
2527                 hash_del(&group_entry->entry);
2528         spin_unlock_irqrestore(&ofdpa->group_tbl_lock, flags);
2529
2530         spin_lock_irqsave(&ofdpa->fdb_tbl_lock, flags);
2531         hash_for_each_safe(ofdpa->fdb_tbl, bkt, tmp, fdb_entry, entry)
2532                 hash_del(&fdb_entry->entry);
2533         spin_unlock_irqrestore(&ofdpa->fdb_tbl_lock, flags);
2534
2535         spin_lock_irqsave(&ofdpa->internal_vlan_tbl_lock, flags);
2536         hash_for_each_safe(ofdpa->internal_vlan_tbl, bkt,
2537                            tmp, internal_vlan_entry, entry)
2538                 hash_del(&internal_vlan_entry->entry);
2539         spin_unlock_irqrestore(&ofdpa->internal_vlan_tbl_lock, flags);
2540
2541         spin_lock_irqsave(&ofdpa->neigh_tbl_lock, flags);
2542         hash_for_each_safe(ofdpa->neigh_tbl, bkt, tmp, neigh_entry, entry)
2543                 hash_del(&neigh_entry->entry);
2544         spin_unlock_irqrestore(&ofdpa->neigh_tbl_lock, flags);
2545 }
2546
2547 static int ofdpa_port_pre_init(struct rocker_port *rocker_port)
2548 {
2549         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2550
2551         ofdpa_port->ofdpa = rocker_port->rocker->wpriv;
2552         ofdpa_port->rocker_port = rocker_port;
2553         ofdpa_port->dev = rocker_port->dev;
2554         ofdpa_port->pport = rocker_port->pport;
2555         ofdpa_port->brport_flags = BR_LEARNING | BR_LEARNING_SYNC;
2556         ofdpa_port->ageing_time = BR_DEFAULT_AGEING_TIME;
2557         return 0;
2558 }
2559
2560 static int ofdpa_port_init(struct rocker_port *rocker_port)
2561 {
2562         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2563         int err;
2564
2565         rocker_port_set_learning(rocker_port,
2566                                  !!(ofdpa_port->brport_flags & BR_LEARNING));
2567
2568         err = ofdpa_port_ig_tbl(ofdpa_port, NULL, 0);
2569         if (err) {
2570                 netdev_err(ofdpa_port->dev, "install ig port table failed\n");
2571                 return err;
2572         }
2573
2574         ofdpa_port->internal_vlan_id =
2575                 ofdpa_port_internal_vlan_id_get(ofdpa_port,
2576                                                 ofdpa_port->dev->ifindex);
2577
2578         err = ofdpa_port_vlan_add(ofdpa_port, NULL, OFDPA_UNTAGGED_VID, 0);
2579         if (err) {
2580                 netdev_err(ofdpa_port->dev, "install untagged VLAN failed\n");
2581                 goto err_untagged_vlan;
2582         }
2583         return 0;
2584
2585 err_untagged_vlan:
2586         ofdpa_port_ig_tbl(ofdpa_port, NULL, OFDPA_OP_FLAG_REMOVE);
2587         return err;
2588 }
2589
2590 static void ofdpa_port_fini(struct rocker_port *rocker_port)
2591 {
2592         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2593
2594         ofdpa_port_ig_tbl(ofdpa_port, NULL, OFDPA_OP_FLAG_REMOVE);
2595 }
2596
2597 static int ofdpa_port_open(struct rocker_port *rocker_port)
2598 {
2599         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2600
2601         return ofdpa_port_fwd_enable(ofdpa_port, 0);
2602 }
2603
2604 static void ofdpa_port_stop(struct rocker_port *rocker_port)
2605 {
2606         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2607
2608         ofdpa_port_fwd_disable(ofdpa_port, OFDPA_OP_FLAG_NOWAIT);
2609 }
2610
2611 static int ofdpa_port_attr_stp_state_set(struct rocker_port *rocker_port,
2612                                          u8 state,
2613                                          struct switchdev_trans *trans)
2614 {
2615         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2616
2617         return ofdpa_port_stp_update(ofdpa_port, trans, 0, state);
2618 }
2619
2620 static int ofdpa_port_attr_bridge_flags_set(struct rocker_port *rocker_port,
2621                                             unsigned long brport_flags,
2622                                             struct switchdev_trans *trans)
2623 {
2624         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2625         unsigned long orig_flags;
2626         int err = 0;
2627
2628         orig_flags = ofdpa_port->brport_flags;
2629         ofdpa_port->brport_flags = brport_flags;
2630         if ((orig_flags ^ ofdpa_port->brport_flags) & BR_LEARNING &&
2631             !switchdev_trans_ph_prepare(trans))
2632                 err = rocker_port_set_learning(ofdpa_port->rocker_port,
2633                                                !!(ofdpa_port->brport_flags & BR_LEARNING));
2634
2635         if (switchdev_trans_ph_prepare(trans))
2636                 ofdpa_port->brport_flags = orig_flags;
2637
2638         return err;
2639 }
2640
2641 static int
2642 ofdpa_port_attr_bridge_flags_get(const struct rocker_port *rocker_port,
2643                                  unsigned long *p_brport_flags)
2644 {
2645         const struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2646
2647         *p_brport_flags = ofdpa_port->brport_flags;
2648         return 0;
2649 }
2650
2651 static int
2652 ofdpa_port_attr_bridge_ageing_time_set(struct rocker_port *rocker_port,
2653                                        u32 ageing_time,
2654                                        struct switchdev_trans *trans)
2655 {
2656         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2657         struct ofdpa *ofdpa = ofdpa_port->ofdpa;
2658
2659         if (!switchdev_trans_ph_prepare(trans)) {
2660                 ofdpa_port->ageing_time = clock_t_to_jiffies(ageing_time);
2661                 if (ofdpa_port->ageing_time < ofdpa->ageing_time)
2662                         ofdpa->ageing_time = ofdpa_port->ageing_time;
2663                 mod_timer(&ofdpa_port->ofdpa->fdb_cleanup_timer, jiffies);
2664         }
2665
2666         return 0;
2667 }
2668
2669 static int ofdpa_port_obj_vlan_add(struct rocker_port *rocker_port,
2670                                    const struct switchdev_obj_port_vlan *vlan,
2671                                    struct switchdev_trans *trans)
2672 {
2673         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2674         u16 vid;
2675         int err;
2676
2677         for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
2678                 err = ofdpa_port_vlan_add(ofdpa_port, trans, vid, vlan->flags);
2679                 if (err)
2680                         return err;
2681         }
2682
2683         return 0;
2684 }
2685
2686 static int ofdpa_port_obj_vlan_del(struct rocker_port *rocker_port,
2687                                    const struct switchdev_obj_port_vlan *vlan)
2688 {
2689         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2690         u16 vid;
2691         int err;
2692
2693         for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
2694                 err = ofdpa_port_vlan_del(ofdpa_port, vid, vlan->flags);
2695                 if (err)
2696                         return err;
2697         }
2698
2699         return 0;
2700 }
2701
2702 static int ofdpa_port_obj_vlan_dump(const struct rocker_port *rocker_port,
2703                                     struct switchdev_obj_port_vlan *vlan,
2704                                     switchdev_obj_dump_cb_t *cb)
2705 {
2706         const struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2707         u16 vid;
2708         int err = 0;
2709
2710         for (vid = 1; vid < VLAN_N_VID; vid++) {
2711                 if (!test_bit(vid, ofdpa_port->vlan_bitmap))
2712                         continue;
2713                 vlan->flags = 0;
2714                 if (ofdpa_vlan_id_is_internal(htons(vid)))
2715                         vlan->flags |= BRIDGE_VLAN_INFO_PVID;
2716                 vlan->vid_begin = vlan->vid_end = vid;
2717                 err = cb(&vlan->obj);
2718                 if (err)
2719                         break;
2720         }
2721
2722         return err;
2723 }
2724
2725 static int ofdpa_port_obj_fdb_add(struct rocker_port *rocker_port,
2726                                   const struct switchdev_obj_port_fdb *fdb,
2727                                   struct switchdev_trans *trans)
2728 {
2729         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2730         __be16 vlan_id = ofdpa_port_vid_to_vlan(ofdpa_port, fdb->vid, NULL);
2731
2732         if (!ofdpa_port_is_bridged(ofdpa_port))
2733                 return -EINVAL;
2734
2735         return ofdpa_port_fdb(ofdpa_port, trans, fdb->addr, vlan_id, 0);
2736 }
2737
2738 static int ofdpa_port_obj_fdb_del(struct rocker_port *rocker_port,
2739                                   const struct switchdev_obj_port_fdb *fdb)
2740 {
2741         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2742         __be16 vlan_id = ofdpa_port_vid_to_vlan(ofdpa_port, fdb->vid, NULL);
2743         int flags = OFDPA_OP_FLAG_REMOVE;
2744
2745         if (!ofdpa_port_is_bridged(ofdpa_port))
2746                 return -EINVAL;
2747
2748         return ofdpa_port_fdb(ofdpa_port, NULL, fdb->addr, vlan_id, flags);
2749 }
2750
2751 static int ofdpa_port_obj_fdb_dump(const struct rocker_port *rocker_port,
2752                                    struct switchdev_obj_port_fdb *fdb,
2753                                    switchdev_obj_dump_cb_t *cb)
2754 {
2755         const struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2756         struct ofdpa *ofdpa = ofdpa_port->ofdpa;
2757         struct ofdpa_fdb_tbl_entry *found;
2758         struct hlist_node *tmp;
2759         unsigned long lock_flags;
2760         int bkt;
2761         int err = 0;
2762
2763         spin_lock_irqsave(&ofdpa->fdb_tbl_lock, lock_flags);
2764         hash_for_each_safe(ofdpa->fdb_tbl, bkt, tmp, found, entry) {
2765                 if (found->key.ofdpa_port != ofdpa_port)
2766                         continue;
2767                 ether_addr_copy(fdb->addr, found->key.addr);
2768                 fdb->ndm_state = NUD_REACHABLE;
2769                 fdb->vid = ofdpa_port_vlan_to_vid(ofdpa_port,
2770                                                   found->key.vlan_id);
2771                 err = cb(&fdb->obj);
2772                 if (err)
2773                         break;
2774         }
2775         spin_unlock_irqrestore(&ofdpa->fdb_tbl_lock, lock_flags);
2776
2777         return err;
2778 }
2779
2780 static int ofdpa_port_bridge_join(struct ofdpa_port *ofdpa_port,
2781                                   struct net_device *bridge)
2782 {
2783         int err;
2784
2785         /* Port is joining bridge, so the internal VLAN for the
2786          * port is going to change to the bridge internal VLAN.
2787          * Let's remove untagged VLAN (vid=0) from port and
2788          * re-add once internal VLAN has changed.
2789          */
2790
2791         err = ofdpa_port_vlan_del(ofdpa_port, OFDPA_UNTAGGED_VID, 0);
2792         if (err)
2793                 return err;
2794
2795         ofdpa_port_internal_vlan_id_put(ofdpa_port,
2796                                         ofdpa_port->dev->ifindex);
2797         ofdpa_port->internal_vlan_id =
2798                 ofdpa_port_internal_vlan_id_get(ofdpa_port, bridge->ifindex);
2799
2800         ofdpa_port->bridge_dev = bridge;
2801
2802         return ofdpa_port_vlan_add(ofdpa_port, NULL, OFDPA_UNTAGGED_VID, 0);
2803 }
2804
2805 static int ofdpa_port_bridge_leave(struct ofdpa_port *ofdpa_port)
2806 {
2807         int err;
2808
2809         err = ofdpa_port_vlan_del(ofdpa_port, OFDPA_UNTAGGED_VID, 0);
2810         if (err)
2811                 return err;
2812
2813         ofdpa_port_internal_vlan_id_put(ofdpa_port,
2814                                         ofdpa_port->bridge_dev->ifindex);
2815         ofdpa_port->internal_vlan_id =
2816                 ofdpa_port_internal_vlan_id_get(ofdpa_port,
2817                                                 ofdpa_port->dev->ifindex);
2818
2819         ofdpa_port->bridge_dev = NULL;
2820
2821         err = ofdpa_port_vlan_add(ofdpa_port, NULL, OFDPA_UNTAGGED_VID, 0);
2822         if (err)
2823                 return err;
2824
2825         if (ofdpa_port->dev->flags & IFF_UP)
2826                 err = ofdpa_port_fwd_enable(ofdpa_port, 0);
2827
2828         return err;
2829 }
2830
2831 static int ofdpa_port_ovs_changed(struct ofdpa_port *ofdpa_port,
2832                                   struct net_device *master)
2833 {
2834         int err;
2835
2836         ofdpa_port->bridge_dev = master;
2837
2838         err = ofdpa_port_fwd_disable(ofdpa_port, 0);
2839         if (err)
2840                 return err;
2841         err = ofdpa_port_fwd_enable(ofdpa_port, 0);
2842
2843         return err;
2844 }
2845
2846 static int ofdpa_port_master_linked(struct rocker_port *rocker_port,
2847                                     struct net_device *master)
2848 {
2849         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2850         int err = 0;
2851
2852         if (netif_is_bridge_master(master))
2853                 err = ofdpa_port_bridge_join(ofdpa_port, master);
2854         else if (netif_is_ovs_master(master))
2855                 err = ofdpa_port_ovs_changed(ofdpa_port, master);
2856         return err;
2857 }
2858
2859 static int ofdpa_port_master_unlinked(struct rocker_port *rocker_port,
2860                                       struct net_device *master)
2861 {
2862         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2863         int err = 0;
2864
2865         if (ofdpa_port_is_bridged(ofdpa_port))
2866                 err = ofdpa_port_bridge_leave(ofdpa_port);
2867         else if (ofdpa_port_is_ovsed(ofdpa_port))
2868                 err = ofdpa_port_ovs_changed(ofdpa_port, NULL);
2869         return err;
2870 }
2871
2872 static int ofdpa_port_neigh_update(struct rocker_port *rocker_port,
2873                                    struct neighbour *n)
2874 {
2875         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2876         int flags = (n->nud_state & NUD_VALID ? 0 : OFDPA_OP_FLAG_REMOVE) |
2877                                                     OFDPA_OP_FLAG_NOWAIT;
2878         __be32 ip_addr = *(__be32 *) n->primary_key;
2879
2880         return ofdpa_port_ipv4_neigh(ofdpa_port, NULL, flags, ip_addr, n->ha);
2881 }
2882
2883 static int ofdpa_port_neigh_destroy(struct rocker_port *rocker_port,
2884                                     struct neighbour *n)
2885 {
2886         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2887         int flags = OFDPA_OP_FLAG_REMOVE | OFDPA_OP_FLAG_NOWAIT;
2888         __be32 ip_addr = *(__be32 *) n->primary_key;
2889
2890         return ofdpa_port_ipv4_neigh(ofdpa_port, NULL, flags, ip_addr, n->ha);
2891 }
2892
2893 static int ofdpa_port_ev_mac_vlan_seen(struct rocker_port *rocker_port,
2894                                        const unsigned char *addr,
2895                                        __be16 vlan_id)
2896 {
2897         struct ofdpa_port *ofdpa_port = rocker_port->wpriv;
2898         int flags = OFDPA_OP_FLAG_NOWAIT | OFDPA_OP_FLAG_LEARNED;
2899
2900         if (ofdpa_port->stp_state != BR_STATE_LEARNING &&
2901             ofdpa_port->stp_state != BR_STATE_FORWARDING)
2902                 return 0;
2903
2904         return ofdpa_port_fdb(ofdpa_port, NULL, addr, vlan_id, flags);
2905 }
2906
2907 static struct ofdpa_port *ofdpa_port_dev_lower_find(struct net_device *dev,
2908                                                     struct rocker *rocker)
2909 {
2910         struct rocker_port *rocker_port;
2911
2912         rocker_port = rocker_port_dev_lower_find(dev, rocker);
2913         return rocker_port ? rocker_port->wpriv : NULL;
2914 }
2915
2916 static int ofdpa_fib4_add(struct rocker *rocker,
2917                           const struct fib_entry_notifier_info *fen_info)
2918 {
2919         struct ofdpa *ofdpa = rocker->wpriv;
2920         struct ofdpa_port *ofdpa_port;
2921         int err;
2922
2923         if (ofdpa->fib_aborted)
2924                 return 0;
2925         ofdpa_port = ofdpa_port_dev_lower_find(fen_info->fi->fib_dev, rocker);
2926         if (!ofdpa_port)
2927                 return 0;
2928         err = ofdpa_port_fib_ipv4(ofdpa_port, NULL, htonl(fen_info->dst),
2929                                   fen_info->dst_len, fen_info->fi,
2930                                   fen_info->tb_id, 0);
2931         if (err)
2932                 return err;
2933         fib_info_offload_inc(fen_info->fi);
2934         return 0;
2935 }
2936
2937 static int ofdpa_fib4_del(struct rocker *rocker,
2938                           const struct fib_entry_notifier_info *fen_info)
2939 {
2940         struct ofdpa *ofdpa = rocker->wpriv;
2941         struct ofdpa_port *ofdpa_port;
2942
2943         if (ofdpa->fib_aborted)
2944                 return 0;
2945         ofdpa_port = ofdpa_port_dev_lower_find(fen_info->fi->fib_dev, rocker);
2946         if (!ofdpa_port)
2947                 return 0;
2948         fib_info_offload_dec(fen_info->fi);
2949         return ofdpa_port_fib_ipv4(ofdpa_port, NULL, htonl(fen_info->dst),
2950                                    fen_info->dst_len, fen_info->fi,
2951                                    fen_info->tb_id, OFDPA_OP_FLAG_REMOVE);
2952 }
2953
2954 static void ofdpa_fib4_abort(struct rocker *rocker)
2955 {
2956         struct ofdpa *ofdpa = rocker->wpriv;
2957         struct ofdpa_port *ofdpa_port;
2958         struct ofdpa_flow_tbl_entry *flow_entry;
2959         struct hlist_node *tmp;
2960         unsigned long flags;
2961         int bkt;
2962
2963         if (ofdpa->fib_aborted)
2964                 return;
2965
2966         spin_lock_irqsave(&ofdpa->flow_tbl_lock, flags);
2967         hash_for_each_safe(ofdpa->flow_tbl, bkt, tmp, flow_entry, entry) {
2968                 if (flow_entry->key.tbl_id !=
2969                     ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING)
2970                         continue;
2971                 ofdpa_port = ofdpa_port_dev_lower_find(flow_entry->fi->fib_dev,
2972                                                        rocker);
2973                 if (!ofdpa_port)
2974                         continue;
2975                 fib_info_offload_dec(flow_entry->fi);
2976                 ofdpa_flow_tbl_del(ofdpa_port, NULL, OFDPA_OP_FLAG_REMOVE,
2977                                    flow_entry);
2978         }
2979         spin_unlock_irqrestore(&ofdpa->flow_tbl_lock, flags);
2980         ofdpa->fib_aborted = true;
2981 }
2982
2983 struct rocker_world_ops rocker_ofdpa_ops = {
2984         .kind = "ofdpa",
2985         .priv_size = sizeof(struct ofdpa),
2986         .port_priv_size = sizeof(struct ofdpa_port),
2987         .mode = ROCKER_PORT_MODE_OF_DPA,
2988         .init = ofdpa_init,
2989         .fini = ofdpa_fini,
2990         .port_pre_init = ofdpa_port_pre_init,
2991         .port_init = ofdpa_port_init,
2992         .port_fini = ofdpa_port_fini,
2993         .port_open = ofdpa_port_open,
2994         .port_stop = ofdpa_port_stop,
2995         .port_attr_stp_state_set = ofdpa_port_attr_stp_state_set,
2996         .port_attr_bridge_flags_set = ofdpa_port_attr_bridge_flags_set,
2997         .port_attr_bridge_flags_get = ofdpa_port_attr_bridge_flags_get,
2998         .port_attr_bridge_ageing_time_set = ofdpa_port_attr_bridge_ageing_time_set,
2999         .port_obj_vlan_add = ofdpa_port_obj_vlan_add,
3000         .port_obj_vlan_del = ofdpa_port_obj_vlan_del,
3001         .port_obj_vlan_dump = ofdpa_port_obj_vlan_dump,
3002         .port_obj_fdb_add = ofdpa_port_obj_fdb_add,
3003         .port_obj_fdb_del = ofdpa_port_obj_fdb_del,
3004         .port_obj_fdb_dump = ofdpa_port_obj_fdb_dump,
3005         .port_master_linked = ofdpa_port_master_linked,
3006         .port_master_unlinked = ofdpa_port_master_unlinked,
3007         .port_neigh_update = ofdpa_port_neigh_update,
3008         .port_neigh_destroy = ofdpa_port_neigh_destroy,
3009         .port_ev_mac_vlan_seen = ofdpa_port_ev_mac_vlan_seen,
3010         .fib4_add = ofdpa_fib4_add,
3011         .fib4_del = ofdpa_fib4_del,
3012         .fib4_abort = ofdpa_fib4_abort,
3013 };