1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Broadcom Starfighter 2 DSA switch CFP support |
4 | * |
5 | * Copyright (C) 2016, Broadcom |
6 | */ |
7 | |
8 | #include <linux/list.h> |
9 | #include <linux/ethtool.h> |
10 | #include <linux/if_ether.h> |
11 | #include <linux/in.h> |
12 | #include <linux/netdevice.h> |
13 | #include <net/dsa.h> |
14 | #include <linux/bitmap.h> |
15 | #include <net/flow_offload.h> |
16 | #include <net/switchdev.h> |
17 | #include <uapi/linux/if_bridge.h> |
18 | |
19 | #include "bcm_sf2.h" |
20 | #include "bcm_sf2_regs.h" |
21 | |
22 | struct cfp_rule { |
23 | int port; |
24 | struct ethtool_rx_flow_spec fs; |
25 | struct list_head next; |
26 | }; |
27 | |
28 | struct cfp_udf_slice_layout { |
29 | u8 slices[UDFS_PER_SLICE]; |
30 | u32 mask_value; |
31 | u32 base_offset; |
32 | }; |
33 | |
34 | struct cfp_udf_layout { |
35 | struct cfp_udf_slice_layout udfs[UDF_NUM_SLICES]; |
36 | }; |
37 | |
38 | static const u8 zero_slice[UDFS_PER_SLICE] = { }; |
39 | |
40 | /* UDF slices layout for a TCPv4/UDPv4 specification */ |
41 | static const struct cfp_udf_layout udf_tcpip4_layout = { |
42 | .udfs = { |
43 | [1] = { |
44 | .slices = { |
45 | /* End of L2, byte offset 12, src IP[0:15] */ |
46 | CFG_UDF_EOL2 | 6, |
47 | /* End of L2, byte offset 14, src IP[16:31] */ |
48 | CFG_UDF_EOL2 | 7, |
49 | /* End of L2, byte offset 16, dst IP[0:15] */ |
50 | CFG_UDF_EOL2 | 8, |
51 | /* End of L2, byte offset 18, dst IP[16:31] */ |
52 | CFG_UDF_EOL2 | 9, |
53 | /* End of L3, byte offset 0, src port */ |
54 | CFG_UDF_EOL3 | 0, |
55 | /* End of L3, byte offset 2, dst port */ |
56 | CFG_UDF_EOL3 | 1, |
57 | 0, 0, 0 |
58 | }, |
59 | .mask_value = L3_FRAMING_MASK | IPPROTO_MASK | IP_FRAG, |
60 | .base_offset = CORE_UDF_0_A_0_8_PORT_0 + UDF_SLICE_OFFSET, |
61 | }, |
62 | }, |
63 | }; |
64 | |
65 | /* UDF slices layout for a TCPv6/UDPv6 specification */ |
66 | static const struct cfp_udf_layout udf_tcpip6_layout = { |
67 | .udfs = { |
68 | [0] = { |
69 | .slices = { |
70 | /* End of L2, byte offset 8, src IP[0:15] */ |
71 | CFG_UDF_EOL2 | 4, |
72 | /* End of L2, byte offset 10, src IP[16:31] */ |
73 | CFG_UDF_EOL2 | 5, |
74 | /* End of L2, byte offset 12, src IP[32:47] */ |
75 | CFG_UDF_EOL2 | 6, |
76 | /* End of L2, byte offset 14, src IP[48:63] */ |
77 | CFG_UDF_EOL2 | 7, |
78 | /* End of L2, byte offset 16, src IP[64:79] */ |
79 | CFG_UDF_EOL2 | 8, |
80 | /* End of L2, byte offset 18, src IP[80:95] */ |
81 | CFG_UDF_EOL2 | 9, |
82 | /* End of L2, byte offset 20, src IP[96:111] */ |
83 | CFG_UDF_EOL2 | 10, |
84 | /* End of L2, byte offset 22, src IP[112:127] */ |
85 | CFG_UDF_EOL2 | 11, |
86 | /* End of L3, byte offset 0, src port */ |
87 | CFG_UDF_EOL3 | 0, |
88 | }, |
89 | .mask_value = L3_FRAMING_MASK | IPPROTO_MASK | IP_FRAG, |
90 | .base_offset = CORE_UDF_0_B_0_8_PORT_0, |
91 | }, |
92 | [3] = { |
93 | .slices = { |
94 | /* End of L2, byte offset 24, dst IP[0:15] */ |
95 | CFG_UDF_EOL2 | 12, |
96 | /* End of L2, byte offset 26, dst IP[16:31] */ |
97 | CFG_UDF_EOL2 | 13, |
98 | /* End of L2, byte offset 28, dst IP[32:47] */ |
99 | CFG_UDF_EOL2 | 14, |
100 | /* End of L2, byte offset 30, dst IP[48:63] */ |
101 | CFG_UDF_EOL2 | 15, |
102 | /* End of L2, byte offset 32, dst IP[64:79] */ |
103 | CFG_UDF_EOL2 | 16, |
104 | /* End of L2, byte offset 34, dst IP[80:95] */ |
105 | CFG_UDF_EOL2 | 17, |
106 | /* End of L2, byte offset 36, dst IP[96:111] */ |
107 | CFG_UDF_EOL2 | 18, |
108 | /* End of L2, byte offset 38, dst IP[112:127] */ |
109 | CFG_UDF_EOL2 | 19, |
110 | /* End of L3, byte offset 2, dst port */ |
111 | CFG_UDF_EOL3 | 1, |
112 | }, |
113 | .mask_value = L3_FRAMING_MASK | IPPROTO_MASK | IP_FRAG, |
114 | .base_offset = CORE_UDF_0_D_0_11_PORT_0, |
115 | }, |
116 | }, |
117 | }; |
118 | |
119 | static inline unsigned int bcm_sf2_get_num_udf_slices(const u8 *layout) |
120 | { |
121 | unsigned int i, count = 0; |
122 | |
123 | for (i = 0; i < UDFS_PER_SLICE; i++) { |
124 | if (layout[i] != 0) |
125 | count++; |
126 | } |
127 | |
128 | return count; |
129 | } |
130 | |
131 | static inline u32 udf_upper_bits(int num_udf) |
132 | { |
133 | return GENMASK(num_udf - 1, 0) >> (UDFS_PER_SLICE - 1); |
134 | } |
135 | |
136 | static inline u32 udf_lower_bits(int num_udf) |
137 | { |
138 | return (u8)GENMASK(num_udf - 1, 0); |
139 | } |
140 | |
141 | static unsigned int bcm_sf2_get_slice_number(const struct cfp_udf_layout *l, |
142 | unsigned int start) |
143 | { |
144 | const struct cfp_udf_slice_layout *slice_layout; |
145 | unsigned int slice_idx; |
146 | |
147 | for (slice_idx = start; slice_idx < UDF_NUM_SLICES; slice_idx++) { |
148 | slice_layout = &l->udfs[slice_idx]; |
149 | if (memcmp(p: slice_layout->slices, q: zero_slice, |
150 | size: sizeof(zero_slice))) |
151 | break; |
152 | } |
153 | |
154 | return slice_idx; |
155 | } |
156 | |
157 | static void bcm_sf2_cfp_udf_set(struct bcm_sf2_priv *priv, |
158 | const struct cfp_udf_layout *layout, |
159 | unsigned int slice_num) |
160 | { |
161 | u32 offset = layout->udfs[slice_num].base_offset; |
162 | unsigned int i; |
163 | |
164 | for (i = 0; i < UDFS_PER_SLICE; i++) |
165 | core_writel(priv, val: layout->udfs[slice_num].slices[i], |
166 | off: offset + i * 4); |
167 | } |
168 | |
169 | static int bcm_sf2_cfp_op(struct bcm_sf2_priv *priv, unsigned int op) |
170 | { |
171 | unsigned int timeout = 1000; |
172 | u32 reg; |
173 | |
174 | reg = core_readl(priv, CORE_CFP_ACC); |
175 | reg &= ~(OP_SEL_MASK | RAM_SEL_MASK); |
176 | reg |= OP_STR_DONE | op; |
177 | core_writel(priv, val: reg, CORE_CFP_ACC); |
178 | |
179 | do { |
180 | reg = core_readl(priv, CORE_CFP_ACC); |
181 | if (!(reg & OP_STR_DONE)) |
182 | break; |
183 | |
184 | cpu_relax(); |
185 | } while (timeout--); |
186 | |
187 | if (!timeout) |
188 | return -ETIMEDOUT; |
189 | |
190 | return 0; |
191 | } |
192 | |
193 | static inline void bcm_sf2_cfp_rule_addr_set(struct bcm_sf2_priv *priv, |
194 | unsigned int addr) |
195 | { |
196 | u32 reg; |
197 | |
198 | WARN_ON(addr >= priv->num_cfp_rules); |
199 | |
200 | reg = core_readl(priv, CORE_CFP_ACC); |
201 | reg &= ~(XCESS_ADDR_MASK << XCESS_ADDR_SHIFT); |
202 | reg |= addr << XCESS_ADDR_SHIFT; |
203 | core_writel(priv, val: reg, CORE_CFP_ACC); |
204 | } |
205 | |
206 | static inline unsigned int bcm_sf2_cfp_rule_size(struct bcm_sf2_priv *priv) |
207 | { |
208 | /* Entry #0 is reserved */ |
209 | return priv->num_cfp_rules - 1; |
210 | } |
211 | |
212 | static int bcm_sf2_cfp_act_pol_set(struct bcm_sf2_priv *priv, |
213 | unsigned int rule_index, |
214 | int src_port, |
215 | unsigned int port_num, |
216 | unsigned int queue_num, |
217 | bool fwd_map_change) |
218 | { |
219 | int ret; |
220 | u32 reg; |
221 | |
222 | /* Replace ARL derived destination with DST_MAP derived, define |
223 | * which port and queue this should be forwarded to. |
224 | */ |
225 | if (fwd_map_change) |
226 | reg = CHANGE_FWRD_MAP_IB_REP_ARL | |
227 | BIT(port_num + DST_MAP_IB_SHIFT) | |
228 | CHANGE_TC | queue_num << NEW_TC_SHIFT; |
229 | else |
230 | reg = 0; |
231 | |
232 | /* Enable looping back to the original port */ |
233 | if (src_port == port_num) |
234 | reg |= LOOP_BK_EN; |
235 | |
236 | core_writel(priv, val: reg, CORE_ACT_POL_DATA0); |
237 | |
238 | /* Set classification ID that needs to be put in Broadcom tag */ |
239 | core_writel(priv, val: rule_index << CHAIN_ID_SHIFT, CORE_ACT_POL_DATA1); |
240 | |
241 | core_writel(priv, val: 0, CORE_ACT_POL_DATA2); |
242 | |
243 | /* Configure policer RAM now */ |
244 | ret = bcm_sf2_cfp_op(priv, OP_SEL_WRITE | ACT_POL_RAM); |
245 | if (ret) { |
246 | pr_err("Policer entry at %d failed\n" , rule_index); |
247 | return ret; |
248 | } |
249 | |
250 | /* Disable the policer */ |
251 | core_writel(priv, POLICER_MODE_DISABLE, CORE_RATE_METER0); |
252 | |
253 | /* Now the rate meter */ |
254 | ret = bcm_sf2_cfp_op(priv, OP_SEL_WRITE | RATE_METER_RAM); |
255 | if (ret) { |
256 | pr_err("Meter entry at %d failed\n" , rule_index); |
257 | return ret; |
258 | } |
259 | |
260 | return 0; |
261 | } |
262 | |
263 | static void bcm_sf2_cfp_slice_ipv4(struct bcm_sf2_priv *priv, |
264 | struct flow_dissector_key_ipv4_addrs *addrs, |
265 | struct flow_dissector_key_ports *ports, |
266 | const __be16 vlan_tci, |
267 | unsigned int slice_num, u8 num_udf, |
268 | bool mask) |
269 | { |
270 | u32 reg, offset; |
271 | |
272 | /* UDF_Valid[7:0] [31:24] |
273 | * S-Tag [23:8] |
274 | * C-Tag [7:0] |
275 | */ |
276 | reg = udf_lower_bits(num_udf) << 24 | be16_to_cpu(vlan_tci) >> 8; |
277 | if (mask) |
278 | core_writel(priv, val: reg, CORE_CFP_MASK_PORT(5)); |
279 | else |
280 | core_writel(priv, val: reg, CORE_CFP_DATA_PORT(5)); |
281 | |
282 | /* C-Tag [31:24] |
283 | * UDF_n_A8 [23:8] |
284 | * UDF_n_A7 [7:0] |
285 | */ |
286 | reg = (u32)(be16_to_cpu(vlan_tci) & 0xff) << 24; |
287 | if (mask) |
288 | offset = CORE_CFP_MASK_PORT(4); |
289 | else |
290 | offset = CORE_CFP_DATA_PORT(4); |
291 | core_writel(priv, val: reg, off: offset); |
292 | |
293 | /* UDF_n_A7 [31:24] |
294 | * UDF_n_A6 [23:8] |
295 | * UDF_n_A5 [7:0] |
296 | */ |
297 | reg = be16_to_cpu(ports->dst) >> 8; |
298 | if (mask) |
299 | offset = CORE_CFP_MASK_PORT(3); |
300 | else |
301 | offset = CORE_CFP_DATA_PORT(3); |
302 | core_writel(priv, val: reg, off: offset); |
303 | |
304 | /* UDF_n_A5 [31:24] |
305 | * UDF_n_A4 [23:8] |
306 | * UDF_n_A3 [7:0] |
307 | */ |
308 | reg = (be16_to_cpu(ports->dst) & 0xff) << 24 | |
309 | (u32)be16_to_cpu(ports->src) << 8 | |
310 | (be32_to_cpu(addrs->dst) & 0x0000ff00) >> 8; |
311 | if (mask) |
312 | offset = CORE_CFP_MASK_PORT(2); |
313 | else |
314 | offset = CORE_CFP_DATA_PORT(2); |
315 | core_writel(priv, val: reg, off: offset); |
316 | |
317 | /* UDF_n_A3 [31:24] |
318 | * UDF_n_A2 [23:8] |
319 | * UDF_n_A1 [7:0] |
320 | */ |
321 | reg = (u32)(be32_to_cpu(addrs->dst) & 0xff) << 24 | |
322 | (u32)(be32_to_cpu(addrs->dst) >> 16) << 8 | |
323 | (be32_to_cpu(addrs->src) & 0x0000ff00) >> 8; |
324 | if (mask) |
325 | offset = CORE_CFP_MASK_PORT(1); |
326 | else |
327 | offset = CORE_CFP_DATA_PORT(1); |
328 | core_writel(priv, val: reg, off: offset); |
329 | |
330 | /* UDF_n_A1 [31:24] |
331 | * UDF_n_A0 [23:8] |
332 | * Reserved [7:4] |
333 | * Slice ID [3:2] |
334 | * Slice valid [1:0] |
335 | */ |
336 | reg = (u32)(be32_to_cpu(addrs->src) & 0xff) << 24 | |
337 | (u32)(be32_to_cpu(addrs->src) >> 16) << 8 | |
338 | SLICE_NUM(slice_num) | SLICE_VALID; |
339 | if (mask) |
340 | offset = CORE_CFP_MASK_PORT(0); |
341 | else |
342 | offset = CORE_CFP_DATA_PORT(0); |
343 | core_writel(priv, val: reg, off: offset); |
344 | } |
345 | |
346 | static int bcm_sf2_cfp_ipv4_rule_set(struct bcm_sf2_priv *priv, int port, |
347 | unsigned int port_num, |
348 | unsigned int queue_num, |
349 | struct ethtool_rx_flow_spec *fs) |
350 | { |
351 | __be16 vlan_tci = 0, vlan_m_tci = htons(0xffff); |
352 | struct ethtool_rx_flow_spec_input input = {}; |
353 | const struct cfp_udf_layout *layout; |
354 | unsigned int slice_num, rule_index; |
355 | struct ethtool_rx_flow_rule *flow; |
356 | struct flow_match_ipv4_addrs ipv4; |
357 | struct flow_match_ports ports; |
358 | struct flow_match_ip ip; |
359 | u8 ip_proto, ip_frag; |
360 | u8 num_udf; |
361 | u32 reg; |
362 | int ret; |
363 | |
364 | switch (fs->flow_type & ~FLOW_EXT) { |
365 | case TCP_V4_FLOW: |
366 | ip_proto = IPPROTO_TCP; |
367 | break; |
368 | case UDP_V4_FLOW: |
369 | ip_proto = IPPROTO_UDP; |
370 | break; |
371 | default: |
372 | return -EINVAL; |
373 | } |
374 | |
375 | ip_frag = !!(be32_to_cpu(fs->h_ext.data[0]) & 1); |
376 | |
377 | /* Extract VLAN TCI */ |
378 | if (fs->flow_type & FLOW_EXT) { |
379 | vlan_tci = fs->h_ext.vlan_tci; |
380 | vlan_m_tci = fs->m_ext.vlan_tci; |
381 | } |
382 | |
383 | /* Locate the first rule available */ |
384 | if (fs->location == RX_CLS_LOC_ANY) |
385 | rule_index = find_first_zero_bit(addr: priv->cfp.used, |
386 | size: priv->num_cfp_rules); |
387 | else |
388 | rule_index = fs->location; |
389 | |
390 | if (rule_index > bcm_sf2_cfp_rule_size(priv)) |
391 | return -ENOSPC; |
392 | |
393 | input.fs = fs; |
394 | flow = ethtool_rx_flow_rule_create(input: &input); |
395 | if (IS_ERR(ptr: flow)) |
396 | return PTR_ERR(ptr: flow); |
397 | |
398 | flow_rule_match_ipv4_addrs(rule: flow->rule, out: &ipv4); |
399 | flow_rule_match_ports(rule: flow->rule, out: &ports); |
400 | flow_rule_match_ip(rule: flow->rule, out: &ip); |
401 | |
402 | layout = &udf_tcpip4_layout; |
403 | /* We only use one UDF slice for now */ |
404 | slice_num = bcm_sf2_get_slice_number(l: layout, start: 0); |
405 | if (slice_num == UDF_NUM_SLICES) { |
406 | ret = -EINVAL; |
407 | goto out_err_flow_rule; |
408 | } |
409 | |
410 | num_udf = bcm_sf2_get_num_udf_slices(layout: layout->udfs[slice_num].slices); |
411 | |
412 | /* Apply the UDF layout for this filter */ |
413 | bcm_sf2_cfp_udf_set(priv, layout, slice_num); |
414 | |
415 | /* Apply to all packets received through this port */ |
416 | core_writel(priv, BIT(port), CORE_CFP_DATA_PORT(7)); |
417 | |
418 | /* Source port map match */ |
419 | core_writel(priv, val: 0xff, CORE_CFP_MASK_PORT(7)); |
420 | |
421 | /* S-Tag status [31:30] |
422 | * C-Tag status [29:28] |
423 | * L2 framing [27:26] |
424 | * L3 framing [25:24] |
425 | * IP ToS [23:16] |
426 | * IP proto [15:08] |
427 | * IP Fragm [7] |
428 | * Non 1st frag [6] |
429 | * IP Authen [5] |
430 | * TTL range [4:3] |
431 | * PPPoE session [2] |
432 | * Reserved [1] |
433 | * UDF_Valid[8] [0] |
434 | */ |
435 | core_writel(priv, val: ip.key->tos << IPTOS_SHIFT | |
436 | ip_proto << IPPROTO_SHIFT | ip_frag << IP_FRAG_SHIFT | |
437 | udf_upper_bits(num_udf), |
438 | CORE_CFP_DATA_PORT(6)); |
439 | |
440 | /* Mask with the specific layout for IPv4 packets */ |
441 | core_writel(priv, val: layout->udfs[slice_num].mask_value | |
442 | udf_upper_bits(num_udf), CORE_CFP_MASK_PORT(6)); |
443 | |
444 | /* Program the match and the mask */ |
445 | bcm_sf2_cfp_slice_ipv4(priv, addrs: ipv4.key, ports: ports.key, vlan_tci, |
446 | slice_num, num_udf, mask: false); |
447 | bcm_sf2_cfp_slice_ipv4(priv, addrs: ipv4.mask, ports: ports.mask, vlan_tci: vlan_m_tci, |
448 | SLICE_NUM_MASK, num_udf, mask: true); |
449 | |
450 | /* Insert into TCAM now */ |
451 | bcm_sf2_cfp_rule_addr_set(priv, addr: rule_index); |
452 | |
453 | ret = bcm_sf2_cfp_op(priv, OP_SEL_WRITE | TCAM_SEL); |
454 | if (ret) { |
455 | pr_err("TCAM entry at addr %d failed\n" , rule_index); |
456 | goto out_err_flow_rule; |
457 | } |
458 | |
459 | /* Insert into Action and policer RAMs now */ |
460 | ret = bcm_sf2_cfp_act_pol_set(priv, rule_index, src_port: port, port_num, |
461 | queue_num, fwd_map_change: true); |
462 | if (ret) |
463 | goto out_err_flow_rule; |
464 | |
465 | /* Turn on CFP for this rule now */ |
466 | reg = core_readl(priv, CORE_CFP_CTL_REG); |
467 | reg |= BIT(port); |
468 | core_writel(priv, val: reg, CORE_CFP_CTL_REG); |
469 | |
470 | /* Flag the rule as being used and return it */ |
471 | set_bit(nr: rule_index, addr: priv->cfp.used); |
472 | set_bit(nr: rule_index, addr: priv->cfp.unique); |
473 | fs->location = rule_index; |
474 | |
475 | return 0; |
476 | |
477 | out_err_flow_rule: |
478 | ethtool_rx_flow_rule_destroy(rule: flow); |
479 | return ret; |
480 | } |
481 | |
482 | static void bcm_sf2_cfp_slice_ipv6(struct bcm_sf2_priv *priv, |
483 | const __be32 *ip6_addr, const __be16 port, |
484 | const __be16 vlan_tci, |
485 | unsigned int slice_num, u32 udf_bits, |
486 | bool mask) |
487 | { |
488 | u32 reg, tmp, val, offset; |
489 | |
490 | /* UDF_Valid[7:0] [31:24] |
491 | * S-Tag [23:8] |
492 | * C-Tag [7:0] |
493 | */ |
494 | reg = udf_bits << 24 | be16_to_cpu(vlan_tci) >> 8; |
495 | if (mask) |
496 | core_writel(priv, val: reg, CORE_CFP_MASK_PORT(5)); |
497 | else |
498 | core_writel(priv, val: reg, CORE_CFP_DATA_PORT(5)); |
499 | |
500 | /* C-Tag [31:24] |
501 | * UDF_n_B8 [23:8] (port) |
502 | * UDF_n_B7 (upper) [7:0] (addr[15:8]) |
503 | */ |
504 | reg = be32_to_cpu(ip6_addr[3]); |
505 | val = (u32)be16_to_cpu(port) << 8 | ((reg >> 8) & 0xff); |
506 | val |= (u32)(be16_to_cpu(vlan_tci) & 0xff) << 24; |
507 | if (mask) |
508 | offset = CORE_CFP_MASK_PORT(4); |
509 | else |
510 | offset = CORE_CFP_DATA_PORT(4); |
511 | core_writel(priv, val, off: offset); |
512 | |
513 | /* UDF_n_B7 (lower) [31:24] (addr[7:0]) |
514 | * UDF_n_B6 [23:8] (addr[31:16]) |
515 | * UDF_n_B5 (upper) [7:0] (addr[47:40]) |
516 | */ |
517 | tmp = be32_to_cpu(ip6_addr[2]); |
518 | val = (u32)(reg & 0xff) << 24 | (u32)(reg >> 16) << 8 | |
519 | ((tmp >> 8) & 0xff); |
520 | if (mask) |
521 | offset = CORE_CFP_MASK_PORT(3); |
522 | else |
523 | offset = CORE_CFP_DATA_PORT(3); |
524 | core_writel(priv, val, off: offset); |
525 | |
526 | /* UDF_n_B5 (lower) [31:24] (addr[39:32]) |
527 | * UDF_n_B4 [23:8] (addr[63:48]) |
528 | * UDF_n_B3 (upper) [7:0] (addr[79:72]) |
529 | */ |
530 | reg = be32_to_cpu(ip6_addr[1]); |
531 | val = (u32)(tmp & 0xff) << 24 | (u32)(tmp >> 16) << 8 | |
532 | ((reg >> 8) & 0xff); |
533 | if (mask) |
534 | offset = CORE_CFP_MASK_PORT(2); |
535 | else |
536 | offset = CORE_CFP_DATA_PORT(2); |
537 | core_writel(priv, val, off: offset); |
538 | |
539 | /* UDF_n_B3 (lower) [31:24] (addr[71:64]) |
540 | * UDF_n_B2 [23:8] (addr[95:80]) |
541 | * UDF_n_B1 (upper) [7:0] (addr[111:104]) |
542 | */ |
543 | tmp = be32_to_cpu(ip6_addr[0]); |
544 | val = (u32)(reg & 0xff) << 24 | (u32)(reg >> 16) << 8 | |
545 | ((tmp >> 8) & 0xff); |
546 | if (mask) |
547 | offset = CORE_CFP_MASK_PORT(1); |
548 | else |
549 | offset = CORE_CFP_DATA_PORT(1); |
550 | core_writel(priv, val, off: offset); |
551 | |
552 | /* UDF_n_B1 (lower) [31:24] (addr[103:96]) |
553 | * UDF_n_B0 [23:8] (addr[127:112]) |
554 | * Reserved [7:4] |
555 | * Slice ID [3:2] |
556 | * Slice valid [1:0] |
557 | */ |
558 | reg = (u32)(tmp & 0xff) << 24 | (u32)(tmp >> 16) << 8 | |
559 | SLICE_NUM(slice_num) | SLICE_VALID; |
560 | if (mask) |
561 | offset = CORE_CFP_MASK_PORT(0); |
562 | else |
563 | offset = CORE_CFP_DATA_PORT(0); |
564 | core_writel(priv, val: reg, off: offset); |
565 | } |
566 | |
567 | static struct cfp_rule *bcm_sf2_cfp_rule_find(struct bcm_sf2_priv *priv, |
568 | int port, u32 location) |
569 | { |
570 | struct cfp_rule *rule; |
571 | |
572 | list_for_each_entry(rule, &priv->cfp.rules_list, next) { |
573 | if (rule->port == port && rule->fs.location == location) |
574 | return rule; |
575 | } |
576 | |
577 | return NULL; |
578 | } |
579 | |
580 | static int bcm_sf2_cfp_rule_cmp(struct bcm_sf2_priv *priv, int port, |
581 | struct ethtool_rx_flow_spec *fs) |
582 | { |
583 | struct cfp_rule *rule = NULL; |
584 | size_t fs_size = 0; |
585 | int ret = 1; |
586 | |
587 | if (list_empty(head: &priv->cfp.rules_list)) |
588 | return ret; |
589 | |
590 | list_for_each_entry(rule, &priv->cfp.rules_list, next) { |
591 | ret = 1; |
592 | if (rule->port != port) |
593 | continue; |
594 | |
595 | if (rule->fs.flow_type != fs->flow_type || |
596 | rule->fs.ring_cookie != fs->ring_cookie || |
597 | rule->fs.h_ext.data[0] != fs->h_ext.data[0]) |
598 | continue; |
599 | |
600 | switch (fs->flow_type & ~FLOW_EXT) { |
601 | case TCP_V6_FLOW: |
602 | case UDP_V6_FLOW: |
603 | fs_size = sizeof(struct ethtool_tcpip6_spec); |
604 | break; |
605 | case TCP_V4_FLOW: |
606 | case UDP_V4_FLOW: |
607 | fs_size = sizeof(struct ethtool_tcpip4_spec); |
608 | break; |
609 | default: |
610 | continue; |
611 | } |
612 | |
613 | ret = memcmp(p: &rule->fs.h_u, q: &fs->h_u, size: fs_size); |
614 | ret |= memcmp(p: &rule->fs.m_u, q: &fs->m_u, size: fs_size); |
615 | /* Compare VLAN TCI values as well */ |
616 | if (rule->fs.flow_type & FLOW_EXT) { |
617 | ret |= rule->fs.h_ext.vlan_tci != fs->h_ext.vlan_tci; |
618 | ret |= rule->fs.m_ext.vlan_tci != fs->m_ext.vlan_tci; |
619 | } |
620 | if (ret == 0) |
621 | break; |
622 | } |
623 | |
624 | return ret; |
625 | } |
626 | |
627 | static int bcm_sf2_cfp_ipv6_rule_set(struct bcm_sf2_priv *priv, int port, |
628 | unsigned int port_num, |
629 | unsigned int queue_num, |
630 | struct ethtool_rx_flow_spec *fs) |
631 | { |
632 | __be16 vlan_tci = 0, vlan_m_tci = htons(0xffff); |
633 | struct ethtool_rx_flow_spec_input input = {}; |
634 | unsigned int slice_num, rule_index[2]; |
635 | const struct cfp_udf_layout *layout; |
636 | struct ethtool_rx_flow_rule *flow; |
637 | struct flow_match_ipv6_addrs ipv6; |
638 | struct flow_match_ports ports; |
639 | u8 ip_proto, ip_frag; |
640 | int ret = 0; |
641 | u8 num_udf; |
642 | u32 reg; |
643 | |
644 | switch (fs->flow_type & ~FLOW_EXT) { |
645 | case TCP_V6_FLOW: |
646 | ip_proto = IPPROTO_TCP; |
647 | break; |
648 | case UDP_V6_FLOW: |
649 | ip_proto = IPPROTO_UDP; |
650 | break; |
651 | default: |
652 | return -EINVAL; |
653 | } |
654 | |
655 | ip_frag = !!(be32_to_cpu(fs->h_ext.data[0]) & 1); |
656 | |
657 | /* Extract VLAN TCI */ |
658 | if (fs->flow_type & FLOW_EXT) { |
659 | vlan_tci = fs->h_ext.vlan_tci; |
660 | vlan_m_tci = fs->m_ext.vlan_tci; |
661 | } |
662 | |
663 | layout = &udf_tcpip6_layout; |
664 | slice_num = bcm_sf2_get_slice_number(l: layout, start: 0); |
665 | if (slice_num == UDF_NUM_SLICES) |
666 | return -EINVAL; |
667 | |
668 | num_udf = bcm_sf2_get_num_udf_slices(layout: layout->udfs[slice_num].slices); |
669 | |
670 | /* Negotiate two indexes, one for the second half which we are chained |
671 | * from, which is what we will return to user-space, and a second one |
672 | * which is used to store its first half. That first half does not |
673 | * allow any choice of placement, so it just needs to find the next |
674 | * available bit. We return the second half as fs->location because |
675 | * that helps with the rule lookup later on since the second half is |
676 | * chained from its first half, we can easily identify IPv6 CFP rules |
677 | * by looking whether they carry a CHAIN_ID. |
678 | * |
679 | * We also want the second half to have a lower rule_index than its |
680 | * first half because the HW search is by incrementing addresses. |
681 | */ |
682 | if (fs->location == RX_CLS_LOC_ANY) |
683 | rule_index[1] = find_first_zero_bit(addr: priv->cfp.used, |
684 | size: priv->num_cfp_rules); |
685 | else |
686 | rule_index[1] = fs->location; |
687 | if (rule_index[1] > bcm_sf2_cfp_rule_size(priv)) |
688 | return -ENOSPC; |
689 | |
690 | /* Flag it as used (cleared on error path) such that we can immediately |
691 | * obtain a second one to chain from. |
692 | */ |
693 | set_bit(nr: rule_index[1], addr: priv->cfp.used); |
694 | |
695 | rule_index[0] = find_first_zero_bit(addr: priv->cfp.used, |
696 | size: priv->num_cfp_rules); |
697 | if (rule_index[0] > bcm_sf2_cfp_rule_size(priv)) { |
698 | ret = -ENOSPC; |
699 | goto out_err; |
700 | } |
701 | |
702 | input.fs = fs; |
703 | flow = ethtool_rx_flow_rule_create(input: &input); |
704 | if (IS_ERR(ptr: flow)) { |
705 | ret = PTR_ERR(ptr: flow); |
706 | goto out_err; |
707 | } |
708 | flow_rule_match_ipv6_addrs(rule: flow->rule, out: &ipv6); |
709 | flow_rule_match_ports(rule: flow->rule, out: &ports); |
710 | |
711 | /* Apply the UDF layout for this filter */ |
712 | bcm_sf2_cfp_udf_set(priv, layout, slice_num); |
713 | |
714 | /* Apply to all packets received through this port */ |
715 | core_writel(priv, BIT(port), CORE_CFP_DATA_PORT(7)); |
716 | |
717 | /* Source port map match */ |
718 | core_writel(priv, val: 0xff, CORE_CFP_MASK_PORT(7)); |
719 | |
720 | /* S-Tag status [31:30] |
721 | * C-Tag status [29:28] |
722 | * L2 framing [27:26] |
723 | * L3 framing [25:24] |
724 | * IP ToS [23:16] |
725 | * IP proto [15:08] |
726 | * IP Fragm [7] |
727 | * Non 1st frag [6] |
728 | * IP Authen [5] |
729 | * TTL range [4:3] |
730 | * PPPoE session [2] |
731 | * Reserved [1] |
732 | * UDF_Valid[8] [0] |
733 | */ |
734 | reg = 1 << L3_FRAMING_SHIFT | ip_proto << IPPROTO_SHIFT | |
735 | ip_frag << IP_FRAG_SHIFT | udf_upper_bits(num_udf); |
736 | core_writel(priv, val: reg, CORE_CFP_DATA_PORT(6)); |
737 | |
738 | /* Mask with the specific layout for IPv6 packets including |
739 | * UDF_Valid[8] |
740 | */ |
741 | reg = layout->udfs[slice_num].mask_value | udf_upper_bits(num_udf); |
742 | core_writel(priv, val: reg, CORE_CFP_MASK_PORT(6)); |
743 | |
744 | /* Slice the IPv6 source address and port */ |
745 | bcm_sf2_cfp_slice_ipv6(priv, ip6_addr: ipv6.key->src.in6_u.u6_addr32, |
746 | port: ports.key->src, vlan_tci, slice_num, |
747 | udf_bits: udf_lower_bits(num_udf), mask: false); |
748 | bcm_sf2_cfp_slice_ipv6(priv, ip6_addr: ipv6.mask->src.in6_u.u6_addr32, |
749 | port: ports.mask->src, vlan_tci: vlan_m_tci, SLICE_NUM_MASK, |
750 | udf_bits: udf_lower_bits(num_udf), mask: true); |
751 | |
752 | /* Insert into TCAM now because we need to insert a second rule */ |
753 | bcm_sf2_cfp_rule_addr_set(priv, addr: rule_index[0]); |
754 | |
755 | ret = bcm_sf2_cfp_op(priv, OP_SEL_WRITE | TCAM_SEL); |
756 | if (ret) { |
757 | pr_err("TCAM entry at addr %d failed\n" , rule_index[0]); |
758 | goto out_err_flow_rule; |
759 | } |
760 | |
761 | /* Insert into Action and policer RAMs now */ |
762 | ret = bcm_sf2_cfp_act_pol_set(priv, rule_index: rule_index[0], src_port: port, port_num, |
763 | queue_num, fwd_map_change: false); |
764 | if (ret) |
765 | goto out_err_flow_rule; |
766 | |
767 | /* Now deal with the second slice to chain this rule */ |
768 | slice_num = bcm_sf2_get_slice_number(l: layout, start: slice_num + 1); |
769 | if (slice_num == UDF_NUM_SLICES) { |
770 | ret = -EINVAL; |
771 | goto out_err_flow_rule; |
772 | } |
773 | |
774 | num_udf = bcm_sf2_get_num_udf_slices(layout: layout->udfs[slice_num].slices); |
775 | |
776 | /* Apply the UDF layout for this filter */ |
777 | bcm_sf2_cfp_udf_set(priv, layout, slice_num); |
778 | |
779 | /* Chained rule, source port match is coming from the rule we are |
780 | * chained from. |
781 | */ |
782 | core_writel(priv, val: 0, CORE_CFP_DATA_PORT(7)); |
783 | core_writel(priv, val: 0, CORE_CFP_MASK_PORT(7)); |
784 | |
785 | /* |
786 | * CHAIN ID [31:24] chain to previous slice |
787 | * Reserved [23:20] |
788 | * UDF_Valid[11:8] [19:16] |
789 | * UDF_Valid[7:0] [15:8] |
790 | * UDF_n_D11 [7:0] |
791 | */ |
792 | reg = rule_index[0] << 24 | udf_upper_bits(num_udf) << 16 | |
793 | udf_lower_bits(num_udf) << 8; |
794 | core_writel(priv, val: reg, CORE_CFP_DATA_PORT(6)); |
795 | |
796 | /* Mask all except chain ID, UDF Valid[8] and UDF Valid[7:0] */ |
797 | reg = XCESS_ADDR_MASK << 24 | udf_upper_bits(num_udf) << 16 | |
798 | udf_lower_bits(num_udf) << 8; |
799 | core_writel(priv, val: reg, CORE_CFP_MASK_PORT(6)); |
800 | |
801 | bcm_sf2_cfp_slice_ipv6(priv, ip6_addr: ipv6.key->dst.in6_u.u6_addr32, |
802 | port: ports.key->dst, vlan_tci: 0, slice_num, |
803 | udf_bits: 0, mask: false); |
804 | bcm_sf2_cfp_slice_ipv6(priv, ip6_addr: ipv6.mask->dst.in6_u.u6_addr32, |
805 | port: ports.key->dst, vlan_tci: 0, SLICE_NUM_MASK, |
806 | udf_bits: 0, mask: true); |
807 | |
808 | /* Insert into TCAM now */ |
809 | bcm_sf2_cfp_rule_addr_set(priv, addr: rule_index[1]); |
810 | |
811 | ret = bcm_sf2_cfp_op(priv, OP_SEL_WRITE | TCAM_SEL); |
812 | if (ret) { |
813 | pr_err("TCAM entry at addr %d failed\n" , rule_index[1]); |
814 | goto out_err_flow_rule; |
815 | } |
816 | |
817 | /* Insert into Action and policer RAMs now, set chain ID to |
818 | * the one we are chained to |
819 | */ |
820 | ret = bcm_sf2_cfp_act_pol_set(priv, rule_index: rule_index[1], src_port: port, port_num, |
821 | queue_num, fwd_map_change: true); |
822 | if (ret) |
823 | goto out_err_flow_rule; |
824 | |
825 | /* Turn on CFP for this rule now */ |
826 | reg = core_readl(priv, CORE_CFP_CTL_REG); |
827 | reg |= BIT(port); |
828 | core_writel(priv, val: reg, CORE_CFP_CTL_REG); |
829 | |
830 | /* Flag the second half rule as being used now, return it as the |
831 | * location, and flag it as unique while dumping rules |
832 | */ |
833 | set_bit(nr: rule_index[0], addr: priv->cfp.used); |
834 | set_bit(nr: rule_index[1], addr: priv->cfp.unique); |
835 | fs->location = rule_index[1]; |
836 | |
837 | return ret; |
838 | |
839 | out_err_flow_rule: |
840 | ethtool_rx_flow_rule_destroy(rule: flow); |
841 | out_err: |
842 | clear_bit(nr: rule_index[1], addr: priv->cfp.used); |
843 | return ret; |
844 | } |
845 | |
846 | static int bcm_sf2_cfp_rule_insert(struct dsa_switch *ds, int port, |
847 | struct ethtool_rx_flow_spec *fs) |
848 | { |
849 | struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds); |
850 | s8 cpu_port = dsa_to_port(ds, p: port)->cpu_dp->index; |
851 | __u64 ring_cookie = fs->ring_cookie; |
852 | struct switchdev_obj_port_vlan vlan; |
853 | unsigned int queue_num, port_num; |
854 | u16 vid; |
855 | int ret; |
856 | |
857 | /* This rule is a Wake-on-LAN filter and we must specifically |
858 | * target the CPU port in order for it to be working. |
859 | */ |
860 | if (ring_cookie == RX_CLS_FLOW_WAKE) |
861 | ring_cookie = cpu_port * SF2_NUM_EGRESS_QUEUES; |
862 | |
863 | /* We do not support discarding packets, check that the |
864 | * destination port is enabled and that we are within the |
865 | * number of ports supported by the switch |
866 | */ |
867 | port_num = ring_cookie / SF2_NUM_EGRESS_QUEUES; |
868 | |
869 | if (ring_cookie == RX_CLS_FLOW_DISC || |
870 | !(dsa_is_user_port(ds, p: port_num) || |
871 | dsa_is_cpu_port(ds, p: port_num)) || |
872 | port_num >= priv->hw_params.num_ports) |
873 | return -EINVAL; |
874 | |
875 | /* If the rule is matching a particular VLAN, make sure that we honor |
876 | * the matching and have it tagged or untagged on the destination port, |
877 | * we do this on egress with a VLAN entry. The egress tagging attribute |
878 | * is expected to be provided in h_ext.data[1] bit 0. A 1 means untagged, |
879 | * a 0 means tagged. |
880 | */ |
881 | if (fs->flow_type & FLOW_EXT) { |
882 | /* We cannot support matching multiple VLAN IDs yet */ |
883 | if ((be16_to_cpu(fs->m_ext.vlan_tci) & VLAN_VID_MASK) != |
884 | VLAN_VID_MASK) |
885 | return -EINVAL; |
886 | |
887 | vid = be16_to_cpu(fs->h_ext.vlan_tci) & VLAN_VID_MASK; |
888 | vlan.vid = vid; |
889 | if (be32_to_cpu(fs->h_ext.data[1]) & 1) |
890 | vlan.flags = BRIDGE_VLAN_INFO_UNTAGGED; |
891 | else |
892 | vlan.flags = 0; |
893 | |
894 | ret = ds->ops->port_vlan_add(ds, port_num, &vlan, NULL); |
895 | if (ret) |
896 | return ret; |
897 | } |
898 | |
899 | /* |
900 | * We have a small oddity where Port 6 just does not have a |
901 | * valid bit here (so we substract by one). |
902 | */ |
903 | queue_num = ring_cookie % SF2_NUM_EGRESS_QUEUES; |
904 | if (port_num >= 7) |
905 | port_num -= 1; |
906 | |
907 | switch (fs->flow_type & ~FLOW_EXT) { |
908 | case TCP_V4_FLOW: |
909 | case UDP_V4_FLOW: |
910 | ret = bcm_sf2_cfp_ipv4_rule_set(priv, port, port_num, |
911 | queue_num, fs); |
912 | break; |
913 | case TCP_V6_FLOW: |
914 | case UDP_V6_FLOW: |
915 | ret = bcm_sf2_cfp_ipv6_rule_set(priv, port, port_num, |
916 | queue_num, fs); |
917 | break; |
918 | default: |
919 | ret = -EINVAL; |
920 | break; |
921 | } |
922 | |
923 | return ret; |
924 | } |
925 | |
926 | static int bcm_sf2_cfp_rule_set(struct dsa_switch *ds, int port, |
927 | struct ethtool_rx_flow_spec *fs) |
928 | { |
929 | struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds); |
930 | struct cfp_rule *rule = NULL; |
931 | int ret = -EINVAL; |
932 | |
933 | /* Check for unsupported extensions */ |
934 | if (fs->flow_type & FLOW_MAC_EXT) |
935 | return -EINVAL; |
936 | |
937 | if (fs->location != RX_CLS_LOC_ANY && |
938 | fs->location > bcm_sf2_cfp_rule_size(priv)) |
939 | return -EINVAL; |
940 | |
941 | if ((fs->flow_type & FLOW_EXT) && |
942 | !(ds->ops->port_vlan_add || ds->ops->port_vlan_del)) |
943 | return -EOPNOTSUPP; |
944 | |
945 | if (fs->location != RX_CLS_LOC_ANY && |
946 | test_bit(fs->location, priv->cfp.used)) |
947 | return -EBUSY; |
948 | |
949 | ret = bcm_sf2_cfp_rule_cmp(priv, port, fs); |
950 | if (ret == 0) |
951 | return -EEXIST; |
952 | |
953 | rule = kzalloc(size: sizeof(*rule), GFP_KERNEL); |
954 | if (!rule) |
955 | return -ENOMEM; |
956 | |
957 | ret = bcm_sf2_cfp_rule_insert(ds, port, fs); |
958 | if (ret) { |
959 | kfree(objp: rule); |
960 | return ret; |
961 | } |
962 | |
963 | rule->port = port; |
964 | memcpy(&rule->fs, fs, sizeof(*fs)); |
965 | list_add_tail(new: &rule->next, head: &priv->cfp.rules_list); |
966 | |
967 | return ret; |
968 | } |
969 | |
970 | static int bcm_sf2_cfp_rule_del_one(struct bcm_sf2_priv *priv, int port, |
971 | u32 loc, u32 *next_loc) |
972 | { |
973 | int ret; |
974 | u32 reg; |
975 | |
976 | /* Indicate which rule we want to read */ |
977 | bcm_sf2_cfp_rule_addr_set(priv, addr: loc); |
978 | |
979 | ret = bcm_sf2_cfp_op(priv, OP_SEL_READ | TCAM_SEL); |
980 | if (ret) |
981 | return ret; |
982 | |
983 | /* Check if this is possibly an IPv6 rule that would |
984 | * indicate we need to delete its companion rule |
985 | * as well |
986 | */ |
987 | reg = core_readl(priv, CORE_CFP_DATA_PORT(6)); |
988 | if (next_loc) |
989 | *next_loc = (reg >> 24) & CHAIN_ID_MASK; |
990 | |
991 | /* Clear its valid bits */ |
992 | reg = core_readl(priv, CORE_CFP_DATA_PORT(0)); |
993 | reg &= ~SLICE_VALID; |
994 | core_writel(priv, val: reg, CORE_CFP_DATA_PORT(0)); |
995 | |
996 | /* Write back this entry into the TCAM now */ |
997 | ret = bcm_sf2_cfp_op(priv, OP_SEL_WRITE | TCAM_SEL); |
998 | if (ret) |
999 | return ret; |
1000 | |
1001 | clear_bit(nr: loc, addr: priv->cfp.used); |
1002 | clear_bit(nr: loc, addr: priv->cfp.unique); |
1003 | |
1004 | return 0; |
1005 | } |
1006 | |
1007 | static int bcm_sf2_cfp_rule_remove(struct bcm_sf2_priv *priv, int port, |
1008 | u32 loc) |
1009 | { |
1010 | u32 next_loc = 0; |
1011 | int ret; |
1012 | |
1013 | ret = bcm_sf2_cfp_rule_del_one(priv, port, loc, next_loc: &next_loc); |
1014 | if (ret) |
1015 | return ret; |
1016 | |
1017 | /* If this was an IPv6 rule, delete is companion rule too */ |
1018 | if (next_loc) |
1019 | ret = bcm_sf2_cfp_rule_del_one(priv, port, loc: next_loc, NULL); |
1020 | |
1021 | return ret; |
1022 | } |
1023 | |
1024 | static int bcm_sf2_cfp_rule_del(struct bcm_sf2_priv *priv, int port, u32 loc) |
1025 | { |
1026 | struct cfp_rule *rule; |
1027 | int ret; |
1028 | |
1029 | if (loc > bcm_sf2_cfp_rule_size(priv)) |
1030 | return -EINVAL; |
1031 | |
1032 | /* Refuse deleting unused rules, and those that are not unique since |
1033 | * that could leave IPv6 rules with one of the chained rule in the |
1034 | * table. |
1035 | */ |
1036 | if (!test_bit(loc, priv->cfp.unique) || loc == 0) |
1037 | return -EINVAL; |
1038 | |
1039 | rule = bcm_sf2_cfp_rule_find(priv, port, location: loc); |
1040 | if (!rule) |
1041 | return -EINVAL; |
1042 | |
1043 | ret = bcm_sf2_cfp_rule_remove(priv, port, loc); |
1044 | |
1045 | list_del(entry: &rule->next); |
1046 | kfree(objp: rule); |
1047 | |
1048 | return ret; |
1049 | } |
1050 | |
1051 | static void bcm_sf2_invert_masks(struct ethtool_rx_flow_spec *flow) |
1052 | { |
1053 | unsigned int i; |
1054 | |
1055 | for (i = 0; i < sizeof(flow->m_u); i++) |
1056 | flow->m_u.hdata[i] ^= 0xff; |
1057 | |
1058 | flow->m_ext.vlan_etype ^= cpu_to_be16(~0); |
1059 | flow->m_ext.vlan_tci ^= cpu_to_be16(~0); |
1060 | flow->m_ext.data[0] ^= cpu_to_be32(~0); |
1061 | flow->m_ext.data[1] ^= cpu_to_be32(~0); |
1062 | } |
1063 | |
1064 | static int bcm_sf2_cfp_rule_get(struct bcm_sf2_priv *priv, int port, |
1065 | struct ethtool_rxnfc *nfc) |
1066 | { |
1067 | struct cfp_rule *rule; |
1068 | |
1069 | rule = bcm_sf2_cfp_rule_find(priv, port, location: nfc->fs.location); |
1070 | if (!rule) |
1071 | return -EINVAL; |
1072 | |
1073 | memcpy(&nfc->fs, &rule->fs, sizeof(rule->fs)); |
1074 | |
1075 | bcm_sf2_invert_masks(flow: &nfc->fs); |
1076 | |
1077 | /* Put the TCAM size here */ |
1078 | nfc->data = bcm_sf2_cfp_rule_size(priv); |
1079 | |
1080 | return 0; |
1081 | } |
1082 | |
1083 | /* We implement the search doing a TCAM search operation */ |
1084 | static int bcm_sf2_cfp_rule_get_all(struct bcm_sf2_priv *priv, |
1085 | int port, struct ethtool_rxnfc *nfc, |
1086 | u32 *rule_locs) |
1087 | { |
1088 | unsigned int index = 1, rules_cnt = 0; |
1089 | |
1090 | for_each_set_bit_from(index, priv->cfp.unique, priv->num_cfp_rules) { |
1091 | rule_locs[rules_cnt] = index; |
1092 | rules_cnt++; |
1093 | } |
1094 | |
1095 | /* Put the TCAM size here */ |
1096 | nfc->data = bcm_sf2_cfp_rule_size(priv); |
1097 | nfc->rule_cnt = rules_cnt; |
1098 | |
1099 | return 0; |
1100 | } |
1101 | |
1102 | int bcm_sf2_get_rxnfc(struct dsa_switch *ds, int port, |
1103 | struct ethtool_rxnfc *nfc, u32 *rule_locs) |
1104 | { |
1105 | struct net_device *p = dsa_port_to_conduit(dp: dsa_to_port(ds, p: port)); |
1106 | struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds); |
1107 | int ret = 0; |
1108 | |
1109 | mutex_lock(&priv->cfp.lock); |
1110 | |
1111 | switch (nfc->cmd) { |
1112 | case ETHTOOL_GRXCLSRLCNT: |
1113 | /* Subtract the default, unusable rule */ |
1114 | nfc->rule_cnt = bitmap_weight(src: priv->cfp.unique, |
1115 | nbits: priv->num_cfp_rules) - 1; |
1116 | /* We support specifying rule locations */ |
1117 | nfc->data |= RX_CLS_LOC_SPECIAL; |
1118 | break; |
1119 | case ETHTOOL_GRXCLSRULE: |
1120 | ret = bcm_sf2_cfp_rule_get(priv, port, nfc); |
1121 | break; |
1122 | case ETHTOOL_GRXCLSRLALL: |
1123 | ret = bcm_sf2_cfp_rule_get_all(priv, port, nfc, rule_locs); |
1124 | break; |
1125 | default: |
1126 | ret = -EOPNOTSUPP; |
1127 | break; |
1128 | } |
1129 | |
1130 | mutex_unlock(lock: &priv->cfp.lock); |
1131 | |
1132 | if (ret) |
1133 | return ret; |
1134 | |
1135 | /* Pass up the commands to the attached master network device */ |
1136 | if (p->ethtool_ops->get_rxnfc) { |
1137 | ret = p->ethtool_ops->get_rxnfc(p, nfc, rule_locs); |
1138 | if (ret == -EOPNOTSUPP) |
1139 | ret = 0; |
1140 | } |
1141 | |
1142 | return ret; |
1143 | } |
1144 | |
1145 | int bcm_sf2_set_rxnfc(struct dsa_switch *ds, int port, |
1146 | struct ethtool_rxnfc *nfc) |
1147 | { |
1148 | struct net_device *p = dsa_port_to_conduit(dp: dsa_to_port(ds, p: port)); |
1149 | struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds); |
1150 | int ret = 0; |
1151 | |
1152 | mutex_lock(&priv->cfp.lock); |
1153 | |
1154 | switch (nfc->cmd) { |
1155 | case ETHTOOL_SRXCLSRLINS: |
1156 | ret = bcm_sf2_cfp_rule_set(ds, port, fs: &nfc->fs); |
1157 | break; |
1158 | |
1159 | case ETHTOOL_SRXCLSRLDEL: |
1160 | ret = bcm_sf2_cfp_rule_del(priv, port, loc: nfc->fs.location); |
1161 | break; |
1162 | default: |
1163 | ret = -EOPNOTSUPP; |
1164 | break; |
1165 | } |
1166 | |
1167 | mutex_unlock(lock: &priv->cfp.lock); |
1168 | |
1169 | if (ret) |
1170 | return ret; |
1171 | |
1172 | /* Pass up the commands to the attached master network device. |
1173 | * This can fail, so rollback the operation if we need to. |
1174 | */ |
1175 | if (p->ethtool_ops->set_rxnfc) { |
1176 | ret = p->ethtool_ops->set_rxnfc(p, nfc); |
1177 | if (ret && ret != -EOPNOTSUPP) { |
1178 | mutex_lock(&priv->cfp.lock); |
1179 | bcm_sf2_cfp_rule_del(priv, port, loc: nfc->fs.location); |
1180 | mutex_unlock(lock: &priv->cfp.lock); |
1181 | } else { |
1182 | ret = 0; |
1183 | } |
1184 | } |
1185 | |
1186 | return ret; |
1187 | } |
1188 | |
1189 | int bcm_sf2_cfp_rst(struct bcm_sf2_priv *priv) |
1190 | { |
1191 | unsigned int timeout = 1000; |
1192 | u32 reg; |
1193 | |
1194 | reg = core_readl(priv, CORE_CFP_ACC); |
1195 | reg |= TCAM_RESET; |
1196 | core_writel(priv, val: reg, CORE_CFP_ACC); |
1197 | |
1198 | do { |
1199 | reg = core_readl(priv, CORE_CFP_ACC); |
1200 | if (!(reg & TCAM_RESET)) |
1201 | break; |
1202 | |
1203 | cpu_relax(); |
1204 | } while (timeout--); |
1205 | |
1206 | if (!timeout) |
1207 | return -ETIMEDOUT; |
1208 | |
1209 | return 0; |
1210 | } |
1211 | |
1212 | void bcm_sf2_cfp_exit(struct dsa_switch *ds) |
1213 | { |
1214 | struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds); |
1215 | struct cfp_rule *rule, *n; |
1216 | |
1217 | if (list_empty(head: &priv->cfp.rules_list)) |
1218 | return; |
1219 | |
1220 | list_for_each_entry_safe_reverse(rule, n, &priv->cfp.rules_list, next) |
1221 | bcm_sf2_cfp_rule_del(priv, port: rule->port, loc: rule->fs.location); |
1222 | } |
1223 | |
1224 | int bcm_sf2_cfp_resume(struct dsa_switch *ds) |
1225 | { |
1226 | struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds); |
1227 | struct cfp_rule *rule; |
1228 | int ret = 0; |
1229 | u32 reg; |
1230 | |
1231 | if (list_empty(head: &priv->cfp.rules_list)) |
1232 | return ret; |
1233 | |
1234 | reg = core_readl(priv, CORE_CFP_CTL_REG); |
1235 | reg &= ~CFP_EN_MAP_MASK; |
1236 | core_writel(priv, val: reg, CORE_CFP_CTL_REG); |
1237 | |
1238 | ret = bcm_sf2_cfp_rst(priv); |
1239 | if (ret) |
1240 | return ret; |
1241 | |
1242 | list_for_each_entry(rule, &priv->cfp.rules_list, next) { |
1243 | ret = bcm_sf2_cfp_rule_remove(priv, port: rule->port, |
1244 | loc: rule->fs.location); |
1245 | if (ret) { |
1246 | dev_err(ds->dev, "failed to remove rule\n" ); |
1247 | return ret; |
1248 | } |
1249 | |
1250 | ret = bcm_sf2_cfp_rule_insert(ds, port: rule->port, fs: &rule->fs); |
1251 | if (ret) { |
1252 | dev_err(ds->dev, "failed to restore rule\n" ); |
1253 | return ret; |
1254 | } |
1255 | } |
1256 | |
1257 | return ret; |
1258 | } |
1259 | |
1260 | static const struct bcm_sf2_cfp_stat { |
1261 | unsigned int offset; |
1262 | unsigned int ram_loc; |
1263 | const char *name; |
1264 | } bcm_sf2_cfp_stats[] = { |
1265 | { |
1266 | .offset = CORE_STAT_GREEN_CNTR, |
1267 | .ram_loc = GREEN_STAT_RAM, |
1268 | .name = "Green" |
1269 | }, |
1270 | { |
1271 | .offset = CORE_STAT_YELLOW_CNTR, |
1272 | .ram_loc = YELLOW_STAT_RAM, |
1273 | .name = "Yellow" |
1274 | }, |
1275 | { |
1276 | .offset = CORE_STAT_RED_CNTR, |
1277 | .ram_loc = RED_STAT_RAM, |
1278 | .name = "Red" |
1279 | }, |
1280 | }; |
1281 | |
1282 | void bcm_sf2_cfp_get_strings(struct dsa_switch *ds, int port, |
1283 | u32 stringset, uint8_t *data) |
1284 | { |
1285 | struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds); |
1286 | unsigned int s = ARRAY_SIZE(bcm_sf2_cfp_stats); |
1287 | char buf[ETH_GSTRING_LEN]; |
1288 | unsigned int i, j, iter; |
1289 | |
1290 | if (stringset != ETH_SS_STATS) |
1291 | return; |
1292 | |
1293 | for (i = 1; i < priv->num_cfp_rules; i++) { |
1294 | for (j = 0; j < s; j++) { |
1295 | snprintf(buf, size: sizeof(buf), |
1296 | fmt: "CFP%03d_%sCntr" , |
1297 | i, bcm_sf2_cfp_stats[j].name); |
1298 | iter = (i - 1) * s + j; |
1299 | strscpy(p: data + iter * ETH_GSTRING_LEN, |
1300 | q: buf, ETH_GSTRING_LEN); |
1301 | } |
1302 | } |
1303 | } |
1304 | |
1305 | void bcm_sf2_cfp_get_ethtool_stats(struct dsa_switch *ds, int port, |
1306 | uint64_t *data) |
1307 | { |
1308 | struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds); |
1309 | unsigned int s = ARRAY_SIZE(bcm_sf2_cfp_stats); |
1310 | const struct bcm_sf2_cfp_stat *stat; |
1311 | unsigned int i, j, iter; |
1312 | struct cfp_rule *rule; |
1313 | int ret; |
1314 | |
1315 | mutex_lock(&priv->cfp.lock); |
1316 | for (i = 1; i < priv->num_cfp_rules; i++) { |
1317 | rule = bcm_sf2_cfp_rule_find(priv, port, location: i); |
1318 | if (!rule) |
1319 | continue; |
1320 | |
1321 | for (j = 0; j < s; j++) { |
1322 | stat = &bcm_sf2_cfp_stats[j]; |
1323 | |
1324 | bcm_sf2_cfp_rule_addr_set(priv, addr: i); |
1325 | ret = bcm_sf2_cfp_op(priv, op: stat->ram_loc | OP_SEL_READ); |
1326 | if (ret) |
1327 | continue; |
1328 | |
1329 | iter = (i - 1) * s + j; |
1330 | data[iter] = core_readl(priv, off: stat->offset); |
1331 | } |
1332 | |
1333 | } |
1334 | mutex_unlock(lock: &priv->cfp.lock); |
1335 | } |
1336 | |
1337 | int bcm_sf2_cfp_get_sset_count(struct dsa_switch *ds, int port, int sset) |
1338 | { |
1339 | struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds); |
1340 | |
1341 | if (sset != ETH_SS_STATS) |
1342 | return 0; |
1343 | |
1344 | /* 3 counters per CFP rules */ |
1345 | return (priv->num_cfp_rules - 1) * ARRAY_SIZE(bcm_sf2_cfp_stats); |
1346 | } |
1347 | |