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