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