7ae0744ea50fffded3700309eb4bc8721692be45
[sfrench/cifs-2.6.git] / drivers / net / ethernet / mellanox / mlx5 / core / en_fs.c
1 /*
2  * Copyright (c) 2015, Mellanox Technologies. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  */
32
33 #include <linux/list.h>
34 #include <linux/ip.h>
35 #include <linux/ipv6.h>
36 #include <linux/tcp.h>
37 #include <linux/mlx5/fs.h>
38 #include "en.h"
39
40 static int mlx5e_add_l2_flow_rule(struct mlx5e_priv *priv,
41                                   struct mlx5e_l2_rule *ai, int type);
42 static void mlx5e_del_l2_flow_rule(struct mlx5e_priv *priv,
43                                    struct mlx5e_l2_rule *ai);
44
45 enum {
46         MLX5E_FULLMATCH = 0,
47         MLX5E_ALLMULTI  = 1,
48         MLX5E_PROMISC   = 2,
49 };
50
51 enum {
52         MLX5E_UC        = 0,
53         MLX5E_MC_IPV4   = 1,
54         MLX5E_MC_IPV6   = 2,
55         MLX5E_MC_OTHER  = 3,
56 };
57
58 enum {
59         MLX5E_ACTION_NONE = 0,
60         MLX5E_ACTION_ADD  = 1,
61         MLX5E_ACTION_DEL  = 2,
62 };
63
64 struct mlx5e_l2_hash_node {
65         struct hlist_node          hlist;
66         u8                         action;
67         struct mlx5e_l2_rule ai;
68 };
69
70 static inline int mlx5e_hash_l2(u8 *addr)
71 {
72         return addr[5];
73 }
74
75 static void mlx5e_add_l2_to_hash(struct hlist_head *hash, u8 *addr)
76 {
77         struct mlx5e_l2_hash_node *hn;
78         int ix = mlx5e_hash_l2(addr);
79         int found = 0;
80
81         hlist_for_each_entry(hn, &hash[ix], hlist)
82                 if (ether_addr_equal_64bits(hn->ai.addr, addr)) {
83                         found = 1;
84                         break;
85                 }
86
87         if (found) {
88                 hn->action = MLX5E_ACTION_NONE;
89                 return;
90         }
91
92         hn = kzalloc(sizeof(*hn), GFP_ATOMIC);
93         if (!hn)
94                 return;
95
96         ether_addr_copy(hn->ai.addr, addr);
97         hn->action = MLX5E_ACTION_ADD;
98
99         hlist_add_head(&hn->hlist, &hash[ix]);
100 }
101
102 static void mlx5e_del_l2_from_hash(struct mlx5e_l2_hash_node *hn)
103 {
104         hlist_del(&hn->hlist);
105         kfree(hn);
106 }
107
108 static int mlx5e_vport_context_update_vlans(struct mlx5e_priv *priv)
109 {
110         struct net_device *ndev = priv->netdev;
111         int max_list_size;
112         int list_size;
113         u16 *vlans;
114         int vlan;
115         int err;
116         int i;
117
118         list_size = 0;
119         for_each_set_bit(vlan, priv->fs.vlan.active_vlans, VLAN_N_VID)
120                 list_size++;
121
122         max_list_size = 1 << MLX5_CAP_GEN(priv->mdev, log_max_vlan_list);
123
124         if (list_size > max_list_size) {
125                 netdev_warn(ndev,
126                             "netdev vlans list size (%d) > (%d) max vport list size, some vlans will be dropped\n",
127                             list_size, max_list_size);
128                 list_size = max_list_size;
129         }
130
131         vlans = kcalloc(list_size, sizeof(*vlans), GFP_KERNEL);
132         if (!vlans)
133                 return -ENOMEM;
134
135         i = 0;
136         for_each_set_bit(vlan, priv->fs.vlan.active_vlans, VLAN_N_VID) {
137                 if (i >= list_size)
138                         break;
139                 vlans[i++] = vlan;
140         }
141
142         err = mlx5_modify_nic_vport_vlans(priv->mdev, vlans, list_size);
143         if (err)
144                 netdev_err(ndev, "Failed to modify vport vlans list err(%d)\n",
145                            err);
146
147         kfree(vlans);
148         return err;
149 }
150
151 enum mlx5e_vlan_rule_type {
152         MLX5E_VLAN_RULE_TYPE_UNTAGGED,
153         MLX5E_VLAN_RULE_TYPE_ANY_VID,
154         MLX5E_VLAN_RULE_TYPE_MATCH_VID,
155 };
156
157 static int __mlx5e_add_vlan_rule(struct mlx5e_priv *priv,
158                                  enum mlx5e_vlan_rule_type rule_type,
159                                  u16 vid, struct mlx5_flow_spec *spec)
160 {
161         struct mlx5_flow_act flow_act = {
162                 .action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST,
163                 .flow_tag = MLX5_FS_DEFAULT_FLOW_TAG,
164                 .encap_id = 0,
165         };
166         struct mlx5_flow_table *ft = priv->fs.vlan.ft.t;
167         struct mlx5_flow_destination dest;
168         struct mlx5_flow_handle **rule_p;
169         int err = 0;
170
171         dest.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
172         dest.ft = priv->fs.l2.ft.t;
173
174         spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
175         MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, outer_headers.cvlan_tag);
176
177         switch (rule_type) {
178         case MLX5E_VLAN_RULE_TYPE_UNTAGGED:
179                 rule_p = &priv->fs.vlan.untagged_rule;
180                 break;
181         case MLX5E_VLAN_RULE_TYPE_ANY_VID:
182                 rule_p = &priv->fs.vlan.any_vlan_rule;
183                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.cvlan_tag, 1);
184                 break;
185         default: /* MLX5E_VLAN_RULE_TYPE_MATCH_VID */
186                 rule_p = &priv->fs.vlan.active_vlans_rule[vid];
187                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.cvlan_tag, 1);
188                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
189                                  outer_headers.first_vid);
190                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.first_vid,
191                          vid);
192                 break;
193         }
194
195         *rule_p = mlx5_add_flow_rules(ft, spec, &flow_act, &dest, 1);
196
197         if (IS_ERR(*rule_p)) {
198                 err = PTR_ERR(*rule_p);
199                 *rule_p = NULL;
200                 netdev_err(priv->netdev, "%s: add rule failed\n", __func__);
201         }
202
203         return err;
204 }
205
206 static int mlx5e_add_vlan_rule(struct mlx5e_priv *priv,
207                                enum mlx5e_vlan_rule_type rule_type, u16 vid)
208 {
209         struct mlx5_flow_spec *spec;
210         int err = 0;
211
212         spec = mlx5_vzalloc(sizeof(*spec));
213         if (!spec) {
214                 netdev_err(priv->netdev, "%s: alloc failed\n", __func__);
215                 return -ENOMEM;
216         }
217
218         if (rule_type == MLX5E_VLAN_RULE_TYPE_MATCH_VID)
219                 mlx5e_vport_context_update_vlans(priv);
220
221         err = __mlx5e_add_vlan_rule(priv, rule_type, vid, spec);
222
223         kvfree(spec);
224
225         return err;
226 }
227
228 static void mlx5e_del_vlan_rule(struct mlx5e_priv *priv,
229                                 enum mlx5e_vlan_rule_type rule_type, u16 vid)
230 {
231         switch (rule_type) {
232         case MLX5E_VLAN_RULE_TYPE_UNTAGGED:
233                 if (priv->fs.vlan.untagged_rule) {
234                         mlx5_del_flow_rules(priv->fs.vlan.untagged_rule);
235                         priv->fs.vlan.untagged_rule = NULL;
236                 }
237                 break;
238         case MLX5E_VLAN_RULE_TYPE_ANY_VID:
239                 if (priv->fs.vlan.any_vlan_rule) {
240                         mlx5_del_flow_rules(priv->fs.vlan.any_vlan_rule);
241                         priv->fs.vlan.any_vlan_rule = NULL;
242                 }
243                 break;
244         case MLX5E_VLAN_RULE_TYPE_MATCH_VID:
245                 mlx5e_vport_context_update_vlans(priv);
246                 if (priv->fs.vlan.active_vlans_rule[vid]) {
247                         mlx5_del_flow_rules(priv->fs.vlan.active_vlans_rule[vid]);
248                         priv->fs.vlan.active_vlans_rule[vid] = NULL;
249                 }
250                 mlx5e_vport_context_update_vlans(priv);
251                 break;
252         }
253 }
254
255 void mlx5e_enable_vlan_filter(struct mlx5e_priv *priv)
256 {
257         if (!priv->fs.vlan.filter_disabled)
258                 return;
259
260         priv->fs.vlan.filter_disabled = false;
261         if (priv->netdev->flags & IFF_PROMISC)
262                 return;
263         mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID, 0);
264 }
265
266 void mlx5e_disable_vlan_filter(struct mlx5e_priv *priv)
267 {
268         if (priv->fs.vlan.filter_disabled)
269                 return;
270
271         priv->fs.vlan.filter_disabled = true;
272         if (priv->netdev->flags & IFF_PROMISC)
273                 return;
274         mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID, 0);
275 }
276
277 int mlx5e_vlan_rx_add_vid(struct net_device *dev, __always_unused __be16 proto,
278                           u16 vid)
279 {
280         struct mlx5e_priv *priv = netdev_priv(dev);
281
282         set_bit(vid, priv->fs.vlan.active_vlans);
283
284         return mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_VID, vid);
285 }
286
287 int mlx5e_vlan_rx_kill_vid(struct net_device *dev, __always_unused __be16 proto,
288                            u16 vid)
289 {
290         struct mlx5e_priv *priv = netdev_priv(dev);
291
292         clear_bit(vid, priv->fs.vlan.active_vlans);
293
294         mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_VID, vid);
295
296         return 0;
297 }
298
299 static void mlx5e_add_vlan_rules(struct mlx5e_priv *priv)
300 {
301         int i;
302
303         mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_UNTAGGED, 0);
304
305         for_each_set_bit(i, priv->fs.vlan.active_vlans, VLAN_N_VID) {
306                 mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_VID, i);
307         }
308
309         if (priv->fs.vlan.filter_disabled &&
310             !(priv->netdev->flags & IFF_PROMISC))
311                 mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID, 0);
312 }
313
314 static void mlx5e_del_vlan_rules(struct mlx5e_priv *priv)
315 {
316         int i;
317
318         mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_UNTAGGED, 0);
319
320         for_each_set_bit(i, priv->fs.vlan.active_vlans, VLAN_N_VID) {
321                 mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_VID, i);
322         }
323
324         if (priv->fs.vlan.filter_disabled &&
325             !(priv->netdev->flags & IFF_PROMISC))
326                 mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID, 0);
327 }
328
329 #define mlx5e_for_each_hash_node(hn, tmp, hash, i) \
330         for (i = 0; i < MLX5E_L2_ADDR_HASH_SIZE; i++) \
331                 hlist_for_each_entry_safe(hn, tmp, &hash[i], hlist)
332
333 static void mlx5e_execute_l2_action(struct mlx5e_priv *priv,
334                                     struct mlx5e_l2_hash_node *hn)
335 {
336         switch (hn->action) {
337         case MLX5E_ACTION_ADD:
338                 mlx5e_add_l2_flow_rule(priv, &hn->ai, MLX5E_FULLMATCH);
339                 hn->action = MLX5E_ACTION_NONE;
340                 break;
341
342         case MLX5E_ACTION_DEL:
343                 mlx5e_del_l2_flow_rule(priv, &hn->ai);
344                 mlx5e_del_l2_from_hash(hn);
345                 break;
346         }
347 }
348
349 static void mlx5e_sync_netdev_addr(struct mlx5e_priv *priv)
350 {
351         struct net_device *netdev = priv->netdev;
352         struct netdev_hw_addr *ha;
353
354         netif_addr_lock_bh(netdev);
355
356         mlx5e_add_l2_to_hash(priv->fs.l2.netdev_uc,
357                              priv->netdev->dev_addr);
358
359         netdev_for_each_uc_addr(ha, netdev)
360                 mlx5e_add_l2_to_hash(priv->fs.l2.netdev_uc, ha->addr);
361
362         netdev_for_each_mc_addr(ha, netdev)
363                 mlx5e_add_l2_to_hash(priv->fs.l2.netdev_mc, ha->addr);
364
365         netif_addr_unlock_bh(netdev);
366 }
367
368 static void mlx5e_fill_addr_array(struct mlx5e_priv *priv, int list_type,
369                                   u8 addr_array[][ETH_ALEN], int size)
370 {
371         bool is_uc = (list_type == MLX5_NVPRT_LIST_TYPE_UC);
372         struct net_device *ndev = priv->netdev;
373         struct mlx5e_l2_hash_node *hn;
374         struct hlist_head *addr_list;
375         struct hlist_node *tmp;
376         int i = 0;
377         int hi;
378
379         addr_list = is_uc ? priv->fs.l2.netdev_uc : priv->fs.l2.netdev_mc;
380
381         if (is_uc) /* Make sure our own address is pushed first */
382                 ether_addr_copy(addr_array[i++], ndev->dev_addr);
383         else if (priv->fs.l2.broadcast_enabled)
384                 ether_addr_copy(addr_array[i++], ndev->broadcast);
385
386         mlx5e_for_each_hash_node(hn, tmp, addr_list, hi) {
387                 if (ether_addr_equal(ndev->dev_addr, hn->ai.addr))
388                         continue;
389                 if (i >= size)
390                         break;
391                 ether_addr_copy(addr_array[i++], hn->ai.addr);
392         }
393 }
394
395 static void mlx5e_vport_context_update_addr_list(struct mlx5e_priv *priv,
396                                                  int list_type)
397 {
398         bool is_uc = (list_type == MLX5_NVPRT_LIST_TYPE_UC);
399         struct mlx5e_l2_hash_node *hn;
400         u8 (*addr_array)[ETH_ALEN] = NULL;
401         struct hlist_head *addr_list;
402         struct hlist_node *tmp;
403         int max_size;
404         int size;
405         int err;
406         int hi;
407
408         size = is_uc ? 0 : (priv->fs.l2.broadcast_enabled ? 1 : 0);
409         max_size = is_uc ?
410                 1 << MLX5_CAP_GEN(priv->mdev, log_max_current_uc_list) :
411                 1 << MLX5_CAP_GEN(priv->mdev, log_max_current_mc_list);
412
413         addr_list = is_uc ? priv->fs.l2.netdev_uc : priv->fs.l2.netdev_mc;
414         mlx5e_for_each_hash_node(hn, tmp, addr_list, hi)
415                 size++;
416
417         if (size > max_size) {
418                 netdev_warn(priv->netdev,
419                             "netdev %s list size (%d) > (%d) max vport list size, some addresses will be dropped\n",
420                             is_uc ? "UC" : "MC", size, max_size);
421                 size = max_size;
422         }
423
424         if (size) {
425                 addr_array = kcalloc(size, ETH_ALEN, GFP_KERNEL);
426                 if (!addr_array) {
427                         err = -ENOMEM;
428                         goto out;
429                 }
430                 mlx5e_fill_addr_array(priv, list_type, addr_array, size);
431         }
432
433         err = mlx5_modify_nic_vport_mac_list(priv->mdev, list_type, addr_array, size);
434 out:
435         if (err)
436                 netdev_err(priv->netdev,
437                            "Failed to modify vport %s list err(%d)\n",
438                            is_uc ? "UC" : "MC", err);
439         kfree(addr_array);
440 }
441
442 static void mlx5e_vport_context_update(struct mlx5e_priv *priv)
443 {
444         struct mlx5e_l2_table *ea = &priv->fs.l2;
445
446         mlx5e_vport_context_update_addr_list(priv, MLX5_NVPRT_LIST_TYPE_UC);
447         mlx5e_vport_context_update_addr_list(priv, MLX5_NVPRT_LIST_TYPE_MC);
448         mlx5_modify_nic_vport_promisc(priv->mdev, 0,
449                                       ea->allmulti_enabled,
450                                       ea->promisc_enabled);
451 }
452
453 static void mlx5e_apply_netdev_addr(struct mlx5e_priv *priv)
454 {
455         struct mlx5e_l2_hash_node *hn;
456         struct hlist_node *tmp;
457         int i;
458
459         mlx5e_for_each_hash_node(hn, tmp, priv->fs.l2.netdev_uc, i)
460                 mlx5e_execute_l2_action(priv, hn);
461
462         mlx5e_for_each_hash_node(hn, tmp, priv->fs.l2.netdev_mc, i)
463                 mlx5e_execute_l2_action(priv, hn);
464 }
465
466 static void mlx5e_handle_netdev_addr(struct mlx5e_priv *priv)
467 {
468         struct mlx5e_l2_hash_node *hn;
469         struct hlist_node *tmp;
470         int i;
471
472         mlx5e_for_each_hash_node(hn, tmp, priv->fs.l2.netdev_uc, i)
473                 hn->action = MLX5E_ACTION_DEL;
474         mlx5e_for_each_hash_node(hn, tmp, priv->fs.l2.netdev_mc, i)
475                 hn->action = MLX5E_ACTION_DEL;
476
477         if (!test_bit(MLX5E_STATE_DESTROYING, &priv->state))
478                 mlx5e_sync_netdev_addr(priv);
479
480         mlx5e_apply_netdev_addr(priv);
481 }
482
483 void mlx5e_set_rx_mode_work(struct work_struct *work)
484 {
485         struct mlx5e_priv *priv = container_of(work, struct mlx5e_priv,
486                                                set_rx_mode_work);
487
488         struct mlx5e_l2_table *ea = &priv->fs.l2;
489         struct net_device *ndev = priv->netdev;
490
491         bool rx_mode_enable   = !test_bit(MLX5E_STATE_DESTROYING, &priv->state);
492         bool promisc_enabled   = rx_mode_enable && (ndev->flags & IFF_PROMISC);
493         bool allmulti_enabled  = rx_mode_enable && (ndev->flags & IFF_ALLMULTI);
494         bool broadcast_enabled = rx_mode_enable;
495
496         bool enable_promisc    = !ea->promisc_enabled   &&  promisc_enabled;
497         bool disable_promisc   =  ea->promisc_enabled   && !promisc_enabled;
498         bool enable_allmulti   = !ea->allmulti_enabled  &&  allmulti_enabled;
499         bool disable_allmulti  =  ea->allmulti_enabled  && !allmulti_enabled;
500         bool enable_broadcast  = !ea->broadcast_enabled &&  broadcast_enabled;
501         bool disable_broadcast =  ea->broadcast_enabled && !broadcast_enabled;
502
503         if (enable_promisc) {
504                 mlx5e_add_l2_flow_rule(priv, &ea->promisc, MLX5E_PROMISC);
505                 if (!priv->fs.vlan.filter_disabled)
506                         mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID,
507                                             0);
508         }
509         if (enable_allmulti)
510                 mlx5e_add_l2_flow_rule(priv, &ea->allmulti, MLX5E_ALLMULTI);
511         if (enable_broadcast)
512                 mlx5e_add_l2_flow_rule(priv, &ea->broadcast, MLX5E_FULLMATCH);
513
514         mlx5e_handle_netdev_addr(priv);
515
516         if (disable_broadcast)
517                 mlx5e_del_l2_flow_rule(priv, &ea->broadcast);
518         if (disable_allmulti)
519                 mlx5e_del_l2_flow_rule(priv, &ea->allmulti);
520         if (disable_promisc) {
521                 if (!priv->fs.vlan.filter_disabled)
522                         mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_ANY_VID,
523                                             0);
524                 mlx5e_del_l2_flow_rule(priv, &ea->promisc);
525         }
526
527         ea->promisc_enabled   = promisc_enabled;
528         ea->allmulti_enabled  = allmulti_enabled;
529         ea->broadcast_enabled = broadcast_enabled;
530
531         mlx5e_vport_context_update(priv);
532 }
533
534 static void mlx5e_destroy_groups(struct mlx5e_flow_table *ft)
535 {
536         int i;
537
538         for (i = ft->num_groups - 1; i >= 0; i--) {
539                 if (!IS_ERR_OR_NULL(ft->g[i]))
540                         mlx5_destroy_flow_group(ft->g[i]);
541                 ft->g[i] = NULL;
542         }
543         ft->num_groups = 0;
544 }
545
546 void mlx5e_init_l2_addr(struct mlx5e_priv *priv)
547 {
548         ether_addr_copy(priv->fs.l2.broadcast.addr, priv->netdev->broadcast);
549 }
550
551 void mlx5e_destroy_flow_table(struct mlx5e_flow_table *ft)
552 {
553         mlx5e_destroy_groups(ft);
554         kfree(ft->g);
555         mlx5_destroy_flow_table(ft->t);
556         ft->t = NULL;
557 }
558
559 static void mlx5e_cleanup_ttc_rules(struct mlx5e_ttc_table *ttc)
560 {
561         int i;
562
563         for (i = 0; i < MLX5E_NUM_TT; i++) {
564                 if (!IS_ERR_OR_NULL(ttc->rules[i])) {
565                         mlx5_del_flow_rules(ttc->rules[i]);
566                         ttc->rules[i] = NULL;
567                 }
568         }
569 }
570
571 static struct {
572         u16 etype;
573         u8 proto;
574 } ttc_rules[] = {
575         [MLX5E_TT_IPV4_TCP] = {
576                 .etype = ETH_P_IP,
577                 .proto = IPPROTO_TCP,
578         },
579         [MLX5E_TT_IPV6_TCP] = {
580                 .etype = ETH_P_IPV6,
581                 .proto = IPPROTO_TCP,
582         },
583         [MLX5E_TT_IPV4_UDP] = {
584                 .etype = ETH_P_IP,
585                 .proto = IPPROTO_UDP,
586         },
587         [MLX5E_TT_IPV6_UDP] = {
588                 .etype = ETH_P_IPV6,
589                 .proto = IPPROTO_UDP,
590         },
591         [MLX5E_TT_IPV4_IPSEC_AH] = {
592                 .etype = ETH_P_IP,
593                 .proto = IPPROTO_AH,
594         },
595         [MLX5E_TT_IPV6_IPSEC_AH] = {
596                 .etype = ETH_P_IPV6,
597                 .proto = IPPROTO_AH,
598         },
599         [MLX5E_TT_IPV4_IPSEC_ESP] = {
600                 .etype = ETH_P_IP,
601                 .proto = IPPROTO_ESP,
602         },
603         [MLX5E_TT_IPV6_IPSEC_ESP] = {
604                 .etype = ETH_P_IPV6,
605                 .proto = IPPROTO_ESP,
606         },
607         [MLX5E_TT_IPV4] = {
608                 .etype = ETH_P_IP,
609                 .proto = 0,
610         },
611         [MLX5E_TT_IPV6] = {
612                 .etype = ETH_P_IPV6,
613                 .proto = 0,
614         },
615         [MLX5E_TT_ANY] = {
616                 .etype = 0,
617                 .proto = 0,
618         },
619 };
620
621 static struct mlx5_flow_handle *
622 mlx5e_generate_ttc_rule(struct mlx5e_priv *priv,
623                         struct mlx5_flow_table *ft,
624                         struct mlx5_flow_destination *dest,
625                         u16 etype,
626                         u8 proto)
627 {
628         struct mlx5_flow_act flow_act = {
629                 .action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST,
630                 .flow_tag = MLX5_FS_DEFAULT_FLOW_TAG,
631                 .encap_id = 0,
632         };
633         struct mlx5_flow_handle *rule;
634         struct mlx5_flow_spec *spec;
635         int err = 0;
636
637         spec = mlx5_vzalloc(sizeof(*spec));
638         if (!spec) {
639                 netdev_err(priv->netdev, "%s: alloc failed\n", __func__);
640                 return ERR_PTR(-ENOMEM);
641         }
642
643         if (proto) {
644                 spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
645                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, outer_headers.ip_protocol);
646                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.ip_protocol, proto);
647         }
648         if (etype) {
649                 spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
650                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria, outer_headers.ethertype);
651                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.ethertype, etype);
652         }
653
654         rule = mlx5_add_flow_rules(ft, spec, &flow_act, dest, 1);
655         if (IS_ERR(rule)) {
656                 err = PTR_ERR(rule);
657                 netdev_err(priv->netdev, "%s: add rule failed\n", __func__);
658         }
659
660         kvfree(spec);
661         return err ? ERR_PTR(err) : rule;
662 }
663
664 static int mlx5e_generate_ttc_table_rules(struct mlx5e_priv *priv)
665 {
666         struct mlx5_flow_destination dest;
667         struct mlx5e_ttc_table *ttc;
668         struct mlx5_flow_handle **rules;
669         struct mlx5_flow_table *ft;
670         int tt;
671         int err;
672
673         ttc = &priv->fs.ttc;
674         ft = ttc->ft.t;
675         rules = ttc->rules;
676
677         dest.type = MLX5_FLOW_DESTINATION_TYPE_TIR;
678         for (tt = 0; tt < MLX5E_NUM_TT; tt++) {
679                 if (tt == MLX5E_TT_ANY)
680                         dest.tir_num = priv->direct_tir[0].tirn;
681                 else
682                         dest.tir_num = priv->indir_tir[tt].tirn;
683                 rules[tt] = mlx5e_generate_ttc_rule(priv, ft, &dest,
684                                                     ttc_rules[tt].etype,
685                                                     ttc_rules[tt].proto);
686                 if (IS_ERR(rules[tt]))
687                         goto del_rules;
688         }
689
690         return 0;
691
692 del_rules:
693         err = PTR_ERR(rules[tt]);
694         rules[tt] = NULL;
695         mlx5e_cleanup_ttc_rules(ttc);
696         return err;
697 }
698
699 #define MLX5E_TTC_NUM_GROUPS    3
700 #define MLX5E_TTC_GROUP1_SIZE   BIT(3)
701 #define MLX5E_TTC_GROUP2_SIZE   BIT(1)
702 #define MLX5E_TTC_GROUP3_SIZE   BIT(0)
703 #define MLX5E_TTC_TABLE_SIZE    (MLX5E_TTC_GROUP1_SIZE +\
704                                  MLX5E_TTC_GROUP2_SIZE +\
705                                  MLX5E_TTC_GROUP3_SIZE)
706 static int mlx5e_create_ttc_table_groups(struct mlx5e_ttc_table *ttc)
707 {
708         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
709         struct mlx5e_flow_table *ft = &ttc->ft;
710         int ix = 0;
711         u32 *in;
712         int err;
713         u8 *mc;
714
715         ft->g = kcalloc(MLX5E_TTC_NUM_GROUPS,
716                         sizeof(*ft->g), GFP_KERNEL);
717         if (!ft->g)
718                 return -ENOMEM;
719         in = mlx5_vzalloc(inlen);
720         if (!in) {
721                 kfree(ft->g);
722                 return -ENOMEM;
723         }
724
725         /* L4 Group */
726         mc = MLX5_ADDR_OF(create_flow_group_in, in, match_criteria);
727         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.ip_protocol);
728         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.ethertype);
729         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
730         MLX5_SET_CFG(in, start_flow_index, ix);
731         ix += MLX5E_TTC_GROUP1_SIZE;
732         MLX5_SET_CFG(in, end_flow_index, ix - 1);
733         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
734         if (IS_ERR(ft->g[ft->num_groups]))
735                 goto err;
736         ft->num_groups++;
737
738         /* L3 Group */
739         MLX5_SET(fte_match_param, mc, outer_headers.ip_protocol, 0);
740         MLX5_SET_CFG(in, start_flow_index, ix);
741         ix += MLX5E_TTC_GROUP2_SIZE;
742         MLX5_SET_CFG(in, end_flow_index, ix - 1);
743         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
744         if (IS_ERR(ft->g[ft->num_groups]))
745                 goto err;
746         ft->num_groups++;
747
748         /* Any Group */
749         memset(in, 0, inlen);
750         MLX5_SET_CFG(in, start_flow_index, ix);
751         ix += MLX5E_TTC_GROUP3_SIZE;
752         MLX5_SET_CFG(in, end_flow_index, ix - 1);
753         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
754         if (IS_ERR(ft->g[ft->num_groups]))
755                 goto err;
756         ft->num_groups++;
757
758         kvfree(in);
759         return 0;
760
761 err:
762         err = PTR_ERR(ft->g[ft->num_groups]);
763         ft->g[ft->num_groups] = NULL;
764         kvfree(in);
765
766         return err;
767 }
768
769 static void mlx5e_destroy_ttc_table(struct mlx5e_priv *priv)
770 {
771         struct mlx5e_ttc_table *ttc = &priv->fs.ttc;
772
773         mlx5e_cleanup_ttc_rules(ttc);
774         mlx5e_destroy_flow_table(&ttc->ft);
775 }
776
777 static int mlx5e_create_ttc_table(struct mlx5e_priv *priv)
778 {
779         struct mlx5e_ttc_table *ttc = &priv->fs.ttc;
780         struct mlx5e_flow_table *ft = &ttc->ft;
781         int err;
782
783         ft->t = mlx5_create_flow_table(priv->fs.ns, MLX5E_NIC_PRIO,
784                                        MLX5E_TTC_TABLE_SIZE, MLX5E_TTC_FT_LEVEL, 0);
785         if (IS_ERR(ft->t)) {
786                 err = PTR_ERR(ft->t);
787                 ft->t = NULL;
788                 return err;
789         }
790
791         err = mlx5e_create_ttc_table_groups(ttc);
792         if (err)
793                 goto err;
794
795         err = mlx5e_generate_ttc_table_rules(priv);
796         if (err)
797                 goto err;
798
799         return 0;
800 err:
801         mlx5e_destroy_flow_table(ft);
802         return err;
803 }
804
805 static void mlx5e_del_l2_flow_rule(struct mlx5e_priv *priv,
806                                    struct mlx5e_l2_rule *ai)
807 {
808         if (!IS_ERR_OR_NULL(ai->rule)) {
809                 mlx5_del_flow_rules(ai->rule);
810                 ai->rule = NULL;
811         }
812 }
813
814 static int mlx5e_add_l2_flow_rule(struct mlx5e_priv *priv,
815                                   struct mlx5e_l2_rule *ai, int type)
816 {
817         struct mlx5_flow_act flow_act = {
818                 .action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST,
819                 .flow_tag = MLX5_FS_DEFAULT_FLOW_TAG,
820                 .encap_id = 0,
821         };
822         struct mlx5_flow_table *ft = priv->fs.l2.ft.t;
823         struct mlx5_flow_destination dest;
824         struct mlx5_flow_spec *spec;
825         int err = 0;
826         u8 *mc_dmac;
827         u8 *mv_dmac;
828
829         spec = mlx5_vzalloc(sizeof(*spec));
830         if (!spec) {
831                 netdev_err(priv->netdev, "%s: alloc failed\n", __func__);
832                 return -ENOMEM;
833         }
834
835         mc_dmac = MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
836                                outer_headers.dmac_47_16);
837         mv_dmac = MLX5_ADDR_OF(fte_match_param, spec->match_value,
838                                outer_headers.dmac_47_16);
839
840         dest.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
841         dest.ft = priv->fs.ttc.ft.t;
842
843         switch (type) {
844         case MLX5E_FULLMATCH:
845                 spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
846                 eth_broadcast_addr(mc_dmac);
847                 ether_addr_copy(mv_dmac, ai->addr);
848                 break;
849
850         case MLX5E_ALLMULTI:
851                 spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
852                 mc_dmac[0] = 0x01;
853                 mv_dmac[0] = 0x01;
854                 break;
855
856         case MLX5E_PROMISC:
857                 break;
858         }
859
860         ai->rule = mlx5_add_flow_rules(ft, spec, &flow_act, &dest, 1);
861         if (IS_ERR(ai->rule)) {
862                 netdev_err(priv->netdev, "%s: add l2 rule(mac:%pM) failed\n",
863                            __func__, mv_dmac);
864                 err = PTR_ERR(ai->rule);
865                 ai->rule = NULL;
866         }
867
868         kvfree(spec);
869
870         return err;
871 }
872
873 #define MLX5E_NUM_L2_GROUPS        3
874 #define MLX5E_L2_GROUP1_SIZE       BIT(0)
875 #define MLX5E_L2_GROUP2_SIZE       BIT(15)
876 #define MLX5E_L2_GROUP3_SIZE       BIT(0)
877 #define MLX5E_L2_TABLE_SIZE        (MLX5E_L2_GROUP1_SIZE +\
878                                     MLX5E_L2_GROUP2_SIZE +\
879                                     MLX5E_L2_GROUP3_SIZE)
880 static int mlx5e_create_l2_table_groups(struct mlx5e_l2_table *l2_table)
881 {
882         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
883         struct mlx5e_flow_table *ft = &l2_table->ft;
884         int ix = 0;
885         u8 *mc_dmac;
886         u32 *in;
887         int err;
888         u8 *mc;
889
890         ft->g = kcalloc(MLX5E_NUM_L2_GROUPS, sizeof(*ft->g), GFP_KERNEL);
891         if (!ft->g)
892                 return -ENOMEM;
893         in = mlx5_vzalloc(inlen);
894         if (!in) {
895                 kfree(ft->g);
896                 return -ENOMEM;
897         }
898
899         mc = MLX5_ADDR_OF(create_flow_group_in, in, match_criteria);
900         mc_dmac = MLX5_ADDR_OF(fte_match_param, mc,
901                                outer_headers.dmac_47_16);
902         /* Flow Group for promiscuous */
903         MLX5_SET_CFG(in, start_flow_index, ix);
904         ix += MLX5E_L2_GROUP1_SIZE;
905         MLX5_SET_CFG(in, end_flow_index, ix - 1);
906         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
907         if (IS_ERR(ft->g[ft->num_groups]))
908                 goto err_destroy_groups;
909         ft->num_groups++;
910
911         /* Flow Group for full match */
912         eth_broadcast_addr(mc_dmac);
913         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
914         MLX5_SET_CFG(in, start_flow_index, ix);
915         ix += MLX5E_L2_GROUP2_SIZE;
916         MLX5_SET_CFG(in, end_flow_index, ix - 1);
917         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
918         if (IS_ERR(ft->g[ft->num_groups]))
919                 goto err_destroy_groups;
920         ft->num_groups++;
921
922         /* Flow Group for allmulti */
923         eth_zero_addr(mc_dmac);
924         mc_dmac[0] = 0x01;
925         MLX5_SET_CFG(in, start_flow_index, ix);
926         ix += MLX5E_L2_GROUP3_SIZE;
927         MLX5_SET_CFG(in, end_flow_index, ix - 1);
928         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
929         if (IS_ERR(ft->g[ft->num_groups]))
930                 goto err_destroy_groups;
931         ft->num_groups++;
932
933         kvfree(in);
934         return 0;
935
936 err_destroy_groups:
937         err = PTR_ERR(ft->g[ft->num_groups]);
938         ft->g[ft->num_groups] = NULL;
939         mlx5e_destroy_groups(ft);
940         kvfree(in);
941
942         return err;
943 }
944
945 static void mlx5e_destroy_l2_table(struct mlx5e_priv *priv)
946 {
947         mlx5e_destroy_flow_table(&priv->fs.l2.ft);
948 }
949
950 static int mlx5e_create_l2_table(struct mlx5e_priv *priv)
951 {
952         struct mlx5e_l2_table *l2_table = &priv->fs.l2;
953         struct mlx5e_flow_table *ft = &l2_table->ft;
954         int err;
955
956         ft->num_groups = 0;
957         ft->t = mlx5_create_flow_table(priv->fs.ns, MLX5E_NIC_PRIO,
958                                        MLX5E_L2_TABLE_SIZE, MLX5E_L2_FT_LEVEL, 0);
959
960         if (IS_ERR(ft->t)) {
961                 err = PTR_ERR(ft->t);
962                 ft->t = NULL;
963                 return err;
964         }
965
966         err = mlx5e_create_l2_table_groups(l2_table);
967         if (err)
968                 goto err_destroy_flow_table;
969
970         return 0;
971
972 err_destroy_flow_table:
973         mlx5_destroy_flow_table(ft->t);
974         ft->t = NULL;
975
976         return err;
977 }
978
979 #define MLX5E_NUM_VLAN_GROUPS   2
980 #define MLX5E_VLAN_GROUP0_SIZE  BIT(12)
981 #define MLX5E_VLAN_GROUP1_SIZE  BIT(1)
982 #define MLX5E_VLAN_TABLE_SIZE   (MLX5E_VLAN_GROUP0_SIZE +\
983                                  MLX5E_VLAN_GROUP1_SIZE)
984
985 static int __mlx5e_create_vlan_table_groups(struct mlx5e_flow_table *ft, u32 *in,
986                                             int inlen)
987 {
988         int err;
989         int ix = 0;
990         u8 *mc = MLX5_ADDR_OF(create_flow_group_in, in, match_criteria);
991
992         memset(in, 0, inlen);
993         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
994         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.cvlan_tag);
995         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.first_vid);
996         MLX5_SET_CFG(in, start_flow_index, ix);
997         ix += MLX5E_VLAN_GROUP0_SIZE;
998         MLX5_SET_CFG(in, end_flow_index, ix - 1);
999         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
1000         if (IS_ERR(ft->g[ft->num_groups]))
1001                 goto err_destroy_groups;
1002         ft->num_groups++;
1003
1004         memset(in, 0, inlen);
1005         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
1006         MLX5_SET_TO_ONES(fte_match_param, mc, outer_headers.cvlan_tag);
1007         MLX5_SET_CFG(in, start_flow_index, ix);
1008         ix += MLX5E_VLAN_GROUP1_SIZE;
1009         MLX5_SET_CFG(in, end_flow_index, ix - 1);
1010         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
1011         if (IS_ERR(ft->g[ft->num_groups]))
1012                 goto err_destroy_groups;
1013         ft->num_groups++;
1014
1015         return 0;
1016
1017 err_destroy_groups:
1018         err = PTR_ERR(ft->g[ft->num_groups]);
1019         ft->g[ft->num_groups] = NULL;
1020         mlx5e_destroy_groups(ft);
1021
1022         return err;
1023 }
1024
1025 static int mlx5e_create_vlan_table_groups(struct mlx5e_flow_table *ft)
1026 {
1027         u32 *in;
1028         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
1029         int err;
1030
1031         in = mlx5_vzalloc(inlen);
1032         if (!in)
1033                 return -ENOMEM;
1034
1035         err = __mlx5e_create_vlan_table_groups(ft, in, inlen);
1036
1037         kvfree(in);
1038         return err;
1039 }
1040
1041 static int mlx5e_create_vlan_table(struct mlx5e_priv *priv)
1042 {
1043         struct mlx5e_flow_table *ft = &priv->fs.vlan.ft;
1044         int err;
1045
1046         ft->num_groups = 0;
1047         ft->t = mlx5_create_flow_table(priv->fs.ns, MLX5E_NIC_PRIO,
1048                                        MLX5E_VLAN_TABLE_SIZE, MLX5E_VLAN_FT_LEVEL, 0);
1049
1050         if (IS_ERR(ft->t)) {
1051                 err = PTR_ERR(ft->t);
1052                 ft->t = NULL;
1053                 return err;
1054         }
1055         ft->g = kcalloc(MLX5E_NUM_VLAN_GROUPS, sizeof(*ft->g), GFP_KERNEL);
1056         if (!ft->g) {
1057                 err = -ENOMEM;
1058                 goto err_destroy_vlan_table;
1059         }
1060
1061         err = mlx5e_create_vlan_table_groups(ft);
1062         if (err)
1063                 goto err_free_g;
1064
1065         mlx5e_add_vlan_rules(priv);
1066
1067         return 0;
1068
1069 err_free_g:
1070         kfree(ft->g);
1071 err_destroy_vlan_table:
1072         mlx5_destroy_flow_table(ft->t);
1073         ft->t = NULL;
1074
1075         return err;
1076 }
1077
1078 static void mlx5e_destroy_vlan_table(struct mlx5e_priv *priv)
1079 {
1080         mlx5e_del_vlan_rules(priv);
1081         mlx5e_destroy_flow_table(&priv->fs.vlan.ft);
1082 }
1083
1084 int mlx5e_create_flow_steering(struct mlx5e_priv *priv)
1085 {
1086         int err;
1087
1088         priv->fs.ns = mlx5_get_flow_namespace(priv->mdev,
1089                                                MLX5_FLOW_NAMESPACE_KERNEL);
1090
1091         if (!priv->fs.ns)
1092                 return -EINVAL;
1093
1094         err = mlx5e_arfs_create_tables(priv);
1095         if (err) {
1096                 netdev_err(priv->netdev, "Failed to create arfs tables, err=%d\n",
1097                            err);
1098                 priv->netdev->hw_features &= ~NETIF_F_NTUPLE;
1099         }
1100
1101         err = mlx5e_create_ttc_table(priv);
1102         if (err) {
1103                 netdev_err(priv->netdev, "Failed to create ttc table, err=%d\n",
1104                            err);
1105                 goto err_destroy_arfs_tables;
1106         }
1107
1108         err = mlx5e_create_l2_table(priv);
1109         if (err) {
1110                 netdev_err(priv->netdev, "Failed to create l2 table, err=%d\n",
1111                            err);
1112                 goto err_destroy_ttc_table;
1113         }
1114
1115         err = mlx5e_create_vlan_table(priv);
1116         if (err) {
1117                 netdev_err(priv->netdev, "Failed to create vlan table, err=%d\n",
1118                            err);
1119                 goto err_destroy_l2_table;
1120         }
1121
1122         mlx5e_ethtool_init_steering(priv);
1123
1124         return 0;
1125
1126 err_destroy_l2_table:
1127         mlx5e_destroy_l2_table(priv);
1128 err_destroy_ttc_table:
1129         mlx5e_destroy_ttc_table(priv);
1130 err_destroy_arfs_tables:
1131         mlx5e_arfs_destroy_tables(priv);
1132
1133         return err;
1134 }
1135
1136 void mlx5e_destroy_flow_steering(struct mlx5e_priv *priv)
1137 {
1138         mlx5e_destroy_vlan_table(priv);
1139         mlx5e_destroy_l2_table(priv);
1140         mlx5e_destroy_ttc_table(priv);
1141         mlx5e_arfs_destroy_tables(priv);
1142         mlx5e_ethtool_cleanup_steering(priv);
1143 }