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