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