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