1
2
3
4
5
6
7
8#include <net/ipv6.h>
9#include <linux/sort.h>
10
11#include "otx2_common.h"
12
13#define OTX2_DEFAULT_ACTION 0x1
14
15static int otx2_mcam_entry_init(struct otx2_nic *pfvf);
16
17struct otx2_flow {
18 struct ethtool_rx_flow_spec flow_spec;
19 struct list_head list;
20 u32 location;
21 u16 entry;
22 bool is_vf;
23 u8 rss_ctx_id;
24 int vf;
25 bool dmac_filter;
26};
27
28enum dmac_req {
29 DMAC_ADDR_UPDATE,
30 DMAC_ADDR_DEL
31};
32
33static void otx2_clear_ntuple_flow_info(struct otx2_nic *pfvf, struct otx2_flow_config *flow_cfg)
34{
35 devm_kfree(pfvf->dev, flow_cfg->flow_ent);
36 flow_cfg->flow_ent = NULL;
37 flow_cfg->max_flows = 0;
38}
39
40static int otx2_free_ntuple_mcam_entries(struct otx2_nic *pfvf)
41{
42 struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
43 struct npc_mcam_free_entry_req *req;
44 int ent, err;
45
46 if (!flow_cfg->max_flows)
47 return 0;
48
49 mutex_lock(&pfvf->mbox.lock);
50 for (ent = 0; ent < flow_cfg->max_flows; ent++) {
51 req = otx2_mbox_alloc_msg_npc_mcam_free_entry(&pfvf->mbox);
52 if (!req)
53 break;
54
55 req->entry = flow_cfg->flow_ent[ent];
56
57
58 err = otx2_sync_mbox_msg(&pfvf->mbox);
59 if (err)
60 break;
61 }
62 mutex_unlock(&pfvf->mbox.lock);
63 otx2_clear_ntuple_flow_info(pfvf, flow_cfg);
64 return 0;
65}
66
67static int mcam_entry_cmp(const void *a, const void *b)
68{
69 return *(u16 *)a - *(u16 *)b;
70}
71
72int otx2_alloc_mcam_entries(struct otx2_nic *pfvf, u16 count)
73{
74 struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
75 struct npc_mcam_alloc_entry_req *req;
76 struct npc_mcam_alloc_entry_rsp *rsp;
77 int ent, allocated = 0;
78
79
80 otx2_free_ntuple_mcam_entries(pfvf);
81
82 if (!count)
83 return 0;
84
85 flow_cfg->flow_ent = devm_kmalloc_array(pfvf->dev, count,
86 sizeof(u16), GFP_KERNEL);
87 if (!flow_cfg->flow_ent) {
88 netdev_err(pfvf->netdev,
89 "%s: Unable to allocate memory for flow entries\n",
90 __func__);
91 return -ENOMEM;
92 }
93
94 mutex_lock(&pfvf->mbox.lock);
95
96
97
98
99 while (allocated < count) {
100 req = otx2_mbox_alloc_msg_npc_mcam_alloc_entry(&pfvf->mbox);
101 if (!req)
102 goto exit;
103
104 req->contig = false;
105 req->count = (count - allocated) > NPC_MAX_NONCONTIG_ENTRIES ?
106 NPC_MAX_NONCONTIG_ENTRIES : count - allocated;
107
108
109
110
111 if (!is_otx2_vf(pfvf->pcifunc)) {
112 req->priority = NPC_MCAM_HIGHER_PRIO;
113 req->ref_entry = flow_cfg->def_ent[0];
114 }
115
116
117 if (otx2_sync_mbox_msg(&pfvf->mbox))
118 goto exit;
119
120 rsp = (struct npc_mcam_alloc_entry_rsp *)otx2_mbox_get_rsp
121 (&pfvf->mbox.mbox, 0, &req->hdr);
122
123 for (ent = 0; ent < rsp->count; ent++)
124 flow_cfg->flow_ent[ent + allocated] = rsp->entry_list[ent];
125
126 allocated += rsp->count;
127
128
129
130
131 if (rsp->count != req->count)
132 break;
133 }
134
135
136
137
138
139
140 if (allocated)
141 sort(&flow_cfg->flow_ent[0], allocated,
142 sizeof(flow_cfg->flow_ent[0]), mcam_entry_cmp, NULL);
143
144exit:
145 mutex_unlock(&pfvf->mbox.lock);
146
147 flow_cfg->max_flows = allocated;
148
149 if (allocated) {
150 pfvf->flags |= OTX2_FLAG_MCAM_ENTRIES_ALLOC;
151 pfvf->flags |= OTX2_FLAG_NTUPLE_SUPPORT;
152 }
153
154 if (allocated != count)
155 netdev_info(pfvf->netdev,
156 "Unable to allocate %d MCAM entries, got only %d\n",
157 count, allocated);
158 return allocated;
159}
160EXPORT_SYMBOL(otx2_alloc_mcam_entries);
161
162static int otx2_mcam_entry_init(struct otx2_nic *pfvf)
163{
164 struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
165 struct npc_mcam_alloc_entry_req *req;
166 struct npc_mcam_alloc_entry_rsp *rsp;
167 int vf_vlan_max_flows;
168 int ent, count;
169
170 vf_vlan_max_flows = pfvf->total_vfs * OTX2_PER_VF_VLAN_FLOWS;
171 count = OTX2_MAX_UNICAST_FLOWS +
172 OTX2_MAX_VLAN_FLOWS + vf_vlan_max_flows;
173
174 flow_cfg->def_ent = devm_kmalloc_array(pfvf->dev, count,
175 sizeof(u16), GFP_KERNEL);
176 if (!flow_cfg->def_ent)
177 return -ENOMEM;
178
179 mutex_lock(&pfvf->mbox.lock);
180
181 req = otx2_mbox_alloc_msg_npc_mcam_alloc_entry(&pfvf->mbox);
182 if (!req) {
183 mutex_unlock(&pfvf->mbox.lock);
184 return -ENOMEM;
185 }
186
187 req->contig = false;
188 req->count = count;
189
190
191 if (otx2_sync_mbox_msg(&pfvf->mbox)) {
192 mutex_unlock(&pfvf->mbox.lock);
193 return -EINVAL;
194 }
195
196 rsp = (struct npc_mcam_alloc_entry_rsp *)otx2_mbox_get_rsp
197 (&pfvf->mbox.mbox, 0, &req->hdr);
198
199 if (rsp->count != req->count) {
200 netdev_info(pfvf->netdev,
201 "Unable to allocate MCAM entries for ucast, vlan and vf_vlan\n");
202 mutex_unlock(&pfvf->mbox.lock);
203 devm_kfree(pfvf->dev, flow_cfg->def_ent);
204 return 0;
205 }
206
207 for (ent = 0; ent < rsp->count; ent++)
208 flow_cfg->def_ent[ent] = rsp->entry_list[ent];
209
210 flow_cfg->vf_vlan_offset = 0;
211 flow_cfg->unicast_offset = vf_vlan_max_flows;
212 flow_cfg->rx_vlan_offset = flow_cfg->unicast_offset +
213 OTX2_MAX_UNICAST_FLOWS;
214 pfvf->flags |= OTX2_FLAG_UCAST_FLTR_SUPPORT;
215 pfvf->flags |= OTX2_FLAG_RX_VLAN_SUPPORT;
216 pfvf->flags |= OTX2_FLAG_VF_VLAN_SUPPORT;
217
218 pfvf->flags |= OTX2_FLAG_MCAM_ENTRIES_ALLOC;
219 mutex_unlock(&pfvf->mbox.lock);
220
221
222 count = otx2_alloc_mcam_entries(pfvf, OTX2_DEFAULT_FLOWCOUNT);
223 if (count <= 0) {
224 otx2_clear_ntuple_flow_info(pfvf, flow_cfg);
225 return 0;
226 }
227
228 pfvf->flags |= OTX2_FLAG_TC_FLOWER_SUPPORT;
229
230 return 0;
231}
232
233int otx2vf_mcam_flow_init(struct otx2_nic *pfvf)
234{
235 struct otx2_flow_config *flow_cfg;
236
237 pfvf->flow_cfg = devm_kzalloc(pfvf->dev,
238 sizeof(struct otx2_flow_config),
239 GFP_KERNEL);
240 if (!pfvf->flow_cfg)
241 return -ENOMEM;
242
243 flow_cfg = pfvf->flow_cfg;
244 INIT_LIST_HEAD(&flow_cfg->flow_list);
245 flow_cfg->max_flows = 0;
246
247 return 0;
248}
249EXPORT_SYMBOL(otx2vf_mcam_flow_init);
250
251int otx2_mcam_flow_init(struct otx2_nic *pf)
252{
253 int err;
254
255 pf->flow_cfg = devm_kzalloc(pf->dev, sizeof(struct otx2_flow_config),
256 GFP_KERNEL);
257 if (!pf->flow_cfg)
258 return -ENOMEM;
259
260 INIT_LIST_HEAD(&pf->flow_cfg->flow_list);
261
262
263
264
265 err = otx2_mcam_entry_init(pf);
266 if (err)
267 return err;
268
269
270 if (!(pf->flags & OTX2_FLAG_UCAST_FLTR_SUPPORT))
271 return 0;
272
273 pf->mac_table = devm_kzalloc(pf->dev, sizeof(struct otx2_mac_table)
274 * OTX2_MAX_UNICAST_FLOWS, GFP_KERNEL);
275 if (!pf->mac_table)
276 return -ENOMEM;
277
278 otx2_dmacflt_get_max_cnt(pf);
279
280
281 if (!pf->flow_cfg->dmacflt_max_flows)
282 return 0;
283
284 pf->flow_cfg->bmap_to_dmacindex =
285 devm_kzalloc(pf->dev, sizeof(u8) *
286 pf->flow_cfg->dmacflt_max_flows,
287 GFP_KERNEL);
288
289 if (!pf->flow_cfg->bmap_to_dmacindex)
290 return -ENOMEM;
291
292 pf->flags |= OTX2_FLAG_DMACFLTR_SUPPORT;
293
294 return 0;
295}
296
297void otx2_mcam_flow_del(struct otx2_nic *pf)
298{
299 otx2_destroy_mcam_flows(pf);
300}
301EXPORT_SYMBOL(otx2_mcam_flow_del);
302
303
304
305
306static int otx2_do_add_macfilter(struct otx2_nic *pf, const u8 *mac)
307{
308 struct otx2_flow_config *flow_cfg = pf->flow_cfg;
309 struct npc_install_flow_req *req;
310 int err, i;
311
312 if (!(pf->flags & OTX2_FLAG_UCAST_FLTR_SUPPORT))
313 return -ENOMEM;
314
315
316 if (netdev_uc_count(pf->netdev) > OTX2_MAX_UNICAST_FLOWS)
317 return -ENOMEM;
318
319 mutex_lock(&pf->mbox.lock);
320 req = otx2_mbox_alloc_msg_npc_install_flow(&pf->mbox);
321 if (!req) {
322 mutex_unlock(&pf->mbox.lock);
323 return -ENOMEM;
324 }
325
326
327 for (i = 0; i < OTX2_MAX_UNICAST_FLOWS; i++) {
328 if (pf->mac_table[i].inuse)
329 continue;
330 ether_addr_copy(pf->mac_table[i].addr, mac);
331 pf->mac_table[i].inuse = true;
332 pf->mac_table[i].mcam_entry =
333 flow_cfg->def_ent[i + flow_cfg->unicast_offset];
334 req->entry = pf->mac_table[i].mcam_entry;
335 break;
336 }
337
338 ether_addr_copy(req->packet.dmac, mac);
339 eth_broadcast_addr((u8 *)&req->mask.dmac);
340 req->features = BIT_ULL(NPC_DMAC);
341 req->channel = pf->hw.rx_chan_base;
342 req->intf = NIX_INTF_RX;
343 req->op = NIX_RX_ACTION_DEFAULT;
344 req->set_cntr = 1;
345
346 err = otx2_sync_mbox_msg(&pf->mbox);
347 mutex_unlock(&pf->mbox.lock);
348
349 return err;
350}
351
352int otx2_add_macfilter(struct net_device *netdev, const u8 *mac)
353{
354 struct otx2_nic *pf = netdev_priv(netdev);
355
356 if (bitmap_weight(&pf->flow_cfg->dmacflt_bmap,
357 pf->flow_cfg->dmacflt_max_flows))
358 netdev_warn(netdev,
359 "Add %pM to CGX/RPM DMAC filters list as well\n",
360 mac);
361
362 return otx2_do_add_macfilter(pf, mac);
363}
364
365static bool otx2_get_mcamentry_for_mac(struct otx2_nic *pf, const u8 *mac,
366 int *mcam_entry)
367{
368 int i;
369
370 for (i = 0; i < OTX2_MAX_UNICAST_FLOWS; i++) {
371 if (!pf->mac_table[i].inuse)
372 continue;
373
374 if (ether_addr_equal(pf->mac_table[i].addr, mac)) {
375 *mcam_entry = pf->mac_table[i].mcam_entry;
376 pf->mac_table[i].inuse = false;
377 return true;
378 }
379 }
380 return false;
381}
382
383int otx2_del_macfilter(struct net_device *netdev, const u8 *mac)
384{
385 struct otx2_nic *pf = netdev_priv(netdev);
386 struct npc_delete_flow_req *req;
387 int err, mcam_entry;
388
389
390 if (!otx2_get_mcamentry_for_mac(pf, mac, &mcam_entry))
391 return 0;
392
393 mutex_lock(&pf->mbox.lock);
394 req = otx2_mbox_alloc_msg_npc_delete_flow(&pf->mbox);
395 if (!req) {
396 mutex_unlock(&pf->mbox.lock);
397 return -ENOMEM;
398 }
399 req->entry = mcam_entry;
400
401 err = otx2_sync_mbox_msg(&pf->mbox);
402 mutex_unlock(&pf->mbox.lock);
403
404 return err;
405}
406
407static struct otx2_flow *otx2_find_flow(struct otx2_nic *pfvf, u32 location)
408{
409 struct otx2_flow *iter;
410
411 list_for_each_entry(iter, &pfvf->flow_cfg->flow_list, list) {
412 if (iter->location == location)
413 return iter;
414 }
415
416 return NULL;
417}
418
419static void otx2_add_flow_to_list(struct otx2_nic *pfvf, struct otx2_flow *flow)
420{
421 struct list_head *head = &pfvf->flow_cfg->flow_list;
422 struct otx2_flow *iter;
423
424 list_for_each_entry(iter, &pfvf->flow_cfg->flow_list, list) {
425 if (iter->location > flow->location)
426 break;
427 head = &iter->list;
428 }
429
430 list_add(&flow->list, head);
431}
432
433int otx2_get_maxflows(struct otx2_flow_config *flow_cfg)
434{
435 if (!flow_cfg)
436 return 0;
437
438 if (flow_cfg->nr_flows == flow_cfg->max_flows ||
439 bitmap_weight(&flow_cfg->dmacflt_bmap,
440 flow_cfg->dmacflt_max_flows))
441 return flow_cfg->max_flows + flow_cfg->dmacflt_max_flows;
442 else
443 return flow_cfg->max_flows;
444}
445EXPORT_SYMBOL(otx2_get_maxflows);
446
447int otx2_get_flow(struct otx2_nic *pfvf, struct ethtool_rxnfc *nfc,
448 u32 location)
449{
450 struct otx2_flow *iter;
451
452 if (location >= otx2_get_maxflows(pfvf->flow_cfg))
453 return -EINVAL;
454
455 list_for_each_entry(iter, &pfvf->flow_cfg->flow_list, list) {
456 if (iter->location == location) {
457 nfc->fs = iter->flow_spec;
458 nfc->rss_context = iter->rss_ctx_id;
459 return 0;
460 }
461 }
462
463 return -ENOENT;
464}
465
466int otx2_get_all_flows(struct otx2_nic *pfvf, struct ethtool_rxnfc *nfc,
467 u32 *rule_locs)
468{
469 u32 rule_cnt = nfc->rule_cnt;
470 u32 location = 0;
471 int idx = 0;
472 int err = 0;
473
474 nfc->data = otx2_get_maxflows(pfvf->flow_cfg);
475 while ((!err || err == -ENOENT) && idx < rule_cnt) {
476 err = otx2_get_flow(pfvf, nfc, location);
477 if (!err)
478 rule_locs[idx++] = location;
479 location++;
480 }
481 nfc->rule_cnt = rule_cnt;
482
483 return err;
484}
485
486static int otx2_prepare_ipv4_flow(struct ethtool_rx_flow_spec *fsp,
487 struct npc_install_flow_req *req,
488 u32 flow_type)
489{
490 struct ethtool_usrip4_spec *ipv4_usr_mask = &fsp->m_u.usr_ip4_spec;
491 struct ethtool_usrip4_spec *ipv4_usr_hdr = &fsp->h_u.usr_ip4_spec;
492 struct ethtool_tcpip4_spec *ipv4_l4_mask = &fsp->m_u.tcp_ip4_spec;
493 struct ethtool_tcpip4_spec *ipv4_l4_hdr = &fsp->h_u.tcp_ip4_spec;
494 struct ethtool_ah_espip4_spec *ah_esp_hdr = &fsp->h_u.ah_ip4_spec;
495 struct ethtool_ah_espip4_spec *ah_esp_mask = &fsp->m_u.ah_ip4_spec;
496 struct flow_msg *pmask = &req->mask;
497 struct flow_msg *pkt = &req->packet;
498
499 switch (flow_type) {
500 case IP_USER_FLOW:
501 if (ipv4_usr_mask->ip4src) {
502 memcpy(&pkt->ip4src, &ipv4_usr_hdr->ip4src,
503 sizeof(pkt->ip4src));
504 memcpy(&pmask->ip4src, &ipv4_usr_mask->ip4src,
505 sizeof(pmask->ip4src));
506 req->features |= BIT_ULL(NPC_SIP_IPV4);
507 }
508 if (ipv4_usr_mask->ip4dst) {
509 memcpy(&pkt->ip4dst, &ipv4_usr_hdr->ip4dst,
510 sizeof(pkt->ip4dst));
511 memcpy(&pmask->ip4dst, &ipv4_usr_mask->ip4dst,
512 sizeof(pmask->ip4dst));
513 req->features |= BIT_ULL(NPC_DIP_IPV4);
514 }
515 if (ipv4_usr_mask->tos) {
516 pkt->tos = ipv4_usr_hdr->tos;
517 pmask->tos = ipv4_usr_mask->tos;
518 req->features |= BIT_ULL(NPC_TOS);
519 }
520 if (ipv4_usr_mask->proto) {
521 switch (ipv4_usr_hdr->proto) {
522 case IPPROTO_ICMP:
523 req->features |= BIT_ULL(NPC_IPPROTO_ICMP);
524 break;
525 case IPPROTO_TCP:
526 req->features |= BIT_ULL(NPC_IPPROTO_TCP);
527 break;
528 case IPPROTO_UDP:
529 req->features |= BIT_ULL(NPC_IPPROTO_UDP);
530 break;
531 case IPPROTO_SCTP:
532 req->features |= BIT_ULL(NPC_IPPROTO_SCTP);
533 break;
534 case IPPROTO_AH:
535 req->features |= BIT_ULL(NPC_IPPROTO_AH);
536 break;
537 case IPPROTO_ESP:
538 req->features |= BIT_ULL(NPC_IPPROTO_ESP);
539 break;
540 default:
541 return -EOPNOTSUPP;
542 }
543 }
544 pkt->etype = cpu_to_be16(ETH_P_IP);
545 pmask->etype = cpu_to_be16(0xFFFF);
546 req->features |= BIT_ULL(NPC_ETYPE);
547 break;
548 case TCP_V4_FLOW:
549 case UDP_V4_FLOW:
550 case SCTP_V4_FLOW:
551 pkt->etype = cpu_to_be16(ETH_P_IP);
552 pmask->etype = cpu_to_be16(0xFFFF);
553 req->features |= BIT_ULL(NPC_ETYPE);
554 if (ipv4_l4_mask->ip4src) {
555 memcpy(&pkt->ip4src, &ipv4_l4_hdr->ip4src,
556 sizeof(pkt->ip4src));
557 memcpy(&pmask->ip4src, &ipv4_l4_mask->ip4src,
558 sizeof(pmask->ip4src));
559 req->features |= BIT_ULL(NPC_SIP_IPV4);
560 }
561 if (ipv4_l4_mask->ip4dst) {
562 memcpy(&pkt->ip4dst, &ipv4_l4_hdr->ip4dst,
563 sizeof(pkt->ip4dst));
564 memcpy(&pmask->ip4dst, &ipv4_l4_mask->ip4dst,
565 sizeof(pmask->ip4dst));
566 req->features |= BIT_ULL(NPC_DIP_IPV4);
567 }
568 if (ipv4_l4_mask->tos) {
569 pkt->tos = ipv4_l4_hdr->tos;
570 pmask->tos = ipv4_l4_mask->tos;
571 req->features |= BIT_ULL(NPC_TOS);
572 }
573 if (ipv4_l4_mask->psrc) {
574 memcpy(&pkt->sport, &ipv4_l4_hdr->psrc,
575 sizeof(pkt->sport));
576 memcpy(&pmask->sport, &ipv4_l4_mask->psrc,
577 sizeof(pmask->sport));
578 if (flow_type == UDP_V4_FLOW)
579 req->features |= BIT_ULL(NPC_SPORT_UDP);
580 else if (flow_type == TCP_V4_FLOW)
581 req->features |= BIT_ULL(NPC_SPORT_TCP);
582 else
583 req->features |= BIT_ULL(NPC_SPORT_SCTP);
584 }
585 if (ipv4_l4_mask->pdst) {
586 memcpy(&pkt->dport, &ipv4_l4_hdr->pdst,
587 sizeof(pkt->dport));
588 memcpy(&pmask->dport, &ipv4_l4_mask->pdst,
589 sizeof(pmask->dport));
590 if (flow_type == UDP_V4_FLOW)
591 req->features |= BIT_ULL(NPC_DPORT_UDP);
592 else if (flow_type == TCP_V4_FLOW)
593 req->features |= BIT_ULL(NPC_DPORT_TCP);
594 else
595 req->features |= BIT_ULL(NPC_DPORT_SCTP);
596 }
597 if (flow_type == UDP_V4_FLOW)
598 req->features |= BIT_ULL(NPC_IPPROTO_UDP);
599 else if (flow_type == TCP_V4_FLOW)
600 req->features |= BIT_ULL(NPC_IPPROTO_TCP);
601 else
602 req->features |= BIT_ULL(NPC_IPPROTO_SCTP);
603 break;
604 case AH_V4_FLOW:
605 case ESP_V4_FLOW:
606 pkt->etype = cpu_to_be16(ETH_P_IP);
607 pmask->etype = cpu_to_be16(0xFFFF);
608 req->features |= BIT_ULL(NPC_ETYPE);
609 if (ah_esp_mask->ip4src) {
610 memcpy(&pkt->ip4src, &ah_esp_hdr->ip4src,
611 sizeof(pkt->ip4src));
612 memcpy(&pmask->ip4src, &ah_esp_mask->ip4src,
613 sizeof(pmask->ip4src));
614 req->features |= BIT_ULL(NPC_SIP_IPV4);
615 }
616 if (ah_esp_mask->ip4dst) {
617 memcpy(&pkt->ip4dst, &ah_esp_hdr->ip4dst,
618 sizeof(pkt->ip4dst));
619 memcpy(&pmask->ip4dst, &ah_esp_mask->ip4dst,
620 sizeof(pmask->ip4dst));
621 req->features |= BIT_ULL(NPC_DIP_IPV4);
622 }
623 if (ah_esp_mask->tos) {
624 pkt->tos = ah_esp_hdr->tos;
625 pmask->tos = ah_esp_mask->tos;
626 req->features |= BIT_ULL(NPC_TOS);
627 }
628
629
630 if (ah_esp_mask->spi & ah_esp_hdr->spi)
631 return -EOPNOTSUPP;
632
633 if (flow_type == AH_V4_FLOW)
634 req->features |= BIT_ULL(NPC_IPPROTO_AH);
635 else
636 req->features |= BIT_ULL(NPC_IPPROTO_ESP);
637 break;
638 default:
639 break;
640 }
641
642 return 0;
643}
644
645static int otx2_prepare_ipv6_flow(struct ethtool_rx_flow_spec *fsp,
646 struct npc_install_flow_req *req,
647 u32 flow_type)
648{
649 struct ethtool_usrip6_spec *ipv6_usr_mask = &fsp->m_u.usr_ip6_spec;
650 struct ethtool_usrip6_spec *ipv6_usr_hdr = &fsp->h_u.usr_ip6_spec;
651 struct ethtool_tcpip6_spec *ipv6_l4_mask = &fsp->m_u.tcp_ip6_spec;
652 struct ethtool_tcpip6_spec *ipv6_l4_hdr = &fsp->h_u.tcp_ip6_spec;
653 struct ethtool_ah_espip6_spec *ah_esp_hdr = &fsp->h_u.ah_ip6_spec;
654 struct ethtool_ah_espip6_spec *ah_esp_mask = &fsp->m_u.ah_ip6_spec;
655 struct flow_msg *pmask = &req->mask;
656 struct flow_msg *pkt = &req->packet;
657
658 switch (flow_type) {
659 case IPV6_USER_FLOW:
660 if (!ipv6_addr_any((struct in6_addr *)ipv6_usr_mask->ip6src)) {
661 memcpy(&pkt->ip6src, &ipv6_usr_hdr->ip6src,
662 sizeof(pkt->ip6src));
663 memcpy(&pmask->ip6src, &ipv6_usr_mask->ip6src,
664 sizeof(pmask->ip6src));
665 req->features |= BIT_ULL(NPC_SIP_IPV6);
666 }
667 if (!ipv6_addr_any((struct in6_addr *)ipv6_usr_mask->ip6dst)) {
668 memcpy(&pkt->ip6dst, &ipv6_usr_hdr->ip6dst,
669 sizeof(pkt->ip6dst));
670 memcpy(&pmask->ip6dst, &ipv6_usr_mask->ip6dst,
671 sizeof(pmask->ip6dst));
672 req->features |= BIT_ULL(NPC_DIP_IPV6);
673 }
674 pkt->etype = cpu_to_be16(ETH_P_IPV6);
675 pmask->etype = cpu_to_be16(0xFFFF);
676 req->features |= BIT_ULL(NPC_ETYPE);
677 break;
678 case TCP_V6_FLOW:
679 case UDP_V6_FLOW:
680 case SCTP_V6_FLOW:
681 pkt->etype = cpu_to_be16(ETH_P_IPV6);
682 pmask->etype = cpu_to_be16(0xFFFF);
683 req->features |= BIT_ULL(NPC_ETYPE);
684 if (!ipv6_addr_any((struct in6_addr *)ipv6_l4_mask->ip6src)) {
685 memcpy(&pkt->ip6src, &ipv6_l4_hdr->ip6src,
686 sizeof(pkt->ip6src));
687 memcpy(&pmask->ip6src, &ipv6_l4_mask->ip6src,
688 sizeof(pmask->ip6src));
689 req->features |= BIT_ULL(NPC_SIP_IPV6);
690 }
691 if (!ipv6_addr_any((struct in6_addr *)ipv6_l4_mask->ip6dst)) {
692 memcpy(&pkt->ip6dst, &ipv6_l4_hdr->ip6dst,
693 sizeof(pkt->ip6dst));
694 memcpy(&pmask->ip6dst, &ipv6_l4_mask->ip6dst,
695 sizeof(pmask->ip6dst));
696 req->features |= BIT_ULL(NPC_DIP_IPV6);
697 }
698 if (ipv6_l4_mask->psrc) {
699 memcpy(&pkt->sport, &ipv6_l4_hdr->psrc,
700 sizeof(pkt->sport));
701 memcpy(&pmask->sport, &ipv6_l4_mask->psrc,
702 sizeof(pmask->sport));
703 if (flow_type == UDP_V6_FLOW)
704 req->features |= BIT_ULL(NPC_SPORT_UDP);
705 else if (flow_type == TCP_V6_FLOW)
706 req->features |= BIT_ULL(NPC_SPORT_TCP);
707 else
708 req->features |= BIT_ULL(NPC_SPORT_SCTP);
709 }
710 if (ipv6_l4_mask->pdst) {
711 memcpy(&pkt->dport, &ipv6_l4_hdr->pdst,
712 sizeof(pkt->dport));
713 memcpy(&pmask->dport, &ipv6_l4_mask->pdst,
714 sizeof(pmask->dport));
715 if (flow_type == UDP_V6_FLOW)
716 req->features |= BIT_ULL(NPC_DPORT_UDP);
717 else if (flow_type == TCP_V6_FLOW)
718 req->features |= BIT_ULL(NPC_DPORT_TCP);
719 else
720 req->features |= BIT_ULL(NPC_DPORT_SCTP);
721 }
722 if (flow_type == UDP_V6_FLOW)
723 req->features |= BIT_ULL(NPC_IPPROTO_UDP);
724 else if (flow_type == TCP_V6_FLOW)
725 req->features |= BIT_ULL(NPC_IPPROTO_TCP);
726 else
727 req->features |= BIT_ULL(NPC_IPPROTO_SCTP);
728 break;
729 case AH_V6_FLOW:
730 case ESP_V6_FLOW:
731 pkt->etype = cpu_to_be16(ETH_P_IPV6);
732 pmask->etype = cpu_to_be16(0xFFFF);
733 req->features |= BIT_ULL(NPC_ETYPE);
734 if (!ipv6_addr_any((struct in6_addr *)ah_esp_hdr->ip6src)) {
735 memcpy(&pkt->ip6src, &ah_esp_hdr->ip6src,
736 sizeof(pkt->ip6src));
737 memcpy(&pmask->ip6src, &ah_esp_mask->ip6src,
738 sizeof(pmask->ip6src));
739 req->features |= BIT_ULL(NPC_SIP_IPV6);
740 }
741 if (!ipv6_addr_any((struct in6_addr *)ah_esp_hdr->ip6dst)) {
742 memcpy(&pkt->ip6dst, &ah_esp_hdr->ip6dst,
743 sizeof(pkt->ip6dst));
744 memcpy(&pmask->ip6dst, &ah_esp_mask->ip6dst,
745 sizeof(pmask->ip6dst));
746 req->features |= BIT_ULL(NPC_DIP_IPV6);
747 }
748
749
750 if ((ah_esp_mask->spi & ah_esp_hdr->spi) ||
751 (ah_esp_mask->tclass & ah_esp_mask->tclass))
752 return -EOPNOTSUPP;
753
754 if (flow_type == AH_V6_FLOW)
755 req->features |= BIT_ULL(NPC_IPPROTO_AH);
756 else
757 req->features |= BIT_ULL(NPC_IPPROTO_ESP);
758 break;
759 default:
760 break;
761 }
762
763 return 0;
764}
765
766static int otx2_prepare_flow_request(struct ethtool_rx_flow_spec *fsp,
767 struct npc_install_flow_req *req)
768{
769 struct ethhdr *eth_mask = &fsp->m_u.ether_spec;
770 struct ethhdr *eth_hdr = &fsp->h_u.ether_spec;
771 struct flow_msg *pmask = &req->mask;
772 struct flow_msg *pkt = &req->packet;
773 u32 flow_type;
774 int ret;
775
776 flow_type = fsp->flow_type & ~(FLOW_EXT | FLOW_MAC_EXT | FLOW_RSS);
777 switch (flow_type) {
778
779 case ETHER_FLOW:
780 if (!is_zero_ether_addr(eth_mask->h_source)) {
781 ether_addr_copy(pkt->smac, eth_hdr->h_source);
782 ether_addr_copy(pmask->smac, eth_mask->h_source);
783 req->features |= BIT_ULL(NPC_SMAC);
784 }
785 if (!is_zero_ether_addr(eth_mask->h_dest)) {
786 ether_addr_copy(pkt->dmac, eth_hdr->h_dest);
787 ether_addr_copy(pmask->dmac, eth_mask->h_dest);
788 req->features |= BIT_ULL(NPC_DMAC);
789 }
790 if (eth_hdr->h_proto) {
791 memcpy(&pkt->etype, ð_hdr->h_proto,
792 sizeof(pkt->etype));
793 memcpy(&pmask->etype, ð_mask->h_proto,
794 sizeof(pmask->etype));
795 req->features |= BIT_ULL(NPC_ETYPE);
796 }
797 break;
798 case IP_USER_FLOW:
799 case TCP_V4_FLOW:
800 case UDP_V4_FLOW:
801 case SCTP_V4_FLOW:
802 case AH_V4_FLOW:
803 case ESP_V4_FLOW:
804 ret = otx2_prepare_ipv4_flow(fsp, req, flow_type);
805 if (ret)
806 return ret;
807 break;
808 case IPV6_USER_FLOW:
809 case TCP_V6_FLOW:
810 case UDP_V6_FLOW:
811 case SCTP_V6_FLOW:
812 case AH_V6_FLOW:
813 case ESP_V6_FLOW:
814 ret = otx2_prepare_ipv6_flow(fsp, req, flow_type);
815 if (ret)
816 return ret;
817 break;
818 default:
819 return -EOPNOTSUPP;
820 }
821 if (fsp->flow_type & FLOW_EXT) {
822 u16 vlan_etype;
823
824 if (fsp->m_ext.vlan_etype) {
825
826 if (be16_to_cpu(fsp->m_ext.vlan_etype) != 0xFFFF)
827 return -EINVAL;
828
829 vlan_etype = be16_to_cpu(fsp->h_ext.vlan_etype);
830
831 if (vlan_etype != ETH_P_8021Q &&
832 vlan_etype != ETH_P_8021AD)
833 return -EINVAL;
834
835 memcpy(&pkt->vlan_etype, &fsp->h_ext.vlan_etype,
836 sizeof(pkt->vlan_etype));
837 memcpy(&pmask->vlan_etype, &fsp->m_ext.vlan_etype,
838 sizeof(pmask->vlan_etype));
839
840 if (vlan_etype == ETH_P_8021Q)
841 req->features |= BIT_ULL(NPC_VLAN_ETYPE_CTAG);
842 else
843 req->features |= BIT_ULL(NPC_VLAN_ETYPE_STAG);
844 }
845
846 if (fsp->m_ext.vlan_tci) {
847 memcpy(&pkt->vlan_tci, &fsp->h_ext.vlan_tci,
848 sizeof(pkt->vlan_tci));
849 memcpy(&pmask->vlan_tci, &fsp->m_ext.vlan_tci,
850 sizeof(pmask->vlan_tci));
851 req->features |= BIT_ULL(NPC_OUTER_VID);
852 }
853
854
855 if (fsp->m_ext.data[1] &&
856 fsp->h_ext.data[1] == cpu_to_be32(OTX2_DEFAULT_ACTION))
857 req->op = NIX_RX_ACTION_DEFAULT;
858 }
859
860 if (fsp->flow_type & FLOW_MAC_EXT &&
861 !is_zero_ether_addr(fsp->m_ext.h_dest)) {
862 ether_addr_copy(pkt->dmac, fsp->h_ext.h_dest);
863 ether_addr_copy(pmask->dmac, fsp->m_ext.h_dest);
864 req->features |= BIT_ULL(NPC_DMAC);
865 }
866
867 if (!req->features)
868 return -EOPNOTSUPP;
869
870 return 0;
871}
872
873static int otx2_is_flow_rule_dmacfilter(struct otx2_nic *pfvf,
874 struct ethtool_rx_flow_spec *fsp)
875{
876 struct ethhdr *eth_mask = &fsp->m_u.ether_spec;
877 struct ethhdr *eth_hdr = &fsp->h_u.ether_spec;
878 u64 ring_cookie = fsp->ring_cookie;
879 u32 flow_type;
880
881 if (!(pfvf->flags & OTX2_FLAG_DMACFLTR_SUPPORT))
882 return false;
883
884 flow_type = fsp->flow_type & ~(FLOW_EXT | FLOW_MAC_EXT | FLOW_RSS);
885
886
887
888
889 if (flow_type == ETHER_FLOW && ring_cookie != RX_CLS_FLOW_DISC &&
890 !ethtool_get_flow_spec_ring_vf(ring_cookie)) {
891 if (is_zero_ether_addr(eth_mask->h_dest) &&
892 is_valid_ether_addr(eth_hdr->h_dest))
893 return true;
894 }
895
896 return false;
897}
898
899static int otx2_add_flow_msg(struct otx2_nic *pfvf, struct otx2_flow *flow)
900{
901 u64 ring_cookie = flow->flow_spec.ring_cookie;
902 struct npc_install_flow_req *req;
903 int err, vf = 0;
904
905 mutex_lock(&pfvf->mbox.lock);
906 req = otx2_mbox_alloc_msg_npc_install_flow(&pfvf->mbox);
907 if (!req) {
908 mutex_unlock(&pfvf->mbox.lock);
909 return -ENOMEM;
910 }
911
912 err = otx2_prepare_flow_request(&flow->flow_spec, req);
913 if (err) {
914
915 otx2_mbox_reset(&pfvf->mbox.mbox, 0);
916 mutex_unlock(&pfvf->mbox.lock);
917 return err;
918 }
919
920 req->entry = flow->entry;
921 req->intf = NIX_INTF_RX;
922 req->set_cntr = 1;
923 req->channel = pfvf->hw.rx_chan_base;
924 if (ring_cookie == RX_CLS_FLOW_DISC) {
925 req->op = NIX_RX_ACTIONOP_DROP;
926 } else {
927
928
929
930 if (flow->flow_spec.flow_type & FLOW_RSS) {
931 req->op = NIX_RX_ACTIONOP_RSS;
932 req->index = flow->rss_ctx_id;
933 req->flow_key_alg = pfvf->hw.flowkey_alg_idx;
934 } else {
935 req->op = NIX_RX_ACTIONOP_UCAST;
936 req->index = ethtool_get_flow_spec_ring(ring_cookie);
937 }
938 vf = ethtool_get_flow_spec_ring_vf(ring_cookie);
939 if (vf > pci_num_vf(pfvf->pdev)) {
940 mutex_unlock(&pfvf->mbox.lock);
941 return -EINVAL;
942 }
943 }
944
945
946 if (vf) {
947 req->vf = vf;
948 flow->is_vf = true;
949 flow->vf = vf;
950 }
951
952
953 err = otx2_sync_mbox_msg(&pfvf->mbox);
954 mutex_unlock(&pfvf->mbox.lock);
955 return err;
956}
957
958static int otx2_add_flow_with_pfmac(struct otx2_nic *pfvf,
959 struct otx2_flow *flow)
960{
961 struct otx2_flow *pf_mac;
962 struct ethhdr *eth_hdr;
963
964 pf_mac = kzalloc(sizeof(*pf_mac), GFP_KERNEL);
965 if (!pf_mac)
966 return -ENOMEM;
967
968 pf_mac->entry = 0;
969 pf_mac->dmac_filter = true;
970 pf_mac->location = pfvf->flow_cfg->max_flows;
971 memcpy(&pf_mac->flow_spec, &flow->flow_spec,
972 sizeof(struct ethtool_rx_flow_spec));
973 pf_mac->flow_spec.location = pf_mac->location;
974
975
976 eth_hdr = &pf_mac->flow_spec.h_u.ether_spec;
977 ether_addr_copy(eth_hdr->h_dest, pfvf->netdev->dev_addr);
978
979
980 otx2_dmacflt_add(pfvf, eth_hdr->h_dest, 0);
981
982 otx2_add_flow_to_list(pfvf, pf_mac);
983 pfvf->flow_cfg->nr_flows++;
984 set_bit(0, &pfvf->flow_cfg->dmacflt_bmap);
985
986 return 0;
987}
988
989int otx2_add_flow(struct otx2_nic *pfvf, struct ethtool_rxnfc *nfc)
990{
991 struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
992 struct ethtool_rx_flow_spec *fsp = &nfc->fs;
993 struct otx2_flow *flow;
994 struct ethhdr *eth_hdr;
995 bool new = false;
996 int err = 0;
997 u32 ring;
998
999 if (!flow_cfg->max_flows) {
1000 netdev_err(pfvf->netdev,
1001 "Ntuple rule count is 0, allocate and retry\n");
1002 return -EINVAL;
1003 }
1004
1005 ring = ethtool_get_flow_spec_ring(fsp->ring_cookie);
1006 if (!(pfvf->flags & OTX2_FLAG_NTUPLE_SUPPORT))
1007 return -ENOMEM;
1008
1009 if (ring >= pfvf->hw.rx_queues && fsp->ring_cookie != RX_CLS_FLOW_DISC)
1010 return -EINVAL;
1011
1012 if (fsp->location >= otx2_get_maxflows(flow_cfg))
1013 return -EINVAL;
1014
1015 flow = otx2_find_flow(pfvf, fsp->location);
1016 if (!flow) {
1017 flow = kzalloc(sizeof(*flow), GFP_KERNEL);
1018 if (!flow)
1019 return -ENOMEM;
1020 flow->location = fsp->location;
1021 flow->entry = flow_cfg->flow_ent[flow->location];
1022 new = true;
1023 }
1024
1025 flow->flow_spec = *fsp;
1026
1027 if (fsp->flow_type & FLOW_RSS)
1028 flow->rss_ctx_id = nfc->rss_context;
1029
1030 if (otx2_is_flow_rule_dmacfilter(pfvf, &flow->flow_spec)) {
1031 eth_hdr = &flow->flow_spec.h_u.ether_spec;
1032
1033
1034 if (flow->dmac_filter)
1035 return otx2_dmacflt_update(pfvf, eth_hdr->h_dest,
1036 flow->entry);
1037
1038 if (bitmap_full(&flow_cfg->dmacflt_bmap,
1039 flow_cfg->dmacflt_max_flows)) {
1040 netdev_warn(pfvf->netdev,
1041 "Can't insert the rule %d as max allowed dmac filters are %d\n",
1042 flow->location +
1043 flow_cfg->dmacflt_max_flows,
1044 flow_cfg->dmacflt_max_flows);
1045 err = -EINVAL;
1046 if (new)
1047 kfree(flow);
1048 return err;
1049 }
1050
1051
1052 if (!test_bit(0, &flow_cfg->dmacflt_bmap))
1053 otx2_add_flow_with_pfmac(pfvf, flow);
1054
1055 flow->dmac_filter = true;
1056 flow->entry = find_first_zero_bit(&flow_cfg->dmacflt_bmap,
1057 flow_cfg->dmacflt_max_flows);
1058 fsp->location = flow_cfg->max_flows + flow->entry;
1059 flow->flow_spec.location = fsp->location;
1060 flow->location = fsp->location;
1061
1062 set_bit(flow->entry, &flow_cfg->dmacflt_bmap);
1063 otx2_dmacflt_add(pfvf, eth_hdr->h_dest, flow->entry);
1064
1065 } else {
1066 if (flow->location >= pfvf->flow_cfg->max_flows) {
1067 netdev_warn(pfvf->netdev,
1068 "Can't insert non dmac ntuple rule at %d, allowed range %d-0\n",
1069 flow->location,
1070 flow_cfg->max_flows - 1);
1071 err = -EINVAL;
1072 } else {
1073 err = otx2_add_flow_msg(pfvf, flow);
1074 }
1075 }
1076
1077 if (err) {
1078 if (err == MBOX_MSG_INVALID)
1079 err = -EINVAL;
1080 if (new)
1081 kfree(flow);
1082 return err;
1083 }
1084
1085
1086 if (new) {
1087 otx2_add_flow_to_list(pfvf, flow);
1088 flow_cfg->nr_flows++;
1089 }
1090
1091 return 0;
1092}
1093
1094static int otx2_remove_flow_msg(struct otx2_nic *pfvf, u16 entry, bool all)
1095{
1096 struct npc_delete_flow_req *req;
1097 int err;
1098
1099 mutex_lock(&pfvf->mbox.lock);
1100 req = otx2_mbox_alloc_msg_npc_delete_flow(&pfvf->mbox);
1101 if (!req) {
1102 mutex_unlock(&pfvf->mbox.lock);
1103 return -ENOMEM;
1104 }
1105
1106 req->entry = entry;
1107 if (all)
1108 req->all = 1;
1109
1110
1111 err = otx2_sync_mbox_msg(&pfvf->mbox);
1112 mutex_unlock(&pfvf->mbox.lock);
1113 return err;
1114}
1115
1116static void otx2_update_rem_pfmac(struct otx2_nic *pfvf, int req)
1117{
1118 struct otx2_flow *iter;
1119 struct ethhdr *eth_hdr;
1120 bool found = false;
1121
1122 list_for_each_entry(iter, &pfvf->flow_cfg->flow_list, list) {
1123 if (iter->dmac_filter && iter->entry == 0) {
1124 eth_hdr = &iter->flow_spec.h_u.ether_spec;
1125 if (req == DMAC_ADDR_DEL) {
1126 otx2_dmacflt_remove(pfvf, eth_hdr->h_dest,
1127 0);
1128 clear_bit(0, &pfvf->flow_cfg->dmacflt_bmap);
1129 found = true;
1130 } else {
1131 ether_addr_copy(eth_hdr->h_dest,
1132 pfvf->netdev->dev_addr);
1133 otx2_dmacflt_update(pfvf, eth_hdr->h_dest, 0);
1134 }
1135 break;
1136 }
1137 }
1138
1139 if (found) {
1140 list_del(&iter->list);
1141 kfree(iter);
1142 pfvf->flow_cfg->nr_flows--;
1143 }
1144}
1145
1146int otx2_remove_flow(struct otx2_nic *pfvf, u32 location)
1147{
1148 struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
1149 struct otx2_flow *flow;
1150 int err;
1151
1152 if (location >= otx2_get_maxflows(flow_cfg))
1153 return -EINVAL;
1154
1155 flow = otx2_find_flow(pfvf, location);
1156 if (!flow)
1157 return -ENOENT;
1158
1159 if (flow->dmac_filter) {
1160 struct ethhdr *eth_hdr = &flow->flow_spec.h_u.ether_spec;
1161
1162
1163 if (ether_addr_equal(pfvf->netdev->dev_addr, eth_hdr->h_dest))
1164 return -EPERM;
1165
1166 err = otx2_dmacflt_remove(pfvf, eth_hdr->h_dest,
1167 flow->entry);
1168 clear_bit(flow->entry, &flow_cfg->dmacflt_bmap);
1169
1170
1171
1172
1173 if (bitmap_weight(&flow_cfg->dmacflt_bmap,
1174 flow_cfg->dmacflt_max_flows) == 1)
1175 otx2_update_rem_pfmac(pfvf, DMAC_ADDR_DEL);
1176 } else {
1177 err = otx2_remove_flow_msg(pfvf, flow->entry, false);
1178 }
1179
1180 if (err)
1181 return err;
1182
1183 list_del(&flow->list);
1184 kfree(flow);
1185 flow_cfg->nr_flows--;
1186
1187 return 0;
1188}
1189
1190void otx2_rss_ctx_flow_del(struct otx2_nic *pfvf, int ctx_id)
1191{
1192 struct otx2_flow *flow, *tmp;
1193 int err;
1194
1195 list_for_each_entry_safe(flow, tmp, &pfvf->flow_cfg->flow_list, list) {
1196 if (flow->rss_ctx_id != ctx_id)
1197 continue;
1198 err = otx2_remove_flow(pfvf, flow->location);
1199 if (err)
1200 netdev_warn(pfvf->netdev,
1201 "Can't delete the rule %d associated with this rss group err:%d",
1202 flow->location, err);
1203 }
1204}
1205
1206int otx2_destroy_ntuple_flows(struct otx2_nic *pfvf)
1207{
1208 struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
1209 struct npc_delete_flow_req *req;
1210 struct otx2_flow *iter, *tmp;
1211 int err;
1212
1213 if (!(pfvf->flags & OTX2_FLAG_NTUPLE_SUPPORT))
1214 return 0;
1215
1216 if (!flow_cfg->max_flows)
1217 return 0;
1218
1219 mutex_lock(&pfvf->mbox.lock);
1220 req = otx2_mbox_alloc_msg_npc_delete_flow(&pfvf->mbox);
1221 if (!req) {
1222 mutex_unlock(&pfvf->mbox.lock);
1223 return -ENOMEM;
1224 }
1225
1226 req->start = flow_cfg->flow_ent[0];
1227 req->end = flow_cfg->flow_ent[flow_cfg->max_flows - 1];
1228 err = otx2_sync_mbox_msg(&pfvf->mbox);
1229 mutex_unlock(&pfvf->mbox.lock);
1230
1231 list_for_each_entry_safe(iter, tmp, &flow_cfg->flow_list, list) {
1232 list_del(&iter->list);
1233 kfree(iter);
1234 flow_cfg->nr_flows--;
1235 }
1236 return err;
1237}
1238
1239int otx2_destroy_mcam_flows(struct otx2_nic *pfvf)
1240{
1241 struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
1242 struct npc_mcam_free_entry_req *req;
1243 struct otx2_flow *iter, *tmp;
1244 int err;
1245
1246 if (!(pfvf->flags & OTX2_FLAG_MCAM_ENTRIES_ALLOC))
1247 return 0;
1248
1249
1250 err = otx2_remove_flow_msg(pfvf, 0, true);
1251 if (err)
1252 return err;
1253
1254 list_for_each_entry_safe(iter, tmp, &flow_cfg->flow_list, list) {
1255 list_del(&iter->list);
1256 kfree(iter);
1257 flow_cfg->nr_flows--;
1258 }
1259
1260 mutex_lock(&pfvf->mbox.lock);
1261 req = otx2_mbox_alloc_msg_npc_mcam_free_entry(&pfvf->mbox);
1262 if (!req) {
1263 mutex_unlock(&pfvf->mbox.lock);
1264 return -ENOMEM;
1265 }
1266
1267 req->all = 1;
1268
1269 err = otx2_sync_mbox_msg(&pfvf->mbox);
1270 if (err) {
1271 mutex_unlock(&pfvf->mbox.lock);
1272 return err;
1273 }
1274
1275 pfvf->flags &= ~OTX2_FLAG_MCAM_ENTRIES_ALLOC;
1276 mutex_unlock(&pfvf->mbox.lock);
1277
1278 return 0;
1279}
1280
1281int otx2_install_rxvlan_offload_flow(struct otx2_nic *pfvf)
1282{
1283 struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
1284 struct npc_install_flow_req *req;
1285 int err;
1286
1287 mutex_lock(&pfvf->mbox.lock);
1288 req = otx2_mbox_alloc_msg_npc_install_flow(&pfvf->mbox);
1289 if (!req) {
1290 mutex_unlock(&pfvf->mbox.lock);
1291 return -ENOMEM;
1292 }
1293
1294 req->entry = flow_cfg->def_ent[flow_cfg->rx_vlan_offset];
1295 req->intf = NIX_INTF_RX;
1296 ether_addr_copy(req->packet.dmac, pfvf->netdev->dev_addr);
1297 eth_broadcast_addr((u8 *)&req->mask.dmac);
1298 req->channel = pfvf->hw.rx_chan_base;
1299 req->op = NIX_RX_ACTION_DEFAULT;
1300 req->features = BIT_ULL(NPC_OUTER_VID) | BIT_ULL(NPC_DMAC);
1301 req->vtag0_valid = true;
1302 req->vtag0_type = NIX_AF_LFX_RX_VTAG_TYPE0;
1303
1304
1305 err = otx2_sync_mbox_msg(&pfvf->mbox);
1306 mutex_unlock(&pfvf->mbox.lock);
1307 return err;
1308}
1309
1310static int otx2_delete_rxvlan_offload_flow(struct otx2_nic *pfvf)
1311{
1312 struct otx2_flow_config *flow_cfg = pfvf->flow_cfg;
1313 struct npc_delete_flow_req *req;
1314 int err;
1315
1316 mutex_lock(&pfvf->mbox.lock);
1317 req = otx2_mbox_alloc_msg_npc_delete_flow(&pfvf->mbox);
1318 if (!req) {
1319 mutex_unlock(&pfvf->mbox.lock);
1320 return -ENOMEM;
1321 }
1322
1323 req->entry = flow_cfg->def_ent[flow_cfg->rx_vlan_offset];
1324
1325 err = otx2_sync_mbox_msg(&pfvf->mbox);
1326 mutex_unlock(&pfvf->mbox.lock);
1327 return err;
1328}
1329
1330int otx2_enable_rxvlan(struct otx2_nic *pf, bool enable)
1331{
1332 struct nix_vtag_config *req;
1333 struct mbox_msghdr *rsp_hdr;
1334 int err;
1335
1336
1337 if (!(pf->flags & OTX2_FLAG_RX_VLAN_SUPPORT))
1338 return -ENOMEM;
1339
1340 if (enable) {
1341 err = otx2_install_rxvlan_offload_flow(pf);
1342 if (err)
1343 return err;
1344 } else {
1345 err = otx2_delete_rxvlan_offload_flow(pf);
1346 if (err)
1347 return err;
1348 }
1349
1350 mutex_lock(&pf->mbox.lock);
1351 req = otx2_mbox_alloc_msg_nix_vtag_cfg(&pf->mbox);
1352 if (!req) {
1353 mutex_unlock(&pf->mbox.lock);
1354 return -ENOMEM;
1355 }
1356
1357
1358 req->vtag_size = VTAGSIZE_T4;
1359 req->cfg_type = 1;
1360 req->rx.vtag_type = NIX_AF_LFX_RX_VTAG_TYPE0;
1361 req->rx.strip_vtag = enable;
1362 req->rx.capture_vtag = enable;
1363
1364 err = otx2_sync_mbox_msg(&pf->mbox);
1365 if (err) {
1366 mutex_unlock(&pf->mbox.lock);
1367 return err;
1368 }
1369
1370 rsp_hdr = otx2_mbox_get_rsp(&pf->mbox.mbox, 0, &req->hdr);
1371 if (IS_ERR(rsp_hdr)) {
1372 mutex_unlock(&pf->mbox.lock);
1373 return PTR_ERR(rsp_hdr);
1374 }
1375
1376 mutex_unlock(&pf->mbox.lock);
1377 return rsp_hdr->rc;
1378}
1379
1380void otx2_dmacflt_reinstall_flows(struct otx2_nic *pf)
1381{
1382 struct otx2_flow *iter;
1383 struct ethhdr *eth_hdr;
1384
1385 list_for_each_entry(iter, &pf->flow_cfg->flow_list, list) {
1386 if (iter->dmac_filter) {
1387 eth_hdr = &iter->flow_spec.h_u.ether_spec;
1388 otx2_dmacflt_add(pf, eth_hdr->h_dest,
1389 iter->entry);
1390 }
1391 }
1392}
1393
1394void otx2_dmacflt_update_pfmac_flow(struct otx2_nic *pfvf)
1395{
1396 otx2_update_rem_pfmac(pfvf, DMAC_ADDR_UPDATE);
1397}
1398
