1 /* QLogic qede NIC Driver 2 * Copyright (c) 2015-2017 QLogic Corporation 3 * 4 * This software is available to you under a choice of one of two 5 * licenses. You may choose to be licensed under the terms of the GNU 6 * General Public License (GPL) Version 2, available from the file 7 * COPYING in the main directory of this source tree, or the 8 * OpenIB.org BSD license below: 9 * 10 * Redistribution and use in source and binary forms, with or 11 * without modification, are permitted provided that the following 12 * conditions are met: 13 * 14 * - Redistributions of source code must retain the above 15 * copyright notice, this list of conditions and the following 16 * disclaimer. 17 * 18 * - Redistributions in binary form must reproduce the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer in the documentation and /or other materials 21 * provided with the distribution. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 * SOFTWARE. 31 */ 32 #include <linux/netdevice.h> 33 #include <linux/etherdevice.h> 34 #include <net/udp_tunnel.h> 35 #include <linux/bitops.h> 36 #include <linux/vmalloc.h> 37 38 #include <linux/qed/qed_if.h> 39 #include "qede.h" 40 41 struct qede_arfs_tuple { 42 union { 43 __be32 src_ipv4; 44 struct in6_addr src_ipv6; 45 }; 46 union { 47 __be32 dst_ipv4; 48 struct in6_addr dst_ipv6; 49 }; 50 __be16 src_port; 51 __be16 dst_port; 52 __be16 eth_proto; 53 u8 ip_proto; 54 }; 55 56 struct qede_arfs_fltr_node { 57 #define QEDE_FLTR_VALID 0 58 unsigned long state; 59 60 /* pointer to aRFS packet buffer */ 61 void *data; 62 63 /* dma map address of aRFS packet buffer */ 64 dma_addr_t mapping; 65 66 /* length of aRFS packet buffer */ 67 int buf_len; 68 69 /* tuples to hold from aRFS packet buffer */ 70 struct qede_arfs_tuple tuple; 71 72 u32 flow_id; 73 u16 sw_id; 74 u16 rxq_id; 75 u16 next_rxq_id; 76 bool filter_op; 77 bool used; 78 u8 fw_rc; 79 struct hlist_node node; 80 }; 81 82 struct qede_arfs { 83 #define QEDE_ARFS_BUCKET_HEAD(edev, idx) (&(edev)->arfs->arfs_hl_head[idx]) 84 #define QEDE_ARFS_POLL_COUNT 100 85 #define QEDE_RFS_FLW_BITSHIFT (4) 86 #define QEDE_RFS_FLW_MASK ((1 << QEDE_RFS_FLW_BITSHIFT) - 1) 87 struct hlist_head arfs_hl_head[1 << QEDE_RFS_FLW_BITSHIFT]; 88 89 /* lock for filter list access */ 90 spinlock_t arfs_list_lock; 91 unsigned long *arfs_fltr_bmap; 92 int filter_count; 93 bool enable; 94 }; 95 96 static void qede_configure_arfs_fltr(struct qede_dev *edev, 97 struct qede_arfs_fltr_node *n, 98 u16 rxq_id, bool add_fltr) 99 { 100 const struct qed_eth_ops *op = edev->ops; 101 102 if (n->used) 103 return; 104 105 DP_VERBOSE(edev, NETIF_MSG_RX_STATUS, 106 "%s arfs filter flow_id=%d, sw_id=%d, src_port=%d, dst_port=%d, rxq=%d\n", 107 add_fltr ? "Adding" : "Deleting", 108 n->flow_id, n->sw_id, ntohs(n->tuple.src_port), 109 ntohs(n->tuple.dst_port), rxq_id); 110 111 n->used = true; 112 n->filter_op = add_fltr; 113 op->ntuple_filter_config(edev->cdev, n, n->mapping, n->buf_len, 0, 114 rxq_id, add_fltr); 115 } 116 117 static void 118 qede_free_arfs_filter(struct qede_dev *edev, struct qede_arfs_fltr_node *fltr) 119 { 120 kfree(fltr->data); 121 clear_bit(fltr->sw_id, edev->arfs->arfs_fltr_bmap); 122 kfree(fltr); 123 } 124 125 static int 126 qede_enqueue_fltr_and_config_searcher(struct qede_dev *edev, 127 struct qede_arfs_fltr_node *fltr, 128 u16 bucket_idx) 129 { 130 fltr->mapping = dma_map_single(&edev->pdev->dev, fltr->data, 131 fltr->buf_len, DMA_TO_DEVICE); 132 if (dma_mapping_error(&edev->pdev->dev, fltr->mapping)) { 133 DP_NOTICE(edev, "Failed to map DMA memory for rule\n"); 134 qede_free_arfs_filter(edev, fltr); 135 return -ENOMEM; 136 } 137 138 INIT_HLIST_NODE(&fltr->node); 139 hlist_add_head(&fltr->node, 140 QEDE_ARFS_BUCKET_HEAD(edev, bucket_idx)); 141 edev->arfs->filter_count++; 142 143 if (edev->arfs->filter_count == 1 && !edev->arfs->enable) { 144 edev->ops->configure_arfs_searcher(edev->cdev, true); 145 edev->arfs->enable = true; 146 } 147 148 return 0; 149 } 150 151 static void 152 qede_dequeue_fltr_and_config_searcher(struct qede_dev *edev, 153 struct qede_arfs_fltr_node *fltr) 154 { 155 hlist_del(&fltr->node); 156 dma_unmap_single(&edev->pdev->dev, fltr->mapping, 157 fltr->buf_len, DMA_TO_DEVICE); 158 159 qede_free_arfs_filter(edev, fltr); 160 edev->arfs->filter_count--; 161 162 if (!edev->arfs->filter_count && edev->arfs->enable) { 163 edev->arfs->enable = false; 164 edev->ops->configure_arfs_searcher(edev->cdev, false); 165 } 166 } 167 168 void qede_arfs_filter_op(void *dev, void *filter, u8 fw_rc) 169 { 170 struct qede_arfs_fltr_node *fltr = filter; 171 struct qede_dev *edev = dev; 172 173 fltr->fw_rc = fw_rc; 174 175 if (fw_rc) { 176 DP_NOTICE(edev, 177 "Failed arfs filter configuration fw_rc=%d, flow_id=%d, sw_id=%d, src_port=%d, dst_port=%d, rxq=%d\n", 178 fw_rc, fltr->flow_id, fltr->sw_id, 179 ntohs(fltr->tuple.src_port), 180 ntohs(fltr->tuple.dst_port), fltr->rxq_id); 181 182 spin_lock_bh(&edev->arfs->arfs_list_lock); 183 184 fltr->used = false; 185 clear_bit(QEDE_FLTR_VALID, &fltr->state); 186 187 spin_unlock_bh(&edev->arfs->arfs_list_lock); 188 return; 189 } 190 191 spin_lock_bh(&edev->arfs->arfs_list_lock); 192 193 fltr->used = false; 194 195 if (fltr->filter_op) { 196 set_bit(QEDE_FLTR_VALID, &fltr->state); 197 if (fltr->rxq_id != fltr->next_rxq_id) 198 qede_configure_arfs_fltr(edev, fltr, fltr->rxq_id, 199 false); 200 } else { 201 clear_bit(QEDE_FLTR_VALID, &fltr->state); 202 if (fltr->rxq_id != fltr->next_rxq_id) { 203 fltr->rxq_id = fltr->next_rxq_id; 204 qede_configure_arfs_fltr(edev, fltr, 205 fltr->rxq_id, true); 206 } 207 } 208 209 spin_unlock_bh(&edev->arfs->arfs_list_lock); 210 } 211 212 /* Should be called while qede_lock is held */ 213 void qede_process_arfs_filters(struct qede_dev *edev, bool free_fltr) 214 { 215 int i; 216 217 for (i = 0; i <= QEDE_RFS_FLW_MASK; i++) { 218 struct hlist_node *temp; 219 struct hlist_head *head; 220 struct qede_arfs_fltr_node *fltr; 221 222 head = &edev->arfs->arfs_hl_head[i]; 223 224 hlist_for_each_entry_safe(fltr, temp, head, node) { 225 bool del = false; 226 227 if (edev->state != QEDE_STATE_OPEN) 228 del = true; 229 230 spin_lock_bh(&edev->arfs->arfs_list_lock); 231 232 if ((!test_bit(QEDE_FLTR_VALID, &fltr->state) && 233 !fltr->used) || free_fltr) { 234 qede_dequeue_fltr_and_config_searcher(edev, 235 fltr); 236 } else { 237 bool flow_exp = false; 238 #ifdef CONFIG_RFS_ACCEL 239 flow_exp = rps_may_expire_flow(edev->ndev, 240 fltr->rxq_id, 241 fltr->flow_id, 242 fltr->sw_id); 243 #endif 244 if ((flow_exp || del) && !free_fltr) 245 qede_configure_arfs_fltr(edev, fltr, 246 fltr->rxq_id, 247 false); 248 } 249 250 spin_unlock_bh(&edev->arfs->arfs_list_lock); 251 } 252 } 253 254 spin_lock_bh(&edev->arfs->arfs_list_lock); 255 256 if (!edev->arfs->filter_count) { 257 if (edev->arfs->enable) { 258 edev->arfs->enable = false; 259 edev->ops->configure_arfs_searcher(edev->cdev, false); 260 } 261 #ifdef CONFIG_RFS_ACCEL 262 } else { 263 set_bit(QEDE_SP_ARFS_CONFIG, &edev->sp_flags); 264 schedule_delayed_work(&edev->sp_task, 265 QEDE_SP_TASK_POLL_DELAY); 266 #endif 267 } 268 269 spin_unlock_bh(&edev->arfs->arfs_list_lock); 270 } 271 272 /* This function waits until all aRFS filters get deleted and freed. 273 * On timeout it frees all filters forcefully. 274 */ 275 void qede_poll_for_freeing_arfs_filters(struct qede_dev *edev) 276 { 277 int count = QEDE_ARFS_POLL_COUNT; 278 279 while (count) { 280 qede_process_arfs_filters(edev, false); 281 282 if (!edev->arfs->filter_count) 283 break; 284 285 msleep(100); 286 count--; 287 } 288 289 if (!count) { 290 DP_NOTICE(edev, "Timeout in polling for arfs filter free\n"); 291 292 /* Something is terribly wrong, free forcefully */ 293 qede_process_arfs_filters(edev, true); 294 } 295 } 296 297 int qede_alloc_arfs(struct qede_dev *edev) 298 { 299 int i; 300 301 edev->arfs = vzalloc(sizeof(*edev->arfs)); 302 if (!edev->arfs) 303 return -ENOMEM; 304 305 spin_lock_init(&edev->arfs->arfs_list_lock); 306 307 for (i = 0; i <= QEDE_RFS_FLW_MASK; i++) 308 INIT_HLIST_HEAD(QEDE_ARFS_BUCKET_HEAD(edev, i)); 309 310 edev->arfs->arfs_fltr_bmap = vzalloc(BITS_TO_LONGS(QEDE_RFS_MAX_FLTR) * 311 sizeof(long)); 312 if (!edev->arfs->arfs_fltr_bmap) { 313 vfree(edev->arfs); 314 edev->arfs = NULL; 315 return -ENOMEM; 316 } 317 318 #ifdef CONFIG_RFS_ACCEL 319 edev->ndev->rx_cpu_rmap = alloc_irq_cpu_rmap(QEDE_RSS_COUNT(edev)); 320 if (!edev->ndev->rx_cpu_rmap) { 321 vfree(edev->arfs->arfs_fltr_bmap); 322 edev->arfs->arfs_fltr_bmap = NULL; 323 vfree(edev->arfs); 324 edev->arfs = NULL; 325 return -ENOMEM; 326 } 327 #endif 328 return 0; 329 } 330 331 void qede_free_arfs(struct qede_dev *edev) 332 { 333 if (!edev->arfs) 334 return; 335 336 #ifdef CONFIG_RFS_ACCEL 337 if (edev->ndev->rx_cpu_rmap) 338 free_irq_cpu_rmap(edev->ndev->rx_cpu_rmap); 339 340 edev->ndev->rx_cpu_rmap = NULL; 341 #endif 342 vfree(edev->arfs->arfs_fltr_bmap); 343 edev->arfs->arfs_fltr_bmap = NULL; 344 vfree(edev->arfs); 345 edev->arfs = NULL; 346 } 347 348 #ifdef CONFIG_RFS_ACCEL 349 static bool qede_compare_ip_addr(struct qede_arfs_fltr_node *tpos, 350 const struct sk_buff *skb) 351 { 352 if (skb->protocol == htons(ETH_P_IP)) { 353 if (tpos->tuple.src_ipv4 == ip_hdr(skb)->saddr && 354 tpos->tuple.dst_ipv4 == ip_hdr(skb)->daddr) 355 return true; 356 else 357 return false; 358 } else { 359 struct in6_addr *src = &tpos->tuple.src_ipv6; 360 u8 size = sizeof(struct in6_addr); 361 362 if (!memcmp(src, &ipv6_hdr(skb)->saddr, size) && 363 !memcmp(&tpos->tuple.dst_ipv6, &ipv6_hdr(skb)->daddr, size)) 364 return true; 365 else 366 return false; 367 } 368 } 369 370 static struct qede_arfs_fltr_node * 371 qede_arfs_htbl_key_search(struct hlist_head *h, const struct sk_buff *skb, 372 __be16 src_port, __be16 dst_port, u8 ip_proto) 373 { 374 struct qede_arfs_fltr_node *tpos; 375 376 hlist_for_each_entry(tpos, h, node) 377 if (tpos->tuple.ip_proto == ip_proto && 378 tpos->tuple.eth_proto == skb->protocol && 379 qede_compare_ip_addr(tpos, skb) && 380 tpos->tuple.src_port == src_port && 381 tpos->tuple.dst_port == dst_port) 382 return tpos; 383 384 return NULL; 385 } 386 387 static struct qede_arfs_fltr_node * 388 qede_alloc_filter(struct qede_dev *edev, int min_hlen) 389 { 390 struct qede_arfs_fltr_node *n; 391 int bit_id; 392 393 bit_id = find_first_zero_bit(edev->arfs->arfs_fltr_bmap, 394 QEDE_RFS_MAX_FLTR); 395 396 if (bit_id >= QEDE_RFS_MAX_FLTR) 397 return NULL; 398 399 n = kzalloc(sizeof(*n), GFP_ATOMIC); 400 if (!n) 401 return NULL; 402 403 n->data = kzalloc(min_hlen, GFP_ATOMIC); 404 if (!n->data) { 405 kfree(n); 406 return NULL; 407 } 408 409 n->sw_id = (u16)bit_id; 410 set_bit(bit_id, edev->arfs->arfs_fltr_bmap); 411 return n; 412 } 413 414 int qede_rx_flow_steer(struct net_device *dev, const struct sk_buff *skb, 415 u16 rxq_index, u32 flow_id) 416 { 417 struct qede_dev *edev = netdev_priv(dev); 418 struct qede_arfs_fltr_node *n; 419 int min_hlen, rc, tp_offset; 420 struct ethhdr *eth; 421 __be16 *ports; 422 u16 tbl_idx; 423 u8 ip_proto; 424 425 if (skb->encapsulation) 426 return -EPROTONOSUPPORT; 427 428 if (skb->protocol != htons(ETH_P_IP) && 429 skb->protocol != htons(ETH_P_IPV6)) 430 return -EPROTONOSUPPORT; 431 432 if (skb->protocol == htons(ETH_P_IP)) { 433 ip_proto = ip_hdr(skb)->protocol; 434 tp_offset = sizeof(struct iphdr); 435 } else { 436 ip_proto = ipv6_hdr(skb)->nexthdr; 437 tp_offset = sizeof(struct ipv6hdr); 438 } 439 440 if (ip_proto != IPPROTO_TCP && ip_proto != IPPROTO_UDP) 441 return -EPROTONOSUPPORT; 442 443 ports = (__be16 *)(skb->data + tp_offset); 444 tbl_idx = skb_get_hash_raw(skb) & QEDE_RFS_FLW_MASK; 445 446 spin_lock_bh(&edev->arfs->arfs_list_lock); 447 448 n = qede_arfs_htbl_key_search(QEDE_ARFS_BUCKET_HEAD(edev, tbl_idx), 449 skb, ports[0], ports[1], ip_proto); 450 if (n) { 451 /* Filter match */ 452 n->next_rxq_id = rxq_index; 453 454 if (test_bit(QEDE_FLTR_VALID, &n->state)) { 455 if (n->rxq_id != rxq_index) 456 qede_configure_arfs_fltr(edev, n, n->rxq_id, 457 false); 458 } else { 459 if (!n->used) { 460 n->rxq_id = rxq_index; 461 qede_configure_arfs_fltr(edev, n, n->rxq_id, 462 true); 463 } 464 } 465 466 rc = n->sw_id; 467 goto ret_unlock; 468 } 469 470 min_hlen = ETH_HLEN + skb_headlen(skb); 471 472 n = qede_alloc_filter(edev, min_hlen); 473 if (!n) { 474 rc = -ENOMEM; 475 goto ret_unlock; 476 } 477 478 n->buf_len = min_hlen; 479 n->rxq_id = rxq_index; 480 n->next_rxq_id = rxq_index; 481 n->tuple.src_port = ports[0]; 482 n->tuple.dst_port = ports[1]; 483 n->flow_id = flow_id; 484 485 if (skb->protocol == htons(ETH_P_IP)) { 486 n->tuple.src_ipv4 = ip_hdr(skb)->saddr; 487 n->tuple.dst_ipv4 = ip_hdr(skb)->daddr; 488 } else { 489 memcpy(&n->tuple.src_ipv6, &ipv6_hdr(skb)->saddr, 490 sizeof(struct in6_addr)); 491 memcpy(&n->tuple.dst_ipv6, &ipv6_hdr(skb)->daddr, 492 sizeof(struct in6_addr)); 493 } 494 495 eth = (struct ethhdr *)n->data; 496 eth->h_proto = skb->protocol; 497 n->tuple.eth_proto = skb->protocol; 498 n->tuple.ip_proto = ip_proto; 499 memcpy(n->data + ETH_HLEN, skb->data, skb_headlen(skb)); 500 501 rc = qede_enqueue_fltr_and_config_searcher(edev, n, tbl_idx); 502 if (rc) 503 goto ret_unlock; 504 505 qede_configure_arfs_fltr(edev, n, n->rxq_id, true); 506 507 spin_unlock_bh(&edev->arfs->arfs_list_lock); 508 509 set_bit(QEDE_SP_ARFS_CONFIG, &edev->sp_flags); 510 schedule_delayed_work(&edev->sp_task, 0); 511 512 return n->sw_id; 513 514 ret_unlock: 515 spin_unlock_bh(&edev->arfs->arfs_list_lock); 516 return rc; 517 } 518 #endif 519 520 void qede_udp_ports_update(void *dev, u16 vxlan_port, u16 geneve_port) 521 { 522 struct qede_dev *edev = dev; 523 524 if (edev->vxlan_dst_port != vxlan_port) 525 edev->vxlan_dst_port = 0; 526 527 if (edev->geneve_dst_port != geneve_port) 528 edev->geneve_dst_port = 0; 529 } 530 531 void qede_force_mac(void *dev, u8 *mac, bool forced) 532 { 533 struct qede_dev *edev = dev; 534 535 __qede_lock(edev); 536 537 /* MAC hints take effect only if we haven't set one already */ 538 if (is_valid_ether_addr(edev->ndev->dev_addr) && !forced) { 539 __qede_unlock(edev); 540 return; 541 } 542 543 ether_addr_copy(edev->ndev->dev_addr, mac); 544 __qede_unlock(edev); 545 } 546 547 void qede_fill_rss_params(struct qede_dev *edev, 548 struct qed_update_vport_rss_params *rss, u8 *update) 549 { 550 bool need_reset = false; 551 int i; 552 553 if (QEDE_RSS_COUNT(edev) <= 1) { 554 memset(rss, 0, sizeof(*rss)); 555 *update = 0; 556 return; 557 } 558 559 /* Need to validate current RSS config uses valid entries */ 560 for (i = 0; i < QED_RSS_IND_TABLE_SIZE; i++) { 561 if (edev->rss_ind_table[i] >= QEDE_RSS_COUNT(edev)) { 562 need_reset = true; 563 break; 564 } 565 } 566 567 if (!(edev->rss_params_inited & QEDE_RSS_INDIR_INITED) || need_reset) { 568 for (i = 0; i < QED_RSS_IND_TABLE_SIZE; i++) { 569 u16 indir_val, val; 570 571 val = QEDE_RSS_COUNT(edev); 572 indir_val = ethtool_rxfh_indir_default(i, val); 573 edev->rss_ind_table[i] = indir_val; 574 } 575 edev->rss_params_inited |= QEDE_RSS_INDIR_INITED; 576 } 577 578 /* Now that we have the queue-indirection, prepare the handles */ 579 for (i = 0; i < QED_RSS_IND_TABLE_SIZE; i++) { 580 u16 idx = QEDE_RX_QUEUE_IDX(edev, edev->rss_ind_table[i]); 581 582 rss->rss_ind_table[i] = edev->fp_array[idx].rxq->handle; 583 } 584 585 if (!(edev->rss_params_inited & QEDE_RSS_KEY_INITED)) { 586 netdev_rss_key_fill(edev->rss_key, sizeof(edev->rss_key)); 587 edev->rss_params_inited |= QEDE_RSS_KEY_INITED; 588 } 589 memcpy(rss->rss_key, edev->rss_key, sizeof(rss->rss_key)); 590 591 if (!(edev->rss_params_inited & QEDE_RSS_CAPS_INITED)) { 592 edev->rss_caps = QED_RSS_IPV4 | QED_RSS_IPV6 | 593 QED_RSS_IPV4_TCP | QED_RSS_IPV6_TCP; 594 edev->rss_params_inited |= QEDE_RSS_CAPS_INITED; 595 } 596 rss->rss_caps = edev->rss_caps; 597 598 *update = 1; 599 } 600 601 static int qede_set_ucast_rx_mac(struct qede_dev *edev, 602 enum qed_filter_xcast_params_type opcode, 603 unsigned char mac[ETH_ALEN]) 604 { 605 struct qed_filter_params filter_cmd; 606 607 memset(&filter_cmd, 0, sizeof(filter_cmd)); 608 filter_cmd.type = QED_FILTER_TYPE_UCAST; 609 filter_cmd.filter.ucast.type = opcode; 610 filter_cmd.filter.ucast.mac_valid = 1; 611 ether_addr_copy(filter_cmd.filter.ucast.mac, mac); 612 613 return edev->ops->filter_config(edev->cdev, &filter_cmd); 614 } 615 616 static int qede_set_ucast_rx_vlan(struct qede_dev *edev, 617 enum qed_filter_xcast_params_type opcode, 618 u16 vid) 619 { 620 struct qed_filter_params filter_cmd; 621 622 memset(&filter_cmd, 0, sizeof(filter_cmd)); 623 filter_cmd.type = QED_FILTER_TYPE_UCAST; 624 filter_cmd.filter.ucast.type = opcode; 625 filter_cmd.filter.ucast.vlan_valid = 1; 626 filter_cmd.filter.ucast.vlan = vid; 627 628 return edev->ops->filter_config(edev->cdev, &filter_cmd); 629 } 630 631 static int qede_config_accept_any_vlan(struct qede_dev *edev, bool action) 632 { 633 struct qed_update_vport_params *params; 634 int rc; 635 636 /* Proceed only if action actually needs to be performed */ 637 if (edev->accept_any_vlan == action) 638 return 0; 639 640 params = vzalloc(sizeof(*params)); 641 if (!params) 642 return -ENOMEM; 643 644 params->vport_id = 0; 645 params->accept_any_vlan = action; 646 params->update_accept_any_vlan_flg = 1; 647 648 rc = edev->ops->vport_update(edev->cdev, params); 649 if (rc) { 650 DP_ERR(edev, "Failed to %s accept-any-vlan\n", 651 action ? "enable" : "disable"); 652 } else { 653 DP_INFO(edev, "%s accept-any-vlan\n", 654 action ? "enabled" : "disabled"); 655 edev->accept_any_vlan = action; 656 } 657 658 vfree(params); 659 return 0; 660 } 661 662 int qede_vlan_rx_add_vid(struct net_device *dev, __be16 proto, u16 vid) 663 { 664 struct qede_dev *edev = netdev_priv(dev); 665 struct qede_vlan *vlan, *tmp; 666 int rc = 0; 667 668 DP_VERBOSE(edev, NETIF_MSG_IFUP, "Adding vlan 0x%04x\n", vid); 669 670 vlan = kzalloc(sizeof(*vlan), GFP_KERNEL); 671 if (!vlan) { 672 DP_INFO(edev, "Failed to allocate struct for vlan\n"); 673 return -ENOMEM; 674 } 675 INIT_LIST_HEAD(&vlan->list); 676 vlan->vid = vid; 677 vlan->configured = false; 678 679 /* Verify vlan isn't already configured */ 680 list_for_each_entry(tmp, &edev->vlan_list, list) { 681 if (tmp->vid == vlan->vid) { 682 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN), 683 "vlan already configured\n"); 684 kfree(vlan); 685 return -EEXIST; 686 } 687 } 688 689 /* If interface is down, cache this VLAN ID and return */ 690 __qede_lock(edev); 691 if (edev->state != QEDE_STATE_OPEN) { 692 DP_VERBOSE(edev, NETIF_MSG_IFDOWN, 693 "Interface is down, VLAN %d will be configured when interface is up\n", 694 vid); 695 if (vid != 0) 696 edev->non_configured_vlans++; 697 list_add(&vlan->list, &edev->vlan_list); 698 goto out; 699 } 700 701 /* Check for the filter limit. 702 * Note - vlan0 has a reserved filter and can be added without 703 * worrying about quota 704 */ 705 if ((edev->configured_vlans < edev->dev_info.num_vlan_filters) || 706 (vlan->vid == 0)) { 707 rc = qede_set_ucast_rx_vlan(edev, 708 QED_FILTER_XCAST_TYPE_ADD, 709 vlan->vid); 710 if (rc) { 711 DP_ERR(edev, "Failed to configure VLAN %d\n", 712 vlan->vid); 713 kfree(vlan); 714 goto out; 715 } 716 vlan->configured = true; 717 718 /* vlan0 filter isn't consuming out of our quota */ 719 if (vlan->vid != 0) 720 edev->configured_vlans++; 721 } else { 722 /* Out of quota; Activate accept-any-VLAN mode */ 723 if (!edev->non_configured_vlans) { 724 rc = qede_config_accept_any_vlan(edev, true); 725 if (rc) { 726 kfree(vlan); 727 goto out; 728 } 729 } 730 731 edev->non_configured_vlans++; 732 } 733 734 list_add(&vlan->list, &edev->vlan_list); 735 736 out: 737 __qede_unlock(edev); 738 return rc; 739 } 740 741 static void qede_del_vlan_from_list(struct qede_dev *edev, 742 struct qede_vlan *vlan) 743 { 744 /* vlan0 filter isn't consuming out of our quota */ 745 if (vlan->vid != 0) { 746 if (vlan->configured) 747 edev->configured_vlans--; 748 else 749 edev->non_configured_vlans--; 750 } 751 752 list_del(&vlan->list); 753 kfree(vlan); 754 } 755 756 int qede_configure_vlan_filters(struct qede_dev *edev) 757 { 758 int rc = 0, real_rc = 0, accept_any_vlan = 0; 759 struct qed_dev_eth_info *dev_info; 760 struct qede_vlan *vlan = NULL; 761 762 if (list_empty(&edev->vlan_list)) 763 return 0; 764 765 dev_info = &edev->dev_info; 766 767 /* Configure non-configured vlans */ 768 list_for_each_entry(vlan, &edev->vlan_list, list) { 769 if (vlan->configured) 770 continue; 771 772 /* We have used all our credits, now enable accept_any_vlan */ 773 if ((vlan->vid != 0) && 774 (edev->configured_vlans == dev_info->num_vlan_filters)) { 775 accept_any_vlan = 1; 776 continue; 777 } 778 779 DP_VERBOSE(edev, NETIF_MSG_IFUP, "Adding vlan %d\n", vlan->vid); 780 781 rc = qede_set_ucast_rx_vlan(edev, QED_FILTER_XCAST_TYPE_ADD, 782 vlan->vid); 783 if (rc) { 784 DP_ERR(edev, "Failed to configure VLAN %u\n", 785 vlan->vid); 786 real_rc = rc; 787 continue; 788 } 789 790 vlan->configured = true; 791 /* vlan0 filter doesn't consume our VLAN filter's quota */ 792 if (vlan->vid != 0) { 793 edev->non_configured_vlans--; 794 edev->configured_vlans++; 795 } 796 } 797 798 /* enable accept_any_vlan mode if we have more VLANs than credits, 799 * or remove accept_any_vlan mode if we've actually removed 800 * a non-configured vlan, and all remaining vlans are truly configured. 801 */ 802 803 if (accept_any_vlan) 804 rc = qede_config_accept_any_vlan(edev, true); 805 else if (!edev->non_configured_vlans) 806 rc = qede_config_accept_any_vlan(edev, false); 807 808 if (rc && !real_rc) 809 real_rc = rc; 810 811 return real_rc; 812 } 813 814 int qede_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, u16 vid) 815 { 816 struct qede_dev *edev = netdev_priv(dev); 817 struct qede_vlan *vlan = NULL; 818 int rc = 0; 819 820 DP_VERBOSE(edev, NETIF_MSG_IFDOWN, "Removing vlan 0x%04x\n", vid); 821 822 /* Find whether entry exists */ 823 __qede_lock(edev); 824 list_for_each_entry(vlan, &edev->vlan_list, list) 825 if (vlan->vid == vid) 826 break; 827 828 if (!vlan || (vlan->vid != vid)) { 829 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN), 830 "Vlan isn't configured\n"); 831 goto out; 832 } 833 834 if (edev->state != QEDE_STATE_OPEN) { 835 /* As interface is already down, we don't have a VPORT 836 * instance to remove vlan filter. So just update vlan list 837 */ 838 DP_VERBOSE(edev, NETIF_MSG_IFDOWN, 839 "Interface is down, removing VLAN from list only\n"); 840 qede_del_vlan_from_list(edev, vlan); 841 goto out; 842 } 843 844 /* Remove vlan */ 845 if (vlan->configured) { 846 rc = qede_set_ucast_rx_vlan(edev, QED_FILTER_XCAST_TYPE_DEL, 847 vid); 848 if (rc) { 849 DP_ERR(edev, "Failed to remove VLAN %d\n", vid); 850 goto out; 851 } 852 } 853 854 qede_del_vlan_from_list(edev, vlan); 855 856 /* We have removed a VLAN - try to see if we can 857 * configure non-configured VLAN from the list. 858 */ 859 rc = qede_configure_vlan_filters(edev); 860 861 out: 862 __qede_unlock(edev); 863 return rc; 864 } 865 866 void qede_vlan_mark_nonconfigured(struct qede_dev *edev) 867 { 868 struct qede_vlan *vlan = NULL; 869 870 if (list_empty(&edev->vlan_list)) 871 return; 872 873 list_for_each_entry(vlan, &edev->vlan_list, list) { 874 if (!vlan->configured) 875 continue; 876 877 vlan->configured = false; 878 879 /* vlan0 filter isn't consuming out of our quota */ 880 if (vlan->vid != 0) { 881 edev->non_configured_vlans++; 882 edev->configured_vlans--; 883 } 884 885 DP_VERBOSE(edev, NETIF_MSG_IFDOWN, 886 "marked vlan %d as non-configured\n", vlan->vid); 887 } 888 889 edev->accept_any_vlan = false; 890 } 891 892 static void qede_set_features_reload(struct qede_dev *edev, 893 struct qede_reload_args *args) 894 { 895 edev->ndev->features = args->u.features; 896 } 897 898 int qede_set_features(struct net_device *dev, netdev_features_t features) 899 { 900 struct qede_dev *edev = netdev_priv(dev); 901 netdev_features_t changes = features ^ dev->features; 902 bool need_reload = false; 903 904 /* No action needed if hardware GRO is disabled during driver load */ 905 if (changes & NETIF_F_GRO) { 906 if (dev->features & NETIF_F_GRO) 907 need_reload = !edev->gro_disable; 908 else 909 need_reload = edev->gro_disable; 910 } 911 912 if (need_reload) { 913 struct qede_reload_args args; 914 915 args.u.features = features; 916 args.func = &qede_set_features_reload; 917 918 /* Make sure that we definitely need to reload. 919 * In case of an eBPF attached program, there will be no FW 920 * aggregations, so no need to actually reload. 921 */ 922 __qede_lock(edev); 923 if (edev->xdp_prog) 924 args.func(edev, &args); 925 else 926 qede_reload(edev, &args, true); 927 __qede_unlock(edev); 928 929 return 1; 930 } 931 932 return 0; 933 } 934 935 void qede_udp_tunnel_add(struct net_device *dev, struct udp_tunnel_info *ti) 936 { 937 struct qede_dev *edev = netdev_priv(dev); 938 struct qed_tunn_params tunn_params; 939 u16 t_port = ntohs(ti->port); 940 int rc; 941 942 memset(&tunn_params, 0, sizeof(tunn_params)); 943 944 switch (ti->type) { 945 case UDP_TUNNEL_TYPE_VXLAN: 946 if (!edev->dev_info.common.vxlan_enable) 947 return; 948 949 if (edev->vxlan_dst_port) 950 return; 951 952 tunn_params.update_vxlan_port = 1; 953 tunn_params.vxlan_port = t_port; 954 955 __qede_lock(edev); 956 rc = edev->ops->tunn_config(edev->cdev, &tunn_params); 957 __qede_unlock(edev); 958 959 if (!rc) { 960 edev->vxlan_dst_port = t_port; 961 DP_VERBOSE(edev, QED_MSG_DEBUG, "Added vxlan port=%d\n", 962 t_port); 963 } else { 964 DP_NOTICE(edev, "Failed to add vxlan UDP port=%d\n", 965 t_port); 966 } 967 968 break; 969 case UDP_TUNNEL_TYPE_GENEVE: 970 if (!edev->dev_info.common.geneve_enable) 971 return; 972 973 if (edev->geneve_dst_port) 974 return; 975 976 tunn_params.update_geneve_port = 1; 977 tunn_params.geneve_port = t_port; 978 979 __qede_lock(edev); 980 rc = edev->ops->tunn_config(edev->cdev, &tunn_params); 981 __qede_unlock(edev); 982 983 if (!rc) { 984 edev->geneve_dst_port = t_port; 985 DP_VERBOSE(edev, QED_MSG_DEBUG, 986 "Added geneve port=%d\n", t_port); 987 } else { 988 DP_NOTICE(edev, "Failed to add geneve UDP port=%d\n", 989 t_port); 990 } 991 992 break; 993 default: 994 return; 995 } 996 } 997 998 void qede_udp_tunnel_del(struct net_device *dev, 999 struct udp_tunnel_info *ti) 1000 { 1001 struct qede_dev *edev = netdev_priv(dev); 1002 struct qed_tunn_params tunn_params; 1003 u16 t_port = ntohs(ti->port); 1004 1005 memset(&tunn_params, 0, sizeof(tunn_params)); 1006 1007 switch (ti->type) { 1008 case UDP_TUNNEL_TYPE_VXLAN: 1009 if (t_port != edev->vxlan_dst_port) 1010 return; 1011 1012 tunn_params.update_vxlan_port = 1; 1013 tunn_params.vxlan_port = 0; 1014 1015 __qede_lock(edev); 1016 edev->ops->tunn_config(edev->cdev, &tunn_params); 1017 __qede_unlock(edev); 1018 1019 edev->vxlan_dst_port = 0; 1020 1021 DP_VERBOSE(edev, QED_MSG_DEBUG, "Deleted vxlan port=%d\n", 1022 t_port); 1023 1024 break; 1025 case UDP_TUNNEL_TYPE_GENEVE: 1026 if (t_port != edev->geneve_dst_port) 1027 return; 1028 1029 tunn_params.update_geneve_port = 1; 1030 tunn_params.geneve_port = 0; 1031 1032 __qede_lock(edev); 1033 edev->ops->tunn_config(edev->cdev, &tunn_params); 1034 __qede_unlock(edev); 1035 1036 edev->geneve_dst_port = 0; 1037 1038 DP_VERBOSE(edev, QED_MSG_DEBUG, "Deleted geneve port=%d\n", 1039 t_port); 1040 break; 1041 default: 1042 return; 1043 } 1044 } 1045 1046 static void qede_xdp_reload_func(struct qede_dev *edev, 1047 struct qede_reload_args *args) 1048 { 1049 struct bpf_prog *old; 1050 1051 old = xchg(&edev->xdp_prog, args->u.new_prog); 1052 if (old) 1053 bpf_prog_put(old); 1054 } 1055 1056 static int qede_xdp_set(struct qede_dev *edev, struct bpf_prog *prog) 1057 { 1058 struct qede_reload_args args; 1059 1060 /* If we're called, there was already a bpf reference increment */ 1061 args.func = &qede_xdp_reload_func; 1062 args.u.new_prog = prog; 1063 qede_reload(edev, &args, false); 1064 1065 return 0; 1066 } 1067 1068 int qede_xdp(struct net_device *dev, struct netdev_xdp *xdp) 1069 { 1070 struct qede_dev *edev = netdev_priv(dev); 1071 1072 switch (xdp->command) { 1073 case XDP_SETUP_PROG: 1074 return qede_xdp_set(edev, xdp->prog); 1075 case XDP_QUERY_PROG: 1076 xdp->prog_attached = !!edev->xdp_prog; 1077 xdp->prog_id = edev->xdp_prog ? edev->xdp_prog->aux->id : 0; 1078 return 0; 1079 default: 1080 return -EINVAL; 1081 } 1082 } 1083 1084 static int qede_set_mcast_rx_mac(struct qede_dev *edev, 1085 enum qed_filter_xcast_params_type opcode, 1086 unsigned char *mac, int num_macs) 1087 { 1088 struct qed_filter_params filter_cmd; 1089 int i; 1090 1091 memset(&filter_cmd, 0, sizeof(filter_cmd)); 1092 filter_cmd.type = QED_FILTER_TYPE_MCAST; 1093 filter_cmd.filter.mcast.type = opcode; 1094 filter_cmd.filter.mcast.num = num_macs; 1095 1096 for (i = 0; i < num_macs; i++, mac += ETH_ALEN) 1097 ether_addr_copy(filter_cmd.filter.mcast.mac[i], mac); 1098 1099 return edev->ops->filter_config(edev->cdev, &filter_cmd); 1100 } 1101 1102 int qede_set_mac_addr(struct net_device *ndev, void *p) 1103 { 1104 struct qede_dev *edev = netdev_priv(ndev); 1105 struct sockaddr *addr = p; 1106 int rc = 0; 1107 1108 /* Make sure the state doesn't transition while changing the MAC. 1109 * Also, all flows accessing the dev_addr field are doing that under 1110 * this lock. 1111 */ 1112 __qede_lock(edev); 1113 1114 if (!is_valid_ether_addr(addr->sa_data)) { 1115 DP_NOTICE(edev, "The MAC address is not valid\n"); 1116 rc = -EFAULT; 1117 goto out; 1118 } 1119 1120 if (!edev->ops->check_mac(edev->cdev, addr->sa_data)) { 1121 DP_NOTICE(edev, "qed prevents setting MAC %pM\n", 1122 addr->sa_data); 1123 rc = -EINVAL; 1124 goto out; 1125 } 1126 1127 if (edev->state == QEDE_STATE_OPEN) { 1128 /* Remove the previous primary mac */ 1129 rc = qede_set_ucast_rx_mac(edev, QED_FILTER_XCAST_TYPE_DEL, 1130 ndev->dev_addr); 1131 if (rc) 1132 goto out; 1133 } 1134 1135 ether_addr_copy(ndev->dev_addr, addr->sa_data); 1136 DP_INFO(edev, "Setting device MAC to %pM\n", addr->sa_data); 1137 1138 if (edev->state != QEDE_STATE_OPEN) { 1139 DP_VERBOSE(edev, NETIF_MSG_IFDOWN, 1140 "The device is currently down\n"); 1141 goto out; 1142 } 1143 1144 edev->ops->common->update_mac(edev->cdev, ndev->dev_addr); 1145 1146 rc = qede_set_ucast_rx_mac(edev, QED_FILTER_XCAST_TYPE_ADD, 1147 ndev->dev_addr); 1148 out: 1149 __qede_unlock(edev); 1150 return rc; 1151 } 1152 1153 static int 1154 qede_configure_mcast_filtering(struct net_device *ndev, 1155 enum qed_filter_rx_mode_type *accept_flags) 1156 { 1157 struct qede_dev *edev = netdev_priv(ndev); 1158 unsigned char *mc_macs, *temp; 1159 struct netdev_hw_addr *ha; 1160 int rc = 0, mc_count; 1161 size_t size; 1162 1163 size = 64 * ETH_ALEN; 1164 1165 mc_macs = kzalloc(size, GFP_KERNEL); 1166 if (!mc_macs) { 1167 DP_NOTICE(edev, 1168 "Failed to allocate memory for multicast MACs\n"); 1169 rc = -ENOMEM; 1170 goto exit; 1171 } 1172 1173 temp = mc_macs; 1174 1175 /* Remove all previously configured MAC filters */ 1176 rc = qede_set_mcast_rx_mac(edev, QED_FILTER_XCAST_TYPE_DEL, 1177 mc_macs, 1); 1178 if (rc) 1179 goto exit; 1180 1181 netif_addr_lock_bh(ndev); 1182 1183 mc_count = netdev_mc_count(ndev); 1184 if (mc_count < 64) { 1185 netdev_for_each_mc_addr(ha, ndev) { 1186 ether_addr_copy(temp, ha->addr); 1187 temp += ETH_ALEN; 1188 } 1189 } 1190 1191 netif_addr_unlock_bh(ndev); 1192 1193 /* Check for all multicast @@@TBD resource allocation */ 1194 if ((ndev->flags & IFF_ALLMULTI) || (mc_count > 64)) { 1195 if (*accept_flags == QED_FILTER_RX_MODE_TYPE_REGULAR) 1196 *accept_flags = QED_FILTER_RX_MODE_TYPE_MULTI_PROMISC; 1197 } else { 1198 /* Add all multicast MAC filters */ 1199 rc = qede_set_mcast_rx_mac(edev, QED_FILTER_XCAST_TYPE_ADD, 1200 mc_macs, mc_count); 1201 } 1202 1203 exit: 1204 kfree(mc_macs); 1205 return rc; 1206 } 1207 1208 void qede_set_rx_mode(struct net_device *ndev) 1209 { 1210 struct qede_dev *edev = netdev_priv(ndev); 1211 1212 set_bit(QEDE_SP_RX_MODE, &edev->sp_flags); 1213 schedule_delayed_work(&edev->sp_task, 0); 1214 } 1215 1216 /* Must be called with qede_lock held */ 1217 void qede_config_rx_mode(struct net_device *ndev) 1218 { 1219 enum qed_filter_rx_mode_type accept_flags; 1220 struct qede_dev *edev = netdev_priv(ndev); 1221 struct qed_filter_params rx_mode; 1222 unsigned char *uc_macs, *temp; 1223 struct netdev_hw_addr *ha; 1224 int rc, uc_count; 1225 size_t size; 1226 1227 netif_addr_lock_bh(ndev); 1228 1229 uc_count = netdev_uc_count(ndev); 1230 size = uc_count * ETH_ALEN; 1231 1232 uc_macs = kzalloc(size, GFP_ATOMIC); 1233 if (!uc_macs) { 1234 DP_NOTICE(edev, "Failed to allocate memory for unicast MACs\n"); 1235 netif_addr_unlock_bh(ndev); 1236 return; 1237 } 1238 1239 temp = uc_macs; 1240 netdev_for_each_uc_addr(ha, ndev) { 1241 ether_addr_copy(temp, ha->addr); 1242 temp += ETH_ALEN; 1243 } 1244 1245 netif_addr_unlock_bh(ndev); 1246 1247 /* Configure the struct for the Rx mode */ 1248 memset(&rx_mode, 0, sizeof(struct qed_filter_params)); 1249 rx_mode.type = QED_FILTER_TYPE_RX_MODE; 1250 1251 /* Remove all previous unicast secondary macs and multicast macs 1252 * (configrue / leave the primary mac) 1253 */ 1254 rc = qede_set_ucast_rx_mac(edev, QED_FILTER_XCAST_TYPE_REPLACE, 1255 edev->ndev->dev_addr); 1256 if (rc) 1257 goto out; 1258 1259 /* Check for promiscuous */ 1260 if (ndev->flags & IFF_PROMISC) 1261 accept_flags = QED_FILTER_RX_MODE_TYPE_PROMISC; 1262 else 1263 accept_flags = QED_FILTER_RX_MODE_TYPE_REGULAR; 1264 1265 /* Configure all filters regardless, in case promisc is rejected */ 1266 if (uc_count < edev->dev_info.num_mac_filters) { 1267 int i; 1268 1269 temp = uc_macs; 1270 for (i = 0; i < uc_count; i++) { 1271 rc = qede_set_ucast_rx_mac(edev, 1272 QED_FILTER_XCAST_TYPE_ADD, 1273 temp); 1274 if (rc) 1275 goto out; 1276 1277 temp += ETH_ALEN; 1278 } 1279 } else { 1280 accept_flags = QED_FILTER_RX_MODE_TYPE_PROMISC; 1281 } 1282 1283 rc = qede_configure_mcast_filtering(ndev, &accept_flags); 1284 if (rc) 1285 goto out; 1286 1287 /* take care of VLAN mode */ 1288 if (ndev->flags & IFF_PROMISC) { 1289 qede_config_accept_any_vlan(edev, true); 1290 } else if (!edev->non_configured_vlans) { 1291 /* It's possible that accept_any_vlan mode is set due to a 1292 * previous setting of IFF_PROMISC. If vlan credits are 1293 * sufficient, disable accept_any_vlan. 1294 */ 1295 qede_config_accept_any_vlan(edev, false); 1296 } 1297 1298 rx_mode.filter.accept_flags = accept_flags; 1299 edev->ops->filter_config(edev->cdev, &rx_mode); 1300 out: 1301 kfree(uc_macs); 1302 } 1303 1304 static struct qede_arfs_fltr_node * 1305 qede_get_arfs_fltr_by_loc(struct hlist_head *head, u32 location) 1306 { 1307 struct qede_arfs_fltr_node *fltr; 1308 1309 hlist_for_each_entry(fltr, head, node) 1310 if (location == fltr->sw_id) 1311 return fltr; 1312 1313 return NULL; 1314 } 1315 1316 static bool 1317 qede_compare_user_flow_ips(struct qede_arfs_fltr_node *tpos, 1318 struct ethtool_rx_flow_spec *fsp, 1319 __be16 proto) 1320 { 1321 if (proto == htons(ETH_P_IP)) { 1322 struct ethtool_tcpip4_spec *ip; 1323 1324 ip = &fsp->h_u.tcp_ip4_spec; 1325 1326 if (tpos->tuple.src_ipv4 == ip->ip4src && 1327 tpos->tuple.dst_ipv4 == ip->ip4dst) 1328 return true; 1329 else 1330 return false; 1331 } else { 1332 struct ethtool_tcpip6_spec *ip6; 1333 struct in6_addr *src; 1334 1335 ip6 = &fsp->h_u.tcp_ip6_spec; 1336 src = &tpos->tuple.src_ipv6; 1337 1338 if (!memcmp(src, &ip6->ip6src, sizeof(struct in6_addr)) && 1339 !memcmp(&tpos->tuple.dst_ipv6, &ip6->ip6dst, 1340 sizeof(struct in6_addr))) 1341 return true; 1342 else 1343 return false; 1344 } 1345 return false; 1346 } 1347 1348 int qede_get_cls_rule_all(struct qede_dev *edev, struct ethtool_rxnfc *info, 1349 u32 *rule_locs) 1350 { 1351 struct qede_arfs_fltr_node *fltr; 1352 struct hlist_head *head; 1353 int cnt = 0, rc = 0; 1354 1355 info->data = QEDE_RFS_MAX_FLTR; 1356 1357 __qede_lock(edev); 1358 1359 if (!edev->arfs) { 1360 rc = -EPERM; 1361 goto unlock; 1362 } 1363 1364 head = QEDE_ARFS_BUCKET_HEAD(edev, 0); 1365 1366 hlist_for_each_entry(fltr, head, node) { 1367 if (cnt == info->rule_cnt) { 1368 rc = -EMSGSIZE; 1369 goto unlock; 1370 } 1371 1372 rule_locs[cnt] = fltr->sw_id; 1373 cnt++; 1374 } 1375 1376 info->rule_cnt = cnt; 1377 1378 unlock: 1379 __qede_unlock(edev); 1380 return rc; 1381 } 1382 1383 int qede_get_cls_rule_entry(struct qede_dev *edev, struct ethtool_rxnfc *cmd) 1384 { 1385 struct ethtool_rx_flow_spec *fsp = &cmd->fs; 1386 struct qede_arfs_fltr_node *fltr = NULL; 1387 int rc = 0; 1388 1389 cmd->data = QEDE_RFS_MAX_FLTR; 1390 1391 __qede_lock(edev); 1392 1393 if (!edev->arfs) { 1394 rc = -EPERM; 1395 goto unlock; 1396 } 1397 1398 fltr = qede_get_arfs_fltr_by_loc(QEDE_ARFS_BUCKET_HEAD(edev, 0), 1399 fsp->location); 1400 if (!fltr) { 1401 DP_NOTICE(edev, "Rule not found - location=0x%x\n", 1402 fsp->location); 1403 rc = -EINVAL; 1404 goto unlock; 1405 } 1406 1407 if (fltr->tuple.eth_proto == htons(ETH_P_IP)) { 1408 if (fltr->tuple.ip_proto == IPPROTO_TCP) 1409 fsp->flow_type = TCP_V4_FLOW; 1410 else 1411 fsp->flow_type = UDP_V4_FLOW; 1412 1413 fsp->h_u.tcp_ip4_spec.psrc = fltr->tuple.src_port; 1414 fsp->h_u.tcp_ip4_spec.pdst = fltr->tuple.dst_port; 1415 fsp->h_u.tcp_ip4_spec.ip4src = fltr->tuple.src_ipv4; 1416 fsp->h_u.tcp_ip4_spec.ip4dst = fltr->tuple.dst_ipv4; 1417 } else { 1418 if (fltr->tuple.ip_proto == IPPROTO_TCP) 1419 fsp->flow_type = TCP_V6_FLOW; 1420 else 1421 fsp->flow_type = UDP_V6_FLOW; 1422 fsp->h_u.tcp_ip6_spec.psrc = fltr->tuple.src_port; 1423 fsp->h_u.tcp_ip6_spec.pdst = fltr->tuple.dst_port; 1424 memcpy(&fsp->h_u.tcp_ip6_spec.ip6src, 1425 &fltr->tuple.src_ipv6, sizeof(struct in6_addr)); 1426 memcpy(&fsp->h_u.tcp_ip6_spec.ip6dst, 1427 &fltr->tuple.dst_ipv6, sizeof(struct in6_addr)); 1428 } 1429 1430 fsp->ring_cookie = fltr->rxq_id; 1431 1432 unlock: 1433 __qede_unlock(edev); 1434 return rc; 1435 } 1436 1437 static int 1438 qede_validate_and_check_flow_exist(struct qede_dev *edev, 1439 struct ethtool_rx_flow_spec *fsp, 1440 int *min_hlen) 1441 { 1442 __be16 src_port = 0x0, dst_port = 0x0; 1443 struct qede_arfs_fltr_node *fltr; 1444 struct hlist_node *temp; 1445 struct hlist_head *head; 1446 __be16 eth_proto; 1447 u8 ip_proto; 1448 1449 if (fsp->location >= QEDE_RFS_MAX_FLTR || 1450 fsp->ring_cookie >= QEDE_RSS_COUNT(edev)) 1451 return -EINVAL; 1452 1453 if (fsp->flow_type == TCP_V4_FLOW) { 1454 *min_hlen += sizeof(struct iphdr) + 1455 sizeof(struct tcphdr); 1456 eth_proto = htons(ETH_P_IP); 1457 ip_proto = IPPROTO_TCP; 1458 } else if (fsp->flow_type == UDP_V4_FLOW) { 1459 *min_hlen += sizeof(struct iphdr) + 1460 sizeof(struct udphdr); 1461 eth_proto = htons(ETH_P_IP); 1462 ip_proto = IPPROTO_UDP; 1463 } else if (fsp->flow_type == TCP_V6_FLOW) { 1464 *min_hlen += sizeof(struct ipv6hdr) + 1465 sizeof(struct tcphdr); 1466 eth_proto = htons(ETH_P_IPV6); 1467 ip_proto = IPPROTO_TCP; 1468 } else if (fsp->flow_type == UDP_V6_FLOW) { 1469 *min_hlen += sizeof(struct ipv6hdr) + 1470 sizeof(struct udphdr); 1471 eth_proto = htons(ETH_P_IPV6); 1472 ip_proto = IPPROTO_UDP; 1473 } else { 1474 DP_NOTICE(edev, "Unsupported flow type = 0x%x\n", 1475 fsp->flow_type); 1476 return -EPROTONOSUPPORT; 1477 } 1478 1479 if (eth_proto == htons(ETH_P_IP)) { 1480 src_port = fsp->h_u.tcp_ip4_spec.psrc; 1481 dst_port = fsp->h_u.tcp_ip4_spec.pdst; 1482 } else { 1483 src_port = fsp->h_u.tcp_ip6_spec.psrc; 1484 dst_port = fsp->h_u.tcp_ip6_spec.pdst; 1485 } 1486 1487 head = QEDE_ARFS_BUCKET_HEAD(edev, 0); 1488 hlist_for_each_entry_safe(fltr, temp, head, node) { 1489 if ((fltr->tuple.ip_proto == ip_proto && 1490 fltr->tuple.eth_proto == eth_proto && 1491 qede_compare_user_flow_ips(fltr, fsp, eth_proto) && 1492 fltr->tuple.src_port == src_port && 1493 fltr->tuple.dst_port == dst_port) || 1494 fltr->sw_id == fsp->location) 1495 return -EEXIST; 1496 } 1497 1498 return 0; 1499 } 1500 1501 static int 1502 qede_poll_arfs_filter_config(struct qede_dev *edev, 1503 struct qede_arfs_fltr_node *fltr) 1504 { 1505 int count = QEDE_ARFS_POLL_COUNT; 1506 1507 while (fltr->used && count) { 1508 msleep(20); 1509 count--; 1510 } 1511 1512 if (count == 0 || fltr->fw_rc) { 1513 qede_dequeue_fltr_and_config_searcher(edev, fltr); 1514 return -EIO; 1515 } 1516 1517 return fltr->fw_rc; 1518 } 1519 1520 int qede_add_cls_rule(struct qede_dev *edev, struct ethtool_rxnfc *info) 1521 { 1522 struct ethtool_rx_flow_spec *fsp = &info->fs; 1523 struct qede_arfs_fltr_node *n; 1524 int min_hlen = ETH_HLEN, rc; 1525 struct ethhdr *eth; 1526 struct iphdr *ip; 1527 __be16 *ports; 1528 1529 __qede_lock(edev); 1530 1531 if (!edev->arfs) { 1532 rc = -EPERM; 1533 goto unlock; 1534 } 1535 1536 rc = qede_validate_and_check_flow_exist(edev, fsp, &min_hlen); 1537 if (rc) 1538 goto unlock; 1539 1540 n = kzalloc(sizeof(*n), GFP_KERNEL); 1541 if (!n) { 1542 rc = -ENOMEM; 1543 goto unlock; 1544 } 1545 1546 n->data = kzalloc(min_hlen, GFP_KERNEL); 1547 if (!n->data) { 1548 kfree(n); 1549 rc = -ENOMEM; 1550 goto unlock; 1551 } 1552 1553 n->sw_id = fsp->location; 1554 set_bit(n->sw_id, edev->arfs->arfs_fltr_bmap); 1555 n->buf_len = min_hlen; 1556 n->rxq_id = fsp->ring_cookie; 1557 n->next_rxq_id = n->rxq_id; 1558 eth = (struct ethhdr *)n->data; 1559 1560 if (info->fs.flow_type == TCP_V4_FLOW || 1561 info->fs.flow_type == UDP_V4_FLOW) { 1562 ports = (__be16 *)(n->data + ETH_HLEN + 1563 sizeof(struct iphdr)); 1564 eth->h_proto = htons(ETH_P_IP); 1565 n->tuple.eth_proto = htons(ETH_P_IP); 1566 n->tuple.src_ipv4 = info->fs.h_u.tcp_ip4_spec.ip4src; 1567 n->tuple.dst_ipv4 = info->fs.h_u.tcp_ip4_spec.ip4dst; 1568 n->tuple.src_port = info->fs.h_u.tcp_ip4_spec.psrc; 1569 n->tuple.dst_port = info->fs.h_u.tcp_ip4_spec.pdst; 1570 ports[0] = n->tuple.src_port; 1571 ports[1] = n->tuple.dst_port; 1572 ip = (struct iphdr *)(n->data + ETH_HLEN); 1573 ip->saddr = info->fs.h_u.tcp_ip4_spec.ip4src; 1574 ip->daddr = info->fs.h_u.tcp_ip4_spec.ip4dst; 1575 ip->version = 0x4; 1576 ip->ihl = 0x5; 1577 1578 if (info->fs.flow_type == TCP_V4_FLOW) { 1579 n->tuple.ip_proto = IPPROTO_TCP; 1580 ip->protocol = IPPROTO_TCP; 1581 } else { 1582 n->tuple.ip_proto = IPPROTO_UDP; 1583 ip->protocol = IPPROTO_UDP; 1584 } 1585 ip->tot_len = cpu_to_be16(min_hlen - ETH_HLEN); 1586 } else { 1587 struct ipv6hdr *ip6; 1588 1589 ip6 = (struct ipv6hdr *)(n->data + ETH_HLEN); 1590 ports = (__be16 *)(n->data + ETH_HLEN + 1591 sizeof(struct ipv6hdr)); 1592 eth->h_proto = htons(ETH_P_IPV6); 1593 n->tuple.eth_proto = htons(ETH_P_IPV6); 1594 memcpy(&n->tuple.src_ipv6, &info->fs.h_u.tcp_ip6_spec.ip6src, 1595 sizeof(struct in6_addr)); 1596 memcpy(&n->tuple.dst_ipv6, &info->fs.h_u.tcp_ip6_spec.ip6dst, 1597 sizeof(struct in6_addr)); 1598 n->tuple.src_port = info->fs.h_u.tcp_ip6_spec.psrc; 1599 n->tuple.dst_port = info->fs.h_u.tcp_ip6_spec.pdst; 1600 ports[0] = n->tuple.src_port; 1601 ports[1] = n->tuple.dst_port; 1602 memcpy(&ip6->saddr, &n->tuple.src_ipv6, 1603 sizeof(struct in6_addr)); 1604 memcpy(&ip6->daddr, &n->tuple.dst_ipv6, 1605 sizeof(struct in6_addr)); 1606 ip6->version = 0x6; 1607 1608 if (info->fs.flow_type == TCP_V6_FLOW) { 1609 n->tuple.ip_proto = IPPROTO_TCP; 1610 ip6->nexthdr = NEXTHDR_TCP; 1611 ip6->payload_len = cpu_to_be16(sizeof(struct tcphdr)); 1612 } else { 1613 n->tuple.ip_proto = IPPROTO_UDP; 1614 ip6->nexthdr = NEXTHDR_UDP; 1615 ip6->payload_len = cpu_to_be16(sizeof(struct udphdr)); 1616 } 1617 } 1618 1619 rc = qede_enqueue_fltr_and_config_searcher(edev, n, 0); 1620 if (rc) 1621 goto unlock; 1622 1623 qede_configure_arfs_fltr(edev, n, n->rxq_id, true); 1624 rc = qede_poll_arfs_filter_config(edev, n); 1625 unlock: 1626 __qede_unlock(edev); 1627 return rc; 1628 } 1629 1630 int qede_del_cls_rule(struct qede_dev *edev, struct ethtool_rxnfc *info) 1631 { 1632 struct ethtool_rx_flow_spec *fsp = &info->fs; 1633 struct qede_arfs_fltr_node *fltr = NULL; 1634 int rc = -EPERM; 1635 1636 __qede_lock(edev); 1637 if (!edev->arfs) 1638 goto unlock; 1639 1640 fltr = qede_get_arfs_fltr_by_loc(QEDE_ARFS_BUCKET_HEAD(edev, 0), 1641 fsp->location); 1642 if (!fltr) 1643 goto unlock; 1644 1645 qede_configure_arfs_fltr(edev, fltr, fltr->rxq_id, false); 1646 1647 rc = qede_poll_arfs_filter_config(edev, fltr); 1648 if (rc == 0) 1649 qede_dequeue_fltr_and_config_searcher(edev, fltr); 1650 1651 unlock: 1652 __qede_unlock(edev); 1653 return rc; 1654 } 1655 1656 int qede_get_arfs_filter_count(struct qede_dev *edev) 1657 { 1658 int count = 0; 1659 1660 __qede_lock(edev); 1661 1662 if (!edev->arfs) 1663 goto unlock; 1664 1665 count = edev->arfs->filter_count; 1666 1667 unlock: 1668 __qede_unlock(edev); 1669 return count; 1670 } 1671