GNU Linux-libre 4.14.262-gnu1
[releases.git] / drivers / net / ethernet / netronome / nfp / flower / match.c
1 /*
2  * Copyright (C) 2017 Netronome Systems, Inc.
3  *
4  * This software is dual licensed under the GNU General License Version 2,
5  * June 1991 as shown in the file COPYING in the top-level directory of this
6  * source tree or the BSD 2-Clause License provided below.  You have the
7  * option to license this software under the complete terms of either license.
8  *
9  * The BSD 2-Clause License:
10  *
11  *     Redistribution and use in source and binary forms, with or
12  *     without modification, are permitted provided that the following
13  *     conditions are met:
14  *
15  *      1. Redistributions of source code must retain the above
16  *         copyright notice, this list of conditions and the following
17  *         disclaimer.
18  *
19  *      2. Redistributions in binary form must reproduce the above
20  *         copyright notice, this list of conditions and the following
21  *         disclaimer in the documentation and/or other materials
22  *         provided with the distribution.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31  * SOFTWARE.
32  */
33
34 #include <linux/bitfield.h>
35 #include <net/pkt_cls.h>
36
37 #include "cmsg.h"
38 #include "main.h"
39
40 static void
41 nfp_flower_compile_meta_tci(struct nfp_flower_meta_two *frame,
42                             struct tc_cls_flower_offload *flow, u8 key_type,
43                             bool mask_version)
44 {
45         struct fl_flow_key *target = mask_version ? flow->mask : flow->key;
46         struct flow_dissector_key_vlan *flow_vlan;
47         u16 tmp_tci;
48
49         memset(frame, 0, sizeof(struct nfp_flower_meta_two));
50         /* Populate the metadata frame. */
51         frame->nfp_flow_key_layer = key_type;
52         frame->mask_id = ~0;
53
54         if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_VLAN)) {
55                 flow_vlan = skb_flow_dissector_target(flow->dissector,
56                                                       FLOW_DISSECTOR_KEY_VLAN,
57                                                       target);
58                 /* Populate the tci field. */
59                 if (flow_vlan->vlan_id) {
60                         tmp_tci = FIELD_PREP(NFP_FLOWER_MASK_VLAN_PRIO,
61                                              flow_vlan->vlan_priority) |
62                                   FIELD_PREP(NFP_FLOWER_MASK_VLAN_VID,
63                                              flow_vlan->vlan_id) |
64                                   NFP_FLOWER_MASK_VLAN_CFI;
65                         frame->tci = cpu_to_be16(tmp_tci);
66                 }
67         }
68 }
69
70 static void
71 nfp_flower_compile_meta(struct nfp_flower_meta_one *frame, u8 key_type)
72 {
73         frame->nfp_flow_key_layer = key_type;
74         frame->mask_id = 0;
75         frame->reserved = 0;
76 }
77
78 static int
79 nfp_flower_compile_port(struct nfp_flower_in_port *frame, u32 cmsg_port,
80                         bool mask_version)
81 {
82         if (mask_version) {
83                 frame->in_port = cpu_to_be32(~0);
84                 return 0;
85         }
86
87         frame->in_port = cpu_to_be32(cmsg_port);
88
89         return 0;
90 }
91
92 static void
93 nfp_flower_compile_mac(struct nfp_flower_mac_mpls *frame,
94                        struct tc_cls_flower_offload *flow,
95                        bool mask_version)
96 {
97         struct fl_flow_key *target = mask_version ? flow->mask : flow->key;
98         struct flow_dissector_key_eth_addrs *addr;
99
100         memset(frame, 0, sizeof(struct nfp_flower_mac_mpls));
101
102         if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_ETH_ADDRS)) {
103                 addr = skb_flow_dissector_target(flow->dissector,
104                                                  FLOW_DISSECTOR_KEY_ETH_ADDRS,
105                                                  target);
106                 /* Populate mac frame. */
107                 ether_addr_copy(frame->mac_dst, &addr->dst[0]);
108                 ether_addr_copy(frame->mac_src, &addr->src[0]);
109         }
110
111         if (mask_version)
112                 frame->mpls_lse = cpu_to_be32(~0);
113 }
114
115 static void
116 nfp_flower_compile_tport(struct nfp_flower_tp_ports *frame,
117                          struct tc_cls_flower_offload *flow,
118                          bool mask_version)
119 {
120         struct fl_flow_key *target = mask_version ? flow->mask : flow->key;
121         struct flow_dissector_key_ports *tp;
122
123         memset(frame, 0, sizeof(struct nfp_flower_tp_ports));
124
125         if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_PORTS)) {
126                 tp = skb_flow_dissector_target(flow->dissector,
127                                                FLOW_DISSECTOR_KEY_PORTS,
128                                                target);
129                 frame->port_src = tp->src;
130                 frame->port_dst = tp->dst;
131         }
132 }
133
134 static void
135 nfp_flower_compile_ipv4(struct nfp_flower_ipv4 *frame,
136                         struct tc_cls_flower_offload *flow,
137                         bool mask_version)
138 {
139         struct fl_flow_key *target = mask_version ? flow->mask : flow->key;
140         struct flow_dissector_key_ipv4_addrs *addr;
141         struct flow_dissector_key_basic *basic;
142
143         /* Wildcard TOS/TTL for now. */
144         memset(frame, 0, sizeof(struct nfp_flower_ipv4));
145
146         if (dissector_uses_key(flow->dissector,
147                                FLOW_DISSECTOR_KEY_IPV4_ADDRS)) {
148                 addr = skb_flow_dissector_target(flow->dissector,
149                                                  FLOW_DISSECTOR_KEY_IPV4_ADDRS,
150                                                  target);
151                 frame->ipv4_src = addr->src;
152                 frame->ipv4_dst = addr->dst;
153         }
154
155         if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_BASIC)) {
156                 basic = skb_flow_dissector_target(flow->dissector,
157                                                   FLOW_DISSECTOR_KEY_BASIC,
158                                                   target);
159                 frame->proto = basic->ip_proto;
160         }
161 }
162
163 static void
164 nfp_flower_compile_ipv6(struct nfp_flower_ipv6 *frame,
165                         struct tc_cls_flower_offload *flow,
166                         bool mask_version)
167 {
168         struct fl_flow_key *target = mask_version ? flow->mask : flow->key;
169         struct flow_dissector_key_ipv6_addrs *addr;
170         struct flow_dissector_key_basic *basic;
171
172         /* Wildcard LABEL/TOS/TTL for now. */
173         memset(frame, 0, sizeof(struct nfp_flower_ipv6));
174
175         if (dissector_uses_key(flow->dissector,
176                                FLOW_DISSECTOR_KEY_IPV6_ADDRS)) {
177                 addr = skb_flow_dissector_target(flow->dissector,
178                                                  FLOW_DISSECTOR_KEY_IPV6_ADDRS,
179                                                  target);
180                 frame->ipv6_src = addr->src;
181                 frame->ipv6_dst = addr->dst;
182         }
183
184         if (dissector_uses_key(flow->dissector, FLOW_DISSECTOR_KEY_BASIC)) {
185                 basic = skb_flow_dissector_target(flow->dissector,
186                                                   FLOW_DISSECTOR_KEY_BASIC,
187                                                   target);
188                 frame->proto = basic->ip_proto;
189         }
190 }
191
192 int nfp_flower_compile_flow_match(struct tc_cls_flower_offload *flow,
193                                   struct nfp_fl_key_ls *key_ls,
194                                   struct net_device *netdev,
195                                   struct nfp_fl_payload *nfp_flow)
196 {
197         int err;
198         u8 *ext;
199         u8 *msk;
200
201         memset(nfp_flow->unmasked_data, 0, key_ls->key_size);
202         memset(nfp_flow->mask_data, 0, key_ls->key_size);
203
204         ext = nfp_flow->unmasked_data;
205         msk = nfp_flow->mask_data;
206         if (NFP_FLOWER_LAYER_PORT & key_ls->key_layer) {
207                 /* Populate Exact Metadata. */
208                 nfp_flower_compile_meta_tci((struct nfp_flower_meta_two *)ext,
209                                             flow, key_ls->key_layer, false);
210                 /* Populate Mask Metadata. */
211                 nfp_flower_compile_meta_tci((struct nfp_flower_meta_two *)msk,
212                                             flow, key_ls->key_layer, true);
213                 ext += sizeof(struct nfp_flower_meta_two);
214                 msk += sizeof(struct nfp_flower_meta_two);
215
216                 /* Populate Exact Port data. */
217                 err = nfp_flower_compile_port((struct nfp_flower_in_port *)ext,
218                                               nfp_repr_get_port_id(netdev),
219                                               false);
220                 if (err)
221                         return err;
222
223                 /* Populate Mask Port Data. */
224                 err = nfp_flower_compile_port((struct nfp_flower_in_port *)msk,
225                                               nfp_repr_get_port_id(netdev),
226                                               true);
227                 if (err)
228                         return err;
229
230                 ext += sizeof(struct nfp_flower_in_port);
231                 msk += sizeof(struct nfp_flower_in_port);
232         } else {
233                 /* Populate Exact Metadata. */
234                 nfp_flower_compile_meta((struct nfp_flower_meta_one *)ext,
235                                         key_ls->key_layer);
236                 /* Populate Mask Metadata. */
237                 nfp_flower_compile_meta((struct nfp_flower_meta_one *)msk,
238                                         key_ls->key_layer);
239                 ext += sizeof(struct nfp_flower_meta_one);
240                 msk += sizeof(struct nfp_flower_meta_one);
241         }
242
243         if (NFP_FLOWER_LAYER_META & key_ls->key_layer) {
244                 /* Additional Metadata Fields.
245                  * Currently unsupported.
246                  */
247                 return -EOPNOTSUPP;
248         }
249
250         if (NFP_FLOWER_LAYER_MAC & key_ls->key_layer) {
251                 /* Populate Exact MAC Data. */
252                 nfp_flower_compile_mac((struct nfp_flower_mac_mpls *)ext,
253                                        flow, false);
254                 /* Populate Mask MAC Data. */
255                 nfp_flower_compile_mac((struct nfp_flower_mac_mpls *)msk,
256                                        flow, true);
257                 ext += sizeof(struct nfp_flower_mac_mpls);
258                 msk += sizeof(struct nfp_flower_mac_mpls);
259         }
260
261         if (NFP_FLOWER_LAYER_TP & key_ls->key_layer) {
262                 /* Populate Exact TP Data. */
263                 nfp_flower_compile_tport((struct nfp_flower_tp_ports *)ext,
264                                          flow, false);
265                 /* Populate Mask TP Data. */
266                 nfp_flower_compile_tport((struct nfp_flower_tp_ports *)msk,
267                                          flow, true);
268                 ext += sizeof(struct nfp_flower_tp_ports);
269                 msk += sizeof(struct nfp_flower_tp_ports);
270         }
271
272         if (NFP_FLOWER_LAYER_IPV4 & key_ls->key_layer) {
273                 /* Populate Exact IPv4 Data. */
274                 nfp_flower_compile_ipv4((struct nfp_flower_ipv4 *)ext,
275                                         flow, false);
276                 /* Populate Mask IPv4 Data. */
277                 nfp_flower_compile_ipv4((struct nfp_flower_ipv4 *)msk,
278                                         flow, true);
279                 ext += sizeof(struct nfp_flower_ipv4);
280                 msk += sizeof(struct nfp_flower_ipv4);
281         }
282
283         if (NFP_FLOWER_LAYER_IPV6 & key_ls->key_layer) {
284                 /* Populate Exact IPv4 Data. */
285                 nfp_flower_compile_ipv6((struct nfp_flower_ipv6 *)ext,
286                                         flow, false);
287                 /* Populate Mask IPv4 Data. */
288                 nfp_flower_compile_ipv6((struct nfp_flower_ipv6 *)msk,
289                                         flow, true);
290                 ext += sizeof(struct nfp_flower_ipv6);
291                 msk += sizeof(struct nfp_flower_ipv6);
292         }
293
294         return 0;
295 }