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