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