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