2355 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/* Copyright (C) 2023 Intel Corporation */3 4#include "idpf.h"5#include "idpf_virtchnl.h"6 7static const struct net_device_ops idpf_netdev_ops;8 9/**10 * idpf_init_vector_stack - Fill the MSIX vector stack with vector index11 * @adapter: private data struct12 *13 * Return 0 on success, error on failure14 */15static int idpf_init_vector_stack(struct idpf_adapter *adapter)16{17 struct idpf_vector_lifo *stack;18 u16 min_vec;19 u32 i;20 21 mutex_lock(&adapter->vector_lock);22 min_vec = adapter->num_msix_entries - adapter->num_avail_msix;23 stack = &adapter->vector_stack;24 stack->size = adapter->num_msix_entries;25 /* set the base and top to point at start of the 'free pool' to26 * distribute the unused vectors on-demand basis27 */28 stack->base = min_vec;29 stack->top = min_vec;30 31 stack->vec_idx = kcalloc(stack->size, sizeof(u16), GFP_KERNEL);32 if (!stack->vec_idx) {33 mutex_unlock(&adapter->vector_lock);34 35 return -ENOMEM;36 }37 38 for (i = 0; i < stack->size; i++)39 stack->vec_idx[i] = i;40 41 mutex_unlock(&adapter->vector_lock);42 43 return 0;44}45 46/**47 * idpf_deinit_vector_stack - zero out the MSIX vector stack48 * @adapter: private data struct49 */50static void idpf_deinit_vector_stack(struct idpf_adapter *adapter)51{52 struct idpf_vector_lifo *stack;53 54 mutex_lock(&adapter->vector_lock);55 stack = &adapter->vector_stack;56 kfree(stack->vec_idx);57 stack->vec_idx = NULL;58 mutex_unlock(&adapter->vector_lock);59}60 61/**62 * idpf_mb_intr_rel_irq - Free the IRQ association with the OS63 * @adapter: adapter structure64 *65 * This will also disable interrupt mode and queue up mailbox task. Mailbox66 * task will reschedule itself if not in interrupt mode.67 */68static void idpf_mb_intr_rel_irq(struct idpf_adapter *adapter)69{70 clear_bit(IDPF_MB_INTR_MODE, adapter->flags);71 kfree(free_irq(adapter->msix_entries[0].vector, adapter));72 queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task, 0);73}74 75/**76 * idpf_intr_rel - Release interrupt capabilities and free memory77 * @adapter: adapter to disable interrupts on78 */79void idpf_intr_rel(struct idpf_adapter *adapter)80{81 if (!adapter->msix_entries)82 return;83 84 idpf_mb_intr_rel_irq(adapter);85 pci_free_irq_vectors(adapter->pdev);86 idpf_send_dealloc_vectors_msg(adapter);87 idpf_deinit_vector_stack(adapter);88 kfree(adapter->msix_entries);89 adapter->msix_entries = NULL;90}91 92/**93 * idpf_mb_intr_clean - Interrupt handler for the mailbox94 * @irq: interrupt number95 * @data: pointer to the adapter structure96 */97static irqreturn_t idpf_mb_intr_clean(int __always_unused irq, void *data)98{99 struct idpf_adapter *adapter = (struct idpf_adapter *)data;100 101 queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task, 0);102 103 return IRQ_HANDLED;104}105 106/**107 * idpf_mb_irq_enable - Enable MSIX interrupt for the mailbox108 * @adapter: adapter to get the hardware address for register write109 */110static void idpf_mb_irq_enable(struct idpf_adapter *adapter)111{112 struct idpf_intr_reg *intr = &adapter->mb_vector.intr_reg;113 u32 val;114 115 val = intr->dyn_ctl_intena_m | intr->dyn_ctl_itridx_m;116 writel(val, intr->dyn_ctl);117 writel(intr->icr_ena_ctlq_m, intr->icr_ena);118}119 120/**121 * idpf_mb_intr_req_irq - Request irq for the mailbox interrupt122 * @adapter: adapter structure to pass to the mailbox irq handler123 */124static int idpf_mb_intr_req_irq(struct idpf_adapter *adapter)125{126 int irq_num, mb_vidx = 0, err;127 char *name;128 129 irq_num = adapter->msix_entries[mb_vidx].vector;130 name = kasprintf(GFP_KERNEL, "%s-%s-%d",131 dev_driver_string(&adapter->pdev->dev),132 "Mailbox", mb_vidx);133 err = request_irq(irq_num, adapter->irq_mb_handler, 0, name, adapter);134 if (err) {135 dev_err(&adapter->pdev->dev,136 "IRQ request for mailbox failed, error: %d\n", err);137 138 return err;139 }140 141 set_bit(IDPF_MB_INTR_MODE, adapter->flags);142 143 return 0;144}145 146/**147 * idpf_set_mb_vec_id - Set vector index for mailbox148 * @adapter: adapter structure to access the vector chunks149 *150 * The first vector id in the requested vector chunks from the CP is for151 * the mailbox152 */153static void idpf_set_mb_vec_id(struct idpf_adapter *adapter)154{155 if (adapter->req_vec_chunks)156 adapter->mb_vector.v_idx =157 le16_to_cpu(adapter->caps.mailbox_vector_id);158 else159 adapter->mb_vector.v_idx = 0;160}161 162/**163 * idpf_mb_intr_init - Initialize the mailbox interrupt164 * @adapter: adapter structure to store the mailbox vector165 */166static int idpf_mb_intr_init(struct idpf_adapter *adapter)167{168 adapter->dev_ops.reg_ops.mb_intr_reg_init(adapter);169 adapter->irq_mb_handler = idpf_mb_intr_clean;170 171 return idpf_mb_intr_req_irq(adapter);172}173 174/**175 * idpf_vector_lifo_push - push MSIX vector index onto stack176 * @adapter: private data struct177 * @vec_idx: vector index to store178 */179static int idpf_vector_lifo_push(struct idpf_adapter *adapter, u16 vec_idx)180{181 struct idpf_vector_lifo *stack = &adapter->vector_stack;182 183 lockdep_assert_held(&adapter->vector_lock);184 185 if (stack->top == stack->base) {186 dev_err(&adapter->pdev->dev, "Exceeded the vector stack limit: %d\n",187 stack->top);188 return -EINVAL;189 }190 191 stack->vec_idx[--stack->top] = vec_idx;192 193 return 0;194}195 196/**197 * idpf_vector_lifo_pop - pop MSIX vector index from stack198 * @adapter: private data struct199 */200static int idpf_vector_lifo_pop(struct idpf_adapter *adapter)201{202 struct idpf_vector_lifo *stack = &adapter->vector_stack;203 204 lockdep_assert_held(&adapter->vector_lock);205 206 if (stack->top == stack->size) {207 dev_err(&adapter->pdev->dev, "No interrupt vectors are available to distribute!\n");208 209 return -EINVAL;210 }211 212 return stack->vec_idx[stack->top++];213}214 215/**216 * idpf_vector_stash - Store the vector indexes onto the stack217 * @adapter: private data struct218 * @q_vector_idxs: vector index array219 * @vec_info: info related to the number of vectors220 *221 * This function is a no-op if there are no vectors indexes to be stashed222 */223static void idpf_vector_stash(struct idpf_adapter *adapter, u16 *q_vector_idxs,224 struct idpf_vector_info *vec_info)225{226 int i, base = 0;227 u16 vec_idx;228 229 lockdep_assert_held(&adapter->vector_lock);230 231 if (!vec_info->num_curr_vecs)232 return;233 234 /* For default vports, no need to stash vector allocated from the235 * default pool onto the stack236 */237 if (vec_info->default_vport)238 base = IDPF_MIN_Q_VEC;239 240 for (i = vec_info->num_curr_vecs - 1; i >= base ; i--) {241 vec_idx = q_vector_idxs[i];242 idpf_vector_lifo_push(adapter, vec_idx);243 adapter->num_avail_msix++;244 }245}246 247/**248 * idpf_req_rel_vector_indexes - Request or release MSIX vector indexes249 * @adapter: driver specific private structure250 * @q_vector_idxs: vector index array251 * @vec_info: info related to the number of vectors252 *253 * This is the core function to distribute the MSIX vectors acquired from the254 * OS. It expects the caller to pass the number of vectors required and255 * also previously allocated. First, it stashes previously allocated vector256 * indexes on to the stack and then figures out if it can allocate requested257 * vectors. It can wait on acquiring the mutex lock. If the caller passes 0 as258 * requested vectors, then this function just stashes the already allocated259 * vectors and returns 0.260 *261 * Returns actual number of vectors allocated on success, error value on failure262 * If 0 is returned, implies the stack has no vectors to allocate which is also263 * a failure case for the caller264 */265int idpf_req_rel_vector_indexes(struct idpf_adapter *adapter,266 u16 *q_vector_idxs,267 struct idpf_vector_info *vec_info)268{269 u16 num_req_vecs, num_alloc_vecs = 0, max_vecs;270 struct idpf_vector_lifo *stack;271 int i, j, vecid;272 273 mutex_lock(&adapter->vector_lock);274 stack = &adapter->vector_stack;275 num_req_vecs = vec_info->num_req_vecs;276 277 /* Stash interrupt vector indexes onto the stack if required */278 idpf_vector_stash(adapter, q_vector_idxs, vec_info);279 280 if (!num_req_vecs)281 goto rel_lock;282 283 if (vec_info->default_vport) {284 /* As IDPF_MIN_Q_VEC per default vport is put aside in the285 * default pool of the stack, use them for default vports286 */287 j = vec_info->index * IDPF_MIN_Q_VEC + IDPF_MBX_Q_VEC;288 for (i = 0; i < IDPF_MIN_Q_VEC; i++) {289 q_vector_idxs[num_alloc_vecs++] = stack->vec_idx[j++];290 num_req_vecs--;291 }292 }293 294 /* Find if stack has enough vector to allocate */295 max_vecs = min(adapter->num_avail_msix, num_req_vecs);296 297 for (j = 0; j < max_vecs; j++) {298 vecid = idpf_vector_lifo_pop(adapter);299 q_vector_idxs[num_alloc_vecs++] = vecid;300 }301 adapter->num_avail_msix -= max_vecs;302 303rel_lock:304 mutex_unlock(&adapter->vector_lock);305 306 return num_alloc_vecs;307}308 309/**310 * idpf_intr_req - Request interrupt capabilities311 * @adapter: adapter to enable interrupts on312 *313 * Returns 0 on success, negative on failure314 */315int idpf_intr_req(struct idpf_adapter *adapter)316{317 u16 default_vports = idpf_get_default_vports(adapter);318 int num_q_vecs, total_vecs, num_vec_ids;319 int min_vectors, v_actual, err;320 unsigned int vector;321 u16 *vecids;322 323 total_vecs = idpf_get_reserved_vecs(adapter);324 num_q_vecs = total_vecs - IDPF_MBX_Q_VEC;325 326 err = idpf_send_alloc_vectors_msg(adapter, num_q_vecs);327 if (err) {328 dev_err(&adapter->pdev->dev,329 "Failed to allocate %d vectors: %d\n", num_q_vecs, err);330 331 return -EAGAIN;332 }333 334 min_vectors = IDPF_MBX_Q_VEC + IDPF_MIN_Q_VEC * default_vports;335 v_actual = pci_alloc_irq_vectors(adapter->pdev, min_vectors,336 total_vecs, PCI_IRQ_MSIX);337 if (v_actual < min_vectors) {338 dev_err(&adapter->pdev->dev, "Failed to allocate MSIX vectors: %d\n",339 v_actual);340 err = -EAGAIN;341 goto send_dealloc_vecs;342 }343 344 adapter->msix_entries = kcalloc(v_actual, sizeof(struct msix_entry),345 GFP_KERNEL);346 347 if (!adapter->msix_entries) {348 err = -ENOMEM;349 goto free_irq;350 }351 352 idpf_set_mb_vec_id(adapter);353 354 vecids = kcalloc(total_vecs, sizeof(u16), GFP_KERNEL);355 if (!vecids) {356 err = -ENOMEM;357 goto free_msix;358 }359 360 num_vec_ids = idpf_get_vec_ids(adapter, vecids, total_vecs,361 &adapter->req_vec_chunks->vchunks);362 if (num_vec_ids < v_actual) {363 err = -EINVAL;364 goto free_vecids;365 }366 367 for (vector = 0; vector < v_actual; vector++) {368 adapter->msix_entries[vector].entry = vecids[vector];369 adapter->msix_entries[vector].vector =370 pci_irq_vector(adapter->pdev, vector);371 }372 373 adapter->num_req_msix = total_vecs;374 adapter->num_msix_entries = v_actual;375 /* 'num_avail_msix' is used to distribute excess vectors to the vports376 * after considering the minimum vectors required per each default377 * vport378 */379 adapter->num_avail_msix = v_actual - min_vectors;380 381 /* Fill MSIX vector lifo stack with vector indexes */382 err = idpf_init_vector_stack(adapter);383 if (err)384 goto free_vecids;385 386 err = idpf_mb_intr_init(adapter);387 if (err)388 goto deinit_vec_stack;389 idpf_mb_irq_enable(adapter);390 kfree(vecids);391 392 return 0;393 394deinit_vec_stack:395 idpf_deinit_vector_stack(adapter);396free_vecids:397 kfree(vecids);398free_msix:399 kfree(adapter->msix_entries);400 adapter->msix_entries = NULL;401free_irq:402 pci_free_irq_vectors(adapter->pdev);403send_dealloc_vecs:404 idpf_send_dealloc_vectors_msg(adapter);405 406 return err;407}408 409/**410 * idpf_find_mac_filter - Search filter list for specific mac filter411 * @vconfig: Vport config structure412 * @macaddr: The MAC address413 *414 * Returns ptr to the filter object or NULL. Must be called while holding the415 * mac_filter_list_lock.416 **/417static struct idpf_mac_filter *idpf_find_mac_filter(struct idpf_vport_config *vconfig,418 const u8 *macaddr)419{420 struct idpf_mac_filter *f;421 422 if (!macaddr)423 return NULL;424 425 list_for_each_entry(f, &vconfig->user_config.mac_filter_list, list) {426 if (ether_addr_equal(macaddr, f->macaddr))427 return f;428 }429 430 return NULL;431}432 433/**434 * __idpf_del_mac_filter - Delete a MAC filter from the filter list435 * @vport_config: Vport config structure436 * @macaddr: The MAC address437 *438 * Returns 0 on success, error value on failure439 **/440static int __idpf_del_mac_filter(struct idpf_vport_config *vport_config,441 const u8 *macaddr)442{443 struct idpf_mac_filter *f;444 445 spin_lock_bh(&vport_config->mac_filter_list_lock);446 f = idpf_find_mac_filter(vport_config, macaddr);447 if (f) {448 list_del(&f->list);449 kfree(f);450 }451 spin_unlock_bh(&vport_config->mac_filter_list_lock);452 453 return 0;454}455 456/**457 * idpf_del_mac_filter - Delete a MAC filter from the filter list458 * @vport: Main vport structure459 * @np: Netdev private structure460 * @macaddr: The MAC address461 * @async: Don't wait for return message462 *463 * Removes filter from list and if interface is up, tells hardware about the464 * removed filter.465 **/466static int idpf_del_mac_filter(struct idpf_vport *vport,467 struct idpf_netdev_priv *np,468 const u8 *macaddr, bool async)469{470 struct idpf_vport_config *vport_config;471 struct idpf_mac_filter *f;472 473 vport_config = np->adapter->vport_config[np->vport_idx];474 475 spin_lock_bh(&vport_config->mac_filter_list_lock);476 f = idpf_find_mac_filter(vport_config, macaddr);477 if (f) {478 f->remove = true;479 } else {480 spin_unlock_bh(&vport_config->mac_filter_list_lock);481 482 return -EINVAL;483 }484 spin_unlock_bh(&vport_config->mac_filter_list_lock);485 486 if (np->state == __IDPF_VPORT_UP) {487 int err;488 489 err = idpf_add_del_mac_filters(vport, np, false, async);490 if (err)491 return err;492 }493 494 return __idpf_del_mac_filter(vport_config, macaddr);495}496 497/**498 * __idpf_add_mac_filter - Add mac filter helper function499 * @vport_config: Vport config structure500 * @macaddr: Address to add501 *502 * Takes mac_filter_list_lock spinlock to add new filter to list.503 */504static int __idpf_add_mac_filter(struct idpf_vport_config *vport_config,505 const u8 *macaddr)506{507 struct idpf_mac_filter *f;508 509 spin_lock_bh(&vport_config->mac_filter_list_lock);510 511 f = idpf_find_mac_filter(vport_config, macaddr);512 if (f) {513 f->remove = false;514 spin_unlock_bh(&vport_config->mac_filter_list_lock);515 516 return 0;517 }518 519 f = kzalloc(sizeof(*f), GFP_ATOMIC);520 if (!f) {521 spin_unlock_bh(&vport_config->mac_filter_list_lock);522 523 return -ENOMEM;524 }525 526 ether_addr_copy(f->macaddr, macaddr);527 list_add_tail(&f->list, &vport_config->user_config.mac_filter_list);528 f->add = true;529 530 spin_unlock_bh(&vport_config->mac_filter_list_lock);531 532 return 0;533}534 535/**536 * idpf_add_mac_filter - Add a mac filter to the filter list537 * @vport: Main vport structure538 * @np: Netdev private structure539 * @macaddr: The MAC address540 * @async: Don't wait for return message541 *542 * Returns 0 on success or error on failure. If interface is up, we'll also543 * send the virtchnl message to tell hardware about the filter.544 **/545static int idpf_add_mac_filter(struct idpf_vport *vport,546 struct idpf_netdev_priv *np,547 const u8 *macaddr, bool async)548{549 struct idpf_vport_config *vport_config;550 int err;551 552 vport_config = np->adapter->vport_config[np->vport_idx];553 err = __idpf_add_mac_filter(vport_config, macaddr);554 if (err)555 return err;556 557 if (np->state == __IDPF_VPORT_UP)558 err = idpf_add_del_mac_filters(vport, np, true, async);559 560 return err;561}562 563/**564 * idpf_del_all_mac_filters - Delete all MAC filters in list565 * @vport: main vport struct566 *567 * Takes mac_filter_list_lock spinlock. Deletes all filters568 */569static void idpf_del_all_mac_filters(struct idpf_vport *vport)570{571 struct idpf_vport_config *vport_config;572 struct idpf_mac_filter *f, *ftmp;573 574 vport_config = vport->adapter->vport_config[vport->idx];575 spin_lock_bh(&vport_config->mac_filter_list_lock);576 577 list_for_each_entry_safe(f, ftmp, &vport_config->user_config.mac_filter_list,578 list) {579 list_del(&f->list);580 kfree(f);581 }582 583 spin_unlock_bh(&vport_config->mac_filter_list_lock);584}585 586/**587 * idpf_restore_mac_filters - Re-add all MAC filters in list588 * @vport: main vport struct589 *590 * Takes mac_filter_list_lock spinlock. Sets add field to true for filters to591 * resync filters back to HW.592 */593static void idpf_restore_mac_filters(struct idpf_vport *vport)594{595 struct idpf_vport_config *vport_config;596 struct idpf_mac_filter *f;597 598 vport_config = vport->adapter->vport_config[vport->idx];599 spin_lock_bh(&vport_config->mac_filter_list_lock);600 601 list_for_each_entry(f, &vport_config->user_config.mac_filter_list, list)602 f->add = true;603 604 spin_unlock_bh(&vport_config->mac_filter_list_lock);605 606 idpf_add_del_mac_filters(vport, netdev_priv(vport->netdev),607 true, false);608}609 610/**611 * idpf_remove_mac_filters - Remove all MAC filters in list612 * @vport: main vport struct613 *614 * Takes mac_filter_list_lock spinlock. Sets remove field to true for filters615 * to remove filters in HW.616 */617static void idpf_remove_mac_filters(struct idpf_vport *vport)618{619 struct idpf_vport_config *vport_config;620 struct idpf_mac_filter *f;621 622 vport_config = vport->adapter->vport_config[vport->idx];623 spin_lock_bh(&vport_config->mac_filter_list_lock);624 625 list_for_each_entry(f, &vport_config->user_config.mac_filter_list, list)626 f->remove = true;627 628 spin_unlock_bh(&vport_config->mac_filter_list_lock);629 630 idpf_add_del_mac_filters(vport, netdev_priv(vport->netdev),631 false, false);632}633 634/**635 * idpf_deinit_mac_addr - deinitialize mac address for vport636 * @vport: main vport structure637 */638static void idpf_deinit_mac_addr(struct idpf_vport *vport)639{640 struct idpf_vport_config *vport_config;641 struct idpf_mac_filter *f;642 643 vport_config = vport->adapter->vport_config[vport->idx];644 645 spin_lock_bh(&vport_config->mac_filter_list_lock);646 647 f = idpf_find_mac_filter(vport_config, vport->default_mac_addr);648 if (f) {649 list_del(&f->list);650 kfree(f);651 }652 653 spin_unlock_bh(&vport_config->mac_filter_list_lock);654}655 656/**657 * idpf_init_mac_addr - initialize mac address for vport658 * @vport: main vport structure659 * @netdev: pointer to netdev struct associated with this vport660 */661static int idpf_init_mac_addr(struct idpf_vport *vport,662 struct net_device *netdev)663{664 struct idpf_netdev_priv *np = netdev_priv(netdev);665 struct idpf_adapter *adapter = vport->adapter;666 int err;667 668 if (is_valid_ether_addr(vport->default_mac_addr)) {669 eth_hw_addr_set(netdev, vport->default_mac_addr);670 ether_addr_copy(netdev->perm_addr, vport->default_mac_addr);671 672 return idpf_add_mac_filter(vport, np, vport->default_mac_addr,673 false);674 }675 676 if (!idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS,677 VIRTCHNL2_CAP_MACFILTER)) {678 dev_err(&adapter->pdev->dev,679 "MAC address is not provided and capability is not set\n");680 681 return -EINVAL;682 }683 684 eth_hw_addr_random(netdev);685 err = idpf_add_mac_filter(vport, np, netdev->dev_addr, false);686 if (err)687 return err;688 689 dev_info(&adapter->pdev->dev, "Invalid MAC address %pM, using random %pM\n",690 vport->default_mac_addr, netdev->dev_addr);691 ether_addr_copy(vport->default_mac_addr, netdev->dev_addr);692 693 return 0;694}695 696/**697 * idpf_cfg_netdev - Allocate, configure and register a netdev698 * @vport: main vport structure699 *700 * Returns 0 on success, negative value on failure.701 */702static int idpf_cfg_netdev(struct idpf_vport *vport)703{704 struct idpf_adapter *adapter = vport->adapter;705 struct idpf_vport_config *vport_config;706 netdev_features_t dflt_features;707 netdev_features_t offloads = 0;708 struct idpf_netdev_priv *np;709 struct net_device *netdev;710 u16 idx = vport->idx;711 int err;712 713 vport_config = adapter->vport_config[idx];714 715 /* It's possible we already have a netdev allocated and registered for716 * this vport717 */718 if (test_bit(IDPF_VPORT_REG_NETDEV, vport_config->flags)) {719 netdev = adapter->netdevs[idx];720 np = netdev_priv(netdev);721 np->vport = vport;722 np->vport_idx = vport->idx;723 np->vport_id = vport->vport_id;724 vport->netdev = netdev;725 726 return idpf_init_mac_addr(vport, netdev);727 }728 729 netdev = alloc_etherdev_mqs(sizeof(struct idpf_netdev_priv),730 vport_config->max_q.max_txq,731 vport_config->max_q.max_rxq);732 if (!netdev)733 return -ENOMEM;734 735 vport->netdev = netdev;736 np = netdev_priv(netdev);737 np->vport = vport;738 np->adapter = adapter;739 np->vport_idx = vport->idx;740 np->vport_id = vport->vport_id;741 742 spin_lock_init(&np->stats_lock);743 744 err = idpf_init_mac_addr(vport, netdev);745 if (err) {746 free_netdev(vport->netdev);747 vport->netdev = NULL;748 749 return err;750 }751 752 /* assign netdev_ops */753 netdev->netdev_ops = &idpf_netdev_ops;754 755 /* setup watchdog timeout value to be 5 second */756 netdev->watchdog_timeo = 5 * HZ;757 758 netdev->dev_port = idx;759 760 /* configure default MTU size */761 netdev->min_mtu = ETH_MIN_MTU;762 netdev->max_mtu = vport->max_mtu;763 764 dflt_features = NETIF_F_SG |765 NETIF_F_HIGHDMA;766 767 if (idpf_is_cap_ena_all(adapter, IDPF_RSS_CAPS, IDPF_CAP_RSS))768 dflt_features |= NETIF_F_RXHASH;769 if (idpf_is_cap_ena_all(adapter, IDPF_CSUM_CAPS, IDPF_CAP_RX_CSUM_L4V4))770 dflt_features |= NETIF_F_IP_CSUM;771 if (idpf_is_cap_ena_all(adapter, IDPF_CSUM_CAPS, IDPF_CAP_RX_CSUM_L4V6))772 dflt_features |= NETIF_F_IPV6_CSUM;773 if (idpf_is_cap_ena(adapter, IDPF_CSUM_CAPS, IDPF_CAP_RX_CSUM))774 dflt_features |= NETIF_F_RXCSUM;775 if (idpf_is_cap_ena_all(adapter, IDPF_CSUM_CAPS, IDPF_CAP_SCTP_CSUM))776 dflt_features |= NETIF_F_SCTP_CRC;777 778 if (idpf_is_cap_ena(adapter, IDPF_SEG_CAPS, VIRTCHNL2_CAP_SEG_IPV4_TCP))779 dflt_features |= NETIF_F_TSO;780 if (idpf_is_cap_ena(adapter, IDPF_SEG_CAPS, VIRTCHNL2_CAP_SEG_IPV6_TCP))781 dflt_features |= NETIF_F_TSO6;782 if (idpf_is_cap_ena_all(adapter, IDPF_SEG_CAPS,783 VIRTCHNL2_CAP_SEG_IPV4_UDP |784 VIRTCHNL2_CAP_SEG_IPV6_UDP))785 dflt_features |= NETIF_F_GSO_UDP_L4;786 if (idpf_is_cap_ena_all(adapter, IDPF_RSC_CAPS, IDPF_CAP_RSC))787 offloads |= NETIF_F_GRO_HW;788 /* advertise to stack only if offloads for encapsulated packets is789 * supported790 */791 if (idpf_is_cap_ena(vport->adapter, IDPF_SEG_CAPS,792 VIRTCHNL2_CAP_SEG_TX_SINGLE_TUNNEL)) {793 offloads |= NETIF_F_GSO_UDP_TUNNEL |794 NETIF_F_GSO_GRE |795 NETIF_F_GSO_GRE_CSUM |796 NETIF_F_GSO_PARTIAL |797 NETIF_F_GSO_UDP_TUNNEL_CSUM |798 NETIF_F_GSO_IPXIP4 |799 NETIF_F_GSO_IPXIP6 |800 0;801 802 if (!idpf_is_cap_ena_all(vport->adapter, IDPF_CSUM_CAPS,803 IDPF_CAP_TUNNEL_TX_CSUM))804 netdev->gso_partial_features |=805 NETIF_F_GSO_UDP_TUNNEL_CSUM;806 807 netdev->gso_partial_features |= NETIF_F_GSO_GRE_CSUM;808 offloads |= NETIF_F_TSO_MANGLEID;809 }810 if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_LOOPBACK))811 offloads |= NETIF_F_LOOPBACK;812 813 netdev->features |= dflt_features;814 netdev->hw_features |= dflt_features | offloads;815 netdev->hw_enc_features |= dflt_features | offloads;816 idpf_set_ethtool_ops(netdev);817 SET_NETDEV_DEV(netdev, &adapter->pdev->dev);818 819 /* carrier off on init to avoid Tx hangs */820 netif_carrier_off(netdev);821 822 /* make sure transmit queues start off as stopped */823 netif_tx_stop_all_queues(netdev);824 825 /* The vport can be arbitrarily released so we need to also track826 * netdevs in the adapter struct827 */828 adapter->netdevs[idx] = netdev;829 830 return 0;831}832 833/**834 * idpf_get_free_slot - get the next non-NULL location index in array835 * @adapter: adapter in which to look for a free vport slot836 */837static int idpf_get_free_slot(struct idpf_adapter *adapter)838{839 unsigned int i;840 841 for (i = 0; i < adapter->max_vports; i++) {842 if (!adapter->vports[i])843 return i;844 }845 846 return IDPF_NO_FREE_SLOT;847}848 849/**850 * idpf_remove_features - Turn off feature configs851 * @vport: virtual port structure852 */853static void idpf_remove_features(struct idpf_vport *vport)854{855 struct idpf_adapter *adapter = vport->adapter;856 857 if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_MACFILTER))858 idpf_remove_mac_filters(vport);859}860 861/**862 * idpf_vport_stop - Disable a vport863 * @vport: vport to disable864 */865static void idpf_vport_stop(struct idpf_vport *vport)866{867 struct idpf_netdev_priv *np = netdev_priv(vport->netdev);868 869 if (np->state <= __IDPF_VPORT_DOWN)870 return;871 872 netif_carrier_off(vport->netdev);873 netif_tx_disable(vport->netdev);874 875 idpf_send_disable_vport_msg(vport);876 idpf_send_disable_queues_msg(vport);877 idpf_send_map_unmap_queue_vector_msg(vport, false);878 /* Normally we ask for queues in create_vport, but if the number of879 * initially requested queues have changed, for example via ethtool880 * set channels, we do delete queues and then add the queues back881 * instead of deleting and reallocating the vport.882 */883 if (test_and_clear_bit(IDPF_VPORT_DEL_QUEUES, vport->flags))884 idpf_send_delete_queues_msg(vport);885 886 idpf_remove_features(vport);887 888 vport->link_up = false;889 idpf_vport_intr_deinit(vport);890 idpf_vport_queues_rel(vport);891 idpf_vport_intr_rel(vport);892 np->state = __IDPF_VPORT_DOWN;893}894 895/**896 * idpf_stop - Disables a network interface897 * @netdev: network interface device structure898 *899 * The stop entry point is called when an interface is de-activated by the OS,900 * and the netdevice enters the DOWN state. The hardware is still under the901 * driver's control, but the netdev interface is disabled.902 *903 * Returns success only - not allowed to fail904 */905static int idpf_stop(struct net_device *netdev)906{907 struct idpf_netdev_priv *np = netdev_priv(netdev);908 struct idpf_vport *vport;909 910 if (test_bit(IDPF_REMOVE_IN_PROG, np->adapter->flags))911 return 0;912 913 idpf_vport_ctrl_lock(netdev);914 vport = idpf_netdev_to_vport(netdev);915 916 idpf_vport_stop(vport);917 918 idpf_vport_ctrl_unlock(netdev);919 920 return 0;921}922 923/**924 * idpf_decfg_netdev - Unregister the netdev925 * @vport: vport for which netdev to be unregistered926 */927static void idpf_decfg_netdev(struct idpf_vport *vport)928{929 struct idpf_adapter *adapter = vport->adapter;930 931 kfree(vport->rx_ptype_lkup);932 vport->rx_ptype_lkup = NULL;933 934 unregister_netdev(vport->netdev);935 free_netdev(vport->netdev);936 vport->netdev = NULL;937 938 adapter->netdevs[vport->idx] = NULL;939}940 941/**942 * idpf_vport_rel - Delete a vport and free its resources943 * @vport: the vport being removed944 */945static void idpf_vport_rel(struct idpf_vport *vport)946{947 struct idpf_adapter *adapter = vport->adapter;948 struct idpf_vport_config *vport_config;949 struct idpf_vector_info vec_info;950 struct idpf_rss_data *rss_data;951 struct idpf_vport_max_q max_q;952 u16 idx = vport->idx;953 954 vport_config = adapter->vport_config[vport->idx];955 idpf_deinit_rss(vport);956 rss_data = &vport_config->user_config.rss_data;957 kfree(rss_data->rss_key);958 rss_data->rss_key = NULL;959 960 idpf_send_destroy_vport_msg(vport);961 962 /* Release all max queues allocated to the adapter's pool */963 max_q.max_rxq = vport_config->max_q.max_rxq;964 max_q.max_txq = vport_config->max_q.max_txq;965 max_q.max_bufq = vport_config->max_q.max_bufq;966 max_q.max_complq = vport_config->max_q.max_complq;967 idpf_vport_dealloc_max_qs(adapter, &max_q);968 969 /* Release all the allocated vectors on the stack */970 vec_info.num_req_vecs = 0;971 vec_info.num_curr_vecs = vport->num_q_vectors;972 vec_info.default_vport = vport->default_vport;973 974 idpf_req_rel_vector_indexes(adapter, vport->q_vector_idxs, &vec_info);975 976 kfree(vport->q_vector_idxs);977 vport->q_vector_idxs = NULL;978 979 kfree(adapter->vport_params_recvd[idx]);980 adapter->vport_params_recvd[idx] = NULL;981 kfree(adapter->vport_params_reqd[idx]);982 adapter->vport_params_reqd[idx] = NULL;983 if (adapter->vport_config[idx]) {984 kfree(adapter->vport_config[idx]->req_qs_chunks);985 adapter->vport_config[idx]->req_qs_chunks = NULL;986 }987 kfree(vport);988 adapter->num_alloc_vports--;989}990 991/**992 * idpf_vport_dealloc - cleanup and release a given vport993 * @vport: pointer to idpf vport structure994 *995 * returns nothing996 */997static void idpf_vport_dealloc(struct idpf_vport *vport)998{999 struct idpf_adapter *adapter = vport->adapter;1000 unsigned int i = vport->idx;1001 1002 idpf_deinit_mac_addr(vport);1003 idpf_vport_stop(vport);1004 1005 if (!test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags))1006 idpf_decfg_netdev(vport);1007 if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags))1008 idpf_del_all_mac_filters(vport);1009 1010 if (adapter->netdevs[i]) {1011 struct idpf_netdev_priv *np = netdev_priv(adapter->netdevs[i]);1012 1013 np->vport = NULL;1014 }1015 1016 idpf_vport_rel(vport);1017 1018 adapter->vports[i] = NULL;1019 adapter->next_vport = idpf_get_free_slot(adapter);1020}1021 1022/**1023 * idpf_is_hsplit_supported - check whether the header split is supported1024 * @vport: virtual port to check the capability for1025 *1026 * Return: true if it's supported by the HW/FW, false if not.1027 */1028static bool idpf_is_hsplit_supported(const struct idpf_vport *vport)1029{1030 return idpf_is_queue_model_split(vport->rxq_model) &&1031 idpf_is_cap_ena_all(vport->adapter, IDPF_HSPLIT_CAPS,1032 IDPF_CAP_HSPLIT);1033}1034 1035/**1036 * idpf_vport_get_hsplit - get the current header split feature state1037 * @vport: virtual port to query the state for1038 *1039 * Return: ``ETHTOOL_TCP_DATA_SPLIT_UNKNOWN`` if not supported,1040 * ``ETHTOOL_TCP_DATA_SPLIT_DISABLED`` if disabled,1041 * ``ETHTOOL_TCP_DATA_SPLIT_ENABLED`` if active.1042 */1043u8 idpf_vport_get_hsplit(const struct idpf_vport *vport)1044{1045 const struct idpf_vport_user_config_data *config;1046 1047 if (!idpf_is_hsplit_supported(vport))1048 return ETHTOOL_TCP_DATA_SPLIT_UNKNOWN;1049 1050 config = &vport->adapter->vport_config[vport->idx]->user_config;1051 1052 return test_bit(__IDPF_USER_FLAG_HSPLIT, config->user_flags) ?1053 ETHTOOL_TCP_DATA_SPLIT_ENABLED :1054 ETHTOOL_TCP_DATA_SPLIT_DISABLED;1055}1056 1057/**1058 * idpf_vport_set_hsplit - enable or disable header split on a given vport1059 * @vport: virtual port to configure1060 * @val: Ethtool flag controlling the header split state1061 *1062 * Return: true on success, false if not supported by the HW.1063 */1064bool idpf_vport_set_hsplit(const struct idpf_vport *vport, u8 val)1065{1066 struct idpf_vport_user_config_data *config;1067 1068 if (!idpf_is_hsplit_supported(vport))1069 return val == ETHTOOL_TCP_DATA_SPLIT_UNKNOWN;1070 1071 config = &vport->adapter->vport_config[vport->idx]->user_config;1072 1073 switch (val) {1074 case ETHTOOL_TCP_DATA_SPLIT_UNKNOWN:1075 /* Default is to enable */1076 case ETHTOOL_TCP_DATA_SPLIT_ENABLED:1077 __set_bit(__IDPF_USER_FLAG_HSPLIT, config->user_flags);1078 return true;1079 case ETHTOOL_TCP_DATA_SPLIT_DISABLED:1080 __clear_bit(__IDPF_USER_FLAG_HSPLIT, config->user_flags);1081 return true;1082 default:1083 return false;1084 }1085}1086 1087/**1088 * idpf_vport_alloc - Allocates the next available struct vport in the adapter1089 * @adapter: board private structure1090 * @max_q: vport max queue info1091 *1092 * returns a pointer to a vport on success, NULL on failure.1093 */1094static struct idpf_vport *idpf_vport_alloc(struct idpf_adapter *adapter,1095 struct idpf_vport_max_q *max_q)1096{1097 struct idpf_rss_data *rss_data;1098 u16 idx = adapter->next_vport;1099 struct idpf_vport *vport;1100 u16 num_max_q;1101 1102 if (idx == IDPF_NO_FREE_SLOT)1103 return NULL;1104 1105 vport = kzalloc(sizeof(*vport), GFP_KERNEL);1106 if (!vport)1107 return vport;1108 1109 if (!adapter->vport_config[idx]) {1110 struct idpf_vport_config *vport_config;1111 1112 vport_config = kzalloc(sizeof(*vport_config), GFP_KERNEL);1113 if (!vport_config) {1114 kfree(vport);1115 1116 return NULL;1117 }1118 1119 adapter->vport_config[idx] = vport_config;1120 }1121 1122 vport->idx = idx;1123 vport->adapter = adapter;1124 vport->compln_clean_budget = IDPF_TX_COMPLQ_CLEAN_BUDGET;1125 vport->default_vport = adapter->num_alloc_vports <1126 idpf_get_default_vports(adapter);1127 1128 num_max_q = max(max_q->max_txq, max_q->max_rxq);1129 vport->q_vector_idxs = kcalloc(num_max_q, sizeof(u16), GFP_KERNEL);1130 if (!vport->q_vector_idxs) {1131 kfree(vport);1132 1133 return NULL;1134 }1135 idpf_vport_init(vport, max_q);1136 1137 /* This alloc is done separate from the LUT because it's not strictly1138 * dependent on how many queues we have. If we change number of queues1139 * and soft reset we'll need a new LUT but the key can remain the same1140 * for as long as the vport exists.1141 */1142 rss_data = &adapter->vport_config[idx]->user_config.rss_data;1143 rss_data->rss_key = kzalloc(rss_data->rss_key_size, GFP_KERNEL);1144 if (!rss_data->rss_key) {1145 kfree(vport);1146 1147 return NULL;1148 }1149 /* Initialize default rss key */1150 netdev_rss_key_fill((void *)rss_data->rss_key, rss_data->rss_key_size);1151 1152 /* fill vport slot in the adapter struct */1153 adapter->vports[idx] = vport;1154 adapter->vport_ids[idx] = idpf_get_vport_id(vport);1155 1156 adapter->num_alloc_vports++;1157 /* prepare adapter->next_vport for next use */1158 adapter->next_vport = idpf_get_free_slot(adapter);1159 1160 return vport;1161}1162 1163/**1164 * idpf_get_stats64 - get statistics for network device structure1165 * @netdev: network interface device structure1166 * @stats: main device statistics structure1167 */1168static void idpf_get_stats64(struct net_device *netdev,1169 struct rtnl_link_stats64 *stats)1170{1171 struct idpf_netdev_priv *np = netdev_priv(netdev);1172 1173 spin_lock_bh(&np->stats_lock);1174 *stats = np->netstats;1175 spin_unlock_bh(&np->stats_lock);1176}1177 1178/**1179 * idpf_statistics_task - Delayed task to get statistics over mailbox1180 * @work: work_struct handle to our data1181 */1182void idpf_statistics_task(struct work_struct *work)1183{1184 struct idpf_adapter *adapter;1185 int i;1186 1187 adapter = container_of(work, struct idpf_adapter, stats_task.work);1188 1189 for (i = 0; i < adapter->max_vports; i++) {1190 struct idpf_vport *vport = adapter->vports[i];1191 1192 if (vport && !test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags))1193 idpf_send_get_stats_msg(vport);1194 }1195 1196 queue_delayed_work(adapter->stats_wq, &adapter->stats_task,1197 msecs_to_jiffies(10000));1198}1199 1200/**1201 * idpf_mbx_task - Delayed task to handle mailbox responses1202 * @work: work_struct handle1203 */1204void idpf_mbx_task(struct work_struct *work)1205{1206 struct idpf_adapter *adapter;1207 1208 adapter = container_of(work, struct idpf_adapter, mbx_task.work);1209 1210 if (test_bit(IDPF_MB_INTR_MODE, adapter->flags))1211 idpf_mb_irq_enable(adapter);1212 else1213 queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task,1214 msecs_to_jiffies(300));1215 1216 idpf_recv_mb_msg(adapter);1217}1218 1219/**1220 * idpf_service_task - Delayed task for handling mailbox responses1221 * @work: work_struct handle to our data1222 *1223 */1224void idpf_service_task(struct work_struct *work)1225{1226 struct idpf_adapter *adapter;1227 1228 adapter = container_of(work, struct idpf_adapter, serv_task.work);1229 1230 if (idpf_is_reset_detected(adapter) &&1231 !idpf_is_reset_in_prog(adapter) &&1232 !test_bit(IDPF_REMOVE_IN_PROG, adapter->flags)) {1233 dev_info(&adapter->pdev->dev, "HW reset detected\n");1234 set_bit(IDPF_HR_FUNC_RESET, adapter->flags);1235 queue_delayed_work(adapter->vc_event_wq,1236 &adapter->vc_event_task,1237 msecs_to_jiffies(10));1238 }1239 1240 queue_delayed_work(adapter->serv_wq, &adapter->serv_task,1241 msecs_to_jiffies(300));1242}1243 1244/**1245 * idpf_restore_features - Restore feature configs1246 * @vport: virtual port structure1247 */1248static void idpf_restore_features(struct idpf_vport *vport)1249{1250 struct idpf_adapter *adapter = vport->adapter;1251 1252 if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_MACFILTER))1253 idpf_restore_mac_filters(vport);1254}1255 1256/**1257 * idpf_set_real_num_queues - set number of queues for netdev1258 * @vport: virtual port structure1259 *1260 * Returns 0 on success, negative on failure.1261 */1262static int idpf_set_real_num_queues(struct idpf_vport *vport)1263{1264 int err;1265 1266 err = netif_set_real_num_rx_queues(vport->netdev, vport->num_rxq);1267 if (err)1268 return err;1269 1270 return netif_set_real_num_tx_queues(vport->netdev, vport->num_txq);1271}1272 1273/**1274 * idpf_up_complete - Complete interface up sequence1275 * @vport: virtual port structure1276 *1277 * Returns 0 on success, negative on failure.1278 */1279static int idpf_up_complete(struct idpf_vport *vport)1280{1281 struct idpf_netdev_priv *np = netdev_priv(vport->netdev);1282 1283 if (vport->link_up && !netif_carrier_ok(vport->netdev)) {1284 netif_carrier_on(vport->netdev);1285 netif_tx_start_all_queues(vport->netdev);1286 }1287 1288 np->state = __IDPF_VPORT_UP;1289 1290 return 0;1291}1292 1293/**1294 * idpf_rx_init_buf_tail - Write initial buffer ring tail value1295 * @vport: virtual port struct1296 */1297static void idpf_rx_init_buf_tail(struct idpf_vport *vport)1298{1299 int i, j;1300 1301 for (i = 0; i < vport->num_rxq_grp; i++) {1302 struct idpf_rxq_group *grp = &vport->rxq_grps[i];1303 1304 if (idpf_is_queue_model_split(vport->rxq_model)) {1305 for (j = 0; j < vport->num_bufqs_per_qgrp; j++) {1306 const struct idpf_buf_queue *q =1307 &grp->splitq.bufq_sets[j].bufq;1308 1309 writel(q->next_to_alloc, q->tail);1310 }1311 } else {1312 for (j = 0; j < grp->singleq.num_rxq; j++) {1313 const struct idpf_rx_queue *q =1314 grp->singleq.rxqs[j];1315 1316 writel(q->next_to_alloc, q->tail);1317 }1318 }1319 }1320}1321 1322/**1323 * idpf_vport_open - Bring up a vport1324 * @vport: vport to bring up1325 */1326static int idpf_vport_open(struct idpf_vport *vport)1327{1328 struct idpf_netdev_priv *np = netdev_priv(vport->netdev);1329 struct idpf_adapter *adapter = vport->adapter;1330 struct idpf_vport_config *vport_config;1331 int err;1332 1333 if (np->state != __IDPF_VPORT_DOWN)1334 return -EBUSY;1335 1336 /* we do not allow interface up just yet */1337 netif_carrier_off(vport->netdev);1338 1339 err = idpf_vport_intr_alloc(vport);1340 if (err) {1341 dev_err(&adapter->pdev->dev, "Failed to allocate interrupts for vport %u: %d\n",1342 vport->vport_id, err);1343 return err;1344 }1345 1346 err = idpf_vport_queues_alloc(vport);1347 if (err)1348 goto intr_rel;1349 1350 err = idpf_vport_queue_ids_init(vport);1351 if (err) {1352 dev_err(&adapter->pdev->dev, "Failed to initialize queue ids for vport %u: %d\n",1353 vport->vport_id, err);1354 goto queues_rel;1355 }1356 1357 err = idpf_vport_intr_init(vport);1358 if (err) {1359 dev_err(&adapter->pdev->dev, "Failed to initialize interrupts for vport %u: %d\n",1360 vport->vport_id, err);1361 goto queues_rel;1362 }1363 1364 err = idpf_rx_bufs_init_all(vport);1365 if (err) {1366 dev_err(&adapter->pdev->dev, "Failed to initialize RX buffers for vport %u: %d\n",1367 vport->vport_id, err);1368 goto queues_rel;1369 }1370 1371 err = idpf_queue_reg_init(vport);1372 if (err) {1373 dev_err(&adapter->pdev->dev, "Failed to initialize queue registers for vport %u: %d\n",1374 vport->vport_id, err);1375 goto queues_rel;1376 }1377 1378 idpf_rx_init_buf_tail(vport);1379 idpf_vport_intr_ena(vport);1380 1381 err = idpf_send_config_queues_msg(vport);1382 if (err) {1383 dev_err(&adapter->pdev->dev, "Failed to configure queues for vport %u, %d\n",1384 vport->vport_id, err);1385 goto intr_deinit;1386 }1387 1388 err = idpf_send_map_unmap_queue_vector_msg(vport, true);1389 if (err) {1390 dev_err(&adapter->pdev->dev, "Failed to map queue vectors for vport %u: %d\n",1391 vport->vport_id, err);1392 goto intr_deinit;1393 }1394 1395 err = idpf_send_enable_queues_msg(vport);1396 if (err) {1397 dev_err(&adapter->pdev->dev, "Failed to enable queues for vport %u: %d\n",1398 vport->vport_id, err);1399 goto unmap_queue_vectors;1400 }1401 1402 err = idpf_send_enable_vport_msg(vport);1403 if (err) {1404 dev_err(&adapter->pdev->dev, "Failed to enable vport %u: %d\n",1405 vport->vport_id, err);1406 err = -EAGAIN;1407 goto disable_queues;1408 }1409 1410 idpf_restore_features(vport);1411 1412 vport_config = adapter->vport_config[vport->idx];1413 if (vport_config->user_config.rss_data.rss_lut)1414 err = idpf_config_rss(vport);1415 else1416 err = idpf_init_rss(vport);1417 if (err) {1418 dev_err(&adapter->pdev->dev, "Failed to initialize RSS for vport %u: %d\n",1419 vport->vport_id, err);1420 goto disable_vport;1421 }1422 1423 err = idpf_up_complete(vport);1424 if (err) {1425 dev_err(&adapter->pdev->dev, "Failed to complete interface up for vport %u: %d\n",1426 vport->vport_id, err);1427 goto deinit_rss;1428 }1429 1430 return 0;1431 1432deinit_rss:1433 idpf_deinit_rss(vport);1434disable_vport:1435 idpf_send_disable_vport_msg(vport);1436disable_queues:1437 idpf_send_disable_queues_msg(vport);1438unmap_queue_vectors:1439 idpf_send_map_unmap_queue_vector_msg(vport, false);1440intr_deinit:1441 idpf_vport_intr_deinit(vport);1442queues_rel:1443 idpf_vport_queues_rel(vport);1444intr_rel:1445 idpf_vport_intr_rel(vport);1446 1447 return err;1448}1449 1450/**1451 * idpf_init_task - Delayed initialization task1452 * @work: work_struct handle to our data1453 *1454 * Init task finishes up pending work started in probe. Due to the asynchronous1455 * nature in which the device communicates with hardware, we may have to wait1456 * several milliseconds to get a response. Instead of busy polling in probe,1457 * pulling it out into a delayed work task prevents us from bogging down the1458 * whole system waiting for a response from hardware.1459 */1460void idpf_init_task(struct work_struct *work)1461{1462 struct idpf_vport_config *vport_config;1463 struct idpf_vport_max_q max_q;1464 struct idpf_adapter *adapter;1465 struct idpf_netdev_priv *np;1466 struct idpf_vport *vport;1467 u16 num_default_vports;1468 struct pci_dev *pdev;1469 bool default_vport;1470 int index, err;1471 1472 adapter = container_of(work, struct idpf_adapter, init_task.work);1473 1474 num_default_vports = idpf_get_default_vports(adapter);1475 if (adapter->num_alloc_vports < num_default_vports)1476 default_vport = true;1477 else1478 default_vport = false;1479 1480 err = idpf_vport_alloc_max_qs(adapter, &max_q);1481 if (err)1482 goto unwind_vports;1483 1484 err = idpf_send_create_vport_msg(adapter, &max_q);1485 if (err) {1486 idpf_vport_dealloc_max_qs(adapter, &max_q);1487 goto unwind_vports;1488 }1489 1490 pdev = adapter->pdev;1491 vport = idpf_vport_alloc(adapter, &max_q);1492 if (!vport) {1493 err = -EFAULT;1494 dev_err(&pdev->dev, "failed to allocate vport: %d\n",1495 err);1496 idpf_vport_dealloc_max_qs(adapter, &max_q);1497 goto unwind_vports;1498 }1499 1500 index = vport->idx;1501 vport_config = adapter->vport_config[index];1502 1503 init_waitqueue_head(&vport->sw_marker_wq);1504 1505 spin_lock_init(&vport_config->mac_filter_list_lock);1506 1507 INIT_LIST_HEAD(&vport_config->user_config.mac_filter_list);1508 1509 err = idpf_check_supported_desc_ids(vport);1510 if (err) {1511 dev_err(&pdev->dev, "failed to get required descriptor ids\n");1512 goto cfg_netdev_err;1513 }1514 1515 if (idpf_cfg_netdev(vport))1516 goto cfg_netdev_err;1517 1518 err = idpf_send_get_rx_ptype_msg(vport);1519 if (err)1520 goto handle_err;1521 1522 /* Once state is put into DOWN, driver is ready for dev_open */1523 np = netdev_priv(vport->netdev);1524 np->state = __IDPF_VPORT_DOWN;1525 if (test_and_clear_bit(IDPF_VPORT_UP_REQUESTED, vport_config->flags))1526 idpf_vport_open(vport);1527 1528 /* Spawn and return 'idpf_init_task' work queue until all the1529 * default vports are created1530 */1531 if (adapter->num_alloc_vports < num_default_vports) {1532 queue_delayed_work(adapter->init_wq, &adapter->init_task,1533 msecs_to_jiffies(5 * (adapter->pdev->devfn & 0x07)));1534 1535 return;1536 }1537 1538 for (index = 0; index < adapter->max_vports; index++) {1539 if (adapter->netdevs[index] &&1540 !test_bit(IDPF_VPORT_REG_NETDEV,1541 adapter->vport_config[index]->flags)) {1542 register_netdev(adapter->netdevs[index]);1543 set_bit(IDPF_VPORT_REG_NETDEV,1544 adapter->vport_config[index]->flags);1545 }1546 }1547 1548 /* As all the required vports are created, clear the reset flag1549 * unconditionally here in case we were in reset and the link was down.1550 */1551 clear_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);1552 /* Start the statistics task now */1553 queue_delayed_work(adapter->stats_wq, &adapter->stats_task,1554 msecs_to_jiffies(10 * (pdev->devfn & 0x07)));1555 1556 return;1557 1558handle_err:1559 idpf_decfg_netdev(vport);1560cfg_netdev_err:1561 idpf_vport_rel(vport);1562 adapter->vports[index] = NULL;1563unwind_vports:1564 if (default_vport) {1565 for (index = 0; index < adapter->max_vports; index++) {1566 if (adapter->vports[index])1567 idpf_vport_dealloc(adapter->vports[index]);1568 }1569 }1570 clear_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);1571}1572 1573/**1574 * idpf_sriov_ena - Enable or change number of VFs1575 * @adapter: private data struct1576 * @num_vfs: number of VFs to allocate1577 */1578static int idpf_sriov_ena(struct idpf_adapter *adapter, int num_vfs)1579{1580 struct device *dev = &adapter->pdev->dev;1581 int err;1582 1583 err = idpf_send_set_sriov_vfs_msg(adapter, num_vfs);1584 if (err) {1585 dev_err(dev, "Failed to allocate VFs: %d\n", err);1586 1587 return err;1588 }1589 1590 err = pci_enable_sriov(adapter->pdev, num_vfs);1591 if (err) {1592 idpf_send_set_sriov_vfs_msg(adapter, 0);1593 dev_err(dev, "Failed to enable SR-IOV: %d\n", err);1594 1595 return err;1596 }1597 1598 adapter->num_vfs = num_vfs;1599 1600 return num_vfs;1601}1602 1603/**1604 * idpf_sriov_configure - Configure the requested VFs1605 * @pdev: pointer to a pci_dev structure1606 * @num_vfs: number of vfs to allocate1607 *1608 * Enable or change the number of VFs. Called when the user updates the number1609 * of VFs in sysfs.1610 **/1611int idpf_sriov_configure(struct pci_dev *pdev, int num_vfs)1612{1613 struct idpf_adapter *adapter = pci_get_drvdata(pdev);1614 1615 if (!idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_SRIOV)) {1616 dev_info(&pdev->dev, "SR-IOV is not supported on this device\n");1617 1618 return -EOPNOTSUPP;1619 }1620 1621 if (num_vfs)1622 return idpf_sriov_ena(adapter, num_vfs);1623 1624 if (pci_vfs_assigned(pdev)) {1625 dev_warn(&pdev->dev, "Unable to free VFs because some are assigned to VMs\n");1626 1627 return -EBUSY;1628 }1629 1630 pci_disable_sriov(adapter->pdev);1631 idpf_send_set_sriov_vfs_msg(adapter, 0);1632 adapter->num_vfs = 0;1633 1634 return 0;1635}1636 1637/**1638 * idpf_deinit_task - Device deinit routine1639 * @adapter: Driver specific private structure1640 *1641 * Extended remove logic which will be used for1642 * hard reset as well1643 */1644void idpf_deinit_task(struct idpf_adapter *adapter)1645{1646 unsigned int i;1647 1648 /* Wait until the init_task is done else this thread might release1649 * the resources first and the other thread might end up in a bad state1650 */1651 cancel_delayed_work_sync(&adapter->init_task);1652 1653 if (!adapter->vports)1654 return;1655 1656 cancel_delayed_work_sync(&adapter->stats_task);1657 1658 for (i = 0; i < adapter->max_vports; i++) {1659 if (adapter->vports[i])1660 idpf_vport_dealloc(adapter->vports[i]);1661 }1662}1663 1664/**1665 * idpf_check_reset_complete - check that reset is complete1666 * @hw: pointer to hw struct1667 * @reset_reg: struct with reset registers1668 *1669 * Returns 0 if device is ready to use, or -EBUSY if it's in reset.1670 **/1671static int idpf_check_reset_complete(struct idpf_hw *hw,1672 struct idpf_reset_reg *reset_reg)1673{1674 struct idpf_adapter *adapter = hw->back;1675 int i;1676 1677 for (i = 0; i < 2000; i++) {1678 u32 reg_val = readl(reset_reg->rstat);1679 1680 /* 0xFFFFFFFF might be read if other side hasn't cleared the1681 * register for us yet and 0xFFFFFFFF is not a valid value for1682 * the register, so treat that as invalid.1683 */1684 if (reg_val != 0xFFFFFFFF && (reg_val & reset_reg->rstat_m))1685 return 0;1686 1687 usleep_range(5000, 10000);1688 }1689 1690 dev_warn(&adapter->pdev->dev, "Device reset timeout!\n");1691 /* Clear the reset flag unconditionally here since the reset1692 * technically isn't in progress anymore from the driver's perspective1693 */1694 clear_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);1695 1696 return -EBUSY;1697}1698 1699/**1700 * idpf_set_vport_state - Set the vport state to be after the reset1701 * @adapter: Driver specific private structure1702 */1703static void idpf_set_vport_state(struct idpf_adapter *adapter)1704{1705 u16 i;1706 1707 for (i = 0; i < adapter->max_vports; i++) {1708 struct idpf_netdev_priv *np;1709 1710 if (!adapter->netdevs[i])1711 continue;1712 1713 np = netdev_priv(adapter->netdevs[i]);1714 if (np->state == __IDPF_VPORT_UP)1715 set_bit(IDPF_VPORT_UP_REQUESTED,1716 adapter->vport_config[i]->flags);1717 }1718}1719 1720/**1721 * idpf_init_hard_reset - Initiate a hardware reset1722 * @adapter: Driver specific private structure1723 *1724 * Deallocate the vports and all the resources associated with them and1725 * reallocate. Also reinitialize the mailbox. Return 0 on success,1726 * negative on failure.1727 */1728static int idpf_init_hard_reset(struct idpf_adapter *adapter)1729{1730 struct idpf_reg_ops *reg_ops = &adapter->dev_ops.reg_ops;1731 struct device *dev = &adapter->pdev->dev;1732 struct net_device *netdev;1733 int err;1734 u16 i;1735 1736 mutex_lock(&adapter->vport_ctrl_lock);1737 1738 dev_info(dev, "Device HW Reset initiated\n");1739 1740 /* Avoid TX hangs on reset */1741 for (i = 0; i < adapter->max_vports; i++) {1742 netdev = adapter->netdevs[i];1743 if (!netdev)1744 continue;1745 1746 netif_carrier_off(netdev);1747 netif_tx_disable(netdev);1748 }1749 1750 /* Prepare for reset */1751 if (test_and_clear_bit(IDPF_HR_DRV_LOAD, adapter->flags)) {1752 reg_ops->trigger_reset(adapter, IDPF_HR_DRV_LOAD);1753 } else if (test_and_clear_bit(IDPF_HR_FUNC_RESET, adapter->flags)) {1754 bool is_reset = idpf_is_reset_detected(adapter);1755 1756 idpf_set_vport_state(adapter);1757 idpf_vc_core_deinit(adapter);1758 if (!is_reset)1759 reg_ops->trigger_reset(adapter, IDPF_HR_FUNC_RESET);1760 idpf_deinit_dflt_mbx(adapter);1761 } else {1762 dev_err(dev, "Unhandled hard reset cause\n");1763 err = -EBADRQC;1764 goto unlock_mutex;1765 }1766 1767 /* Wait for reset to complete */1768 err = idpf_check_reset_complete(&adapter->hw, &adapter->reset_reg);1769 if (err) {1770 dev_err(dev, "The driver was unable to contact the device's firmware. Check that the FW is running. Driver state= 0x%x\n",1771 adapter->state);1772 goto unlock_mutex;1773 }1774 1775 /* Reset is complete and so start building the driver resources again */1776 err = idpf_init_dflt_mbx(adapter);1777 if (err) {1778 dev_err(dev, "Failed to initialize default mailbox: %d\n", err);1779 goto unlock_mutex;1780 }1781 1782 queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task, 0);1783 1784 /* Initialize the state machine, also allocate memory and request1785 * resources1786 */1787 err = idpf_vc_core_init(adapter);1788 if (err) {1789 cancel_delayed_work_sync(&adapter->mbx_task);1790 idpf_deinit_dflt_mbx(adapter);1791 goto unlock_mutex;1792 }1793 1794 /* Wait till all the vports are initialized to release the reset lock,1795 * else user space callbacks may access uninitialized vports1796 */1797 while (test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags))1798 msleep(100);1799 1800unlock_mutex:1801 mutex_unlock(&adapter->vport_ctrl_lock);1802 1803 return err;1804}1805 1806/**1807 * idpf_vc_event_task - Handle virtchannel event logic1808 * @work: work queue struct1809 */1810void idpf_vc_event_task(struct work_struct *work)1811{1812 struct idpf_adapter *adapter;1813 1814 adapter = container_of(work, struct idpf_adapter, vc_event_task.work);1815 1816 if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags))1817 return;1818 1819 if (test_bit(IDPF_HR_FUNC_RESET, adapter->flags) ||1820 test_bit(IDPF_HR_DRV_LOAD, adapter->flags)) {1821 set_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);1822 idpf_init_hard_reset(adapter);1823 }1824}1825 1826/**1827 * idpf_initiate_soft_reset - Initiate a software reset1828 * @vport: virtual port data struct1829 * @reset_cause: reason for the soft reset1830 *1831 * Soft reset only reallocs vport queue resources. Returns 0 on success,1832 * negative on failure.1833 */1834int idpf_initiate_soft_reset(struct idpf_vport *vport,1835 enum idpf_vport_reset_cause reset_cause)1836{1837 struct idpf_netdev_priv *np = netdev_priv(vport->netdev);1838 enum idpf_vport_state current_state = np->state;1839 struct idpf_adapter *adapter = vport->adapter;1840 struct idpf_vport *new_vport;1841 int err;1842 1843 /* If the system is low on memory, we can end up in bad state if we1844 * free all the memory for queue resources and try to allocate them1845 * again. Instead, we can pre-allocate the new resources before doing1846 * anything and bailing if the alloc fails.1847 *1848 * Make a clone of the existing vport to mimic its current1849 * configuration, then modify the new structure with any requested1850 * changes. Once the allocation of the new resources is done, stop the1851 * existing vport and copy the configuration to the main vport. If an1852 * error occurred, the existing vport will be untouched.1853 *1854 */1855 new_vport = kzalloc(sizeof(*vport), GFP_KERNEL);1856 if (!new_vport)1857 return -ENOMEM;1858 1859 /* This purposely avoids copying the end of the struct because it1860 * contains wait_queues and mutexes and other stuff we don't want to1861 * mess with. Nothing below should use those variables from new_vport1862 * and should instead always refer to them in vport if they need to.1863 */1864 memcpy(new_vport, vport, offsetof(struct idpf_vport, link_up));1865 1866 /* Adjust resource parameters prior to reallocating resources */1867 switch (reset_cause) {1868 case IDPF_SR_Q_CHANGE:1869 err = idpf_vport_adjust_qs(new_vport);1870 if (err)1871 goto free_vport;1872 break;1873 case IDPF_SR_Q_DESC_CHANGE:1874 /* Update queue parameters before allocating resources */1875 idpf_vport_calc_num_q_desc(new_vport);1876 break;1877 case IDPF_SR_MTU_CHANGE:1878 case IDPF_SR_RSC_CHANGE:1879 break;1880 default:1881 dev_err(&adapter->pdev->dev, "Unhandled soft reset cause\n");1882 err = -EINVAL;1883 goto free_vport;1884 }1885 1886 if (current_state <= __IDPF_VPORT_DOWN) {1887 idpf_send_delete_queues_msg(vport);1888 } else {1889 set_bit(IDPF_VPORT_DEL_QUEUES, vport->flags);1890 idpf_vport_stop(vport);1891 }1892 1893 idpf_deinit_rss(vport);1894 /* We're passing in vport here because we need its wait_queue1895 * to send a message and it should be getting all the vport1896 * config data out of the adapter but we need to be careful not1897 * to add code to add_queues to change the vport config within1898 * vport itself as it will be wiped with a memcpy later.1899 */1900 err = idpf_send_add_queues_msg(vport, new_vport->num_txq,1901 new_vport->num_complq,1902 new_vport->num_rxq,1903 new_vport->num_bufq);1904 if (err)1905 goto err_reset;1906 1907 /* Same comment as above regarding avoiding copying the wait_queues and1908 * mutexes applies here. We do not want to mess with those if possible.1909 */1910 memcpy(vport, new_vport, offsetof(struct idpf_vport, link_up));1911 1912 if (reset_cause == IDPF_SR_Q_CHANGE)1913 idpf_vport_alloc_vec_indexes(vport);1914 1915 err = idpf_set_real_num_queues(vport);1916 if (err)1917 goto err_open;1918 1919 if (current_state == __IDPF_VPORT_UP)1920 err = idpf_vport_open(vport);1921 1922 kfree(new_vport);1923 1924 return err;1925 1926err_reset:1927 idpf_send_add_queues_msg(vport, vport->num_txq, vport->num_complq,1928 vport->num_rxq, vport->num_bufq);1929 1930err_open:1931 if (current_state == __IDPF_VPORT_UP)1932 idpf_vport_open(vport);1933 1934free_vport:1935 kfree(new_vport);1936 1937 return err;1938}1939 1940/**1941 * idpf_addr_sync - Callback for dev_(mc|uc)_sync to add address1942 * @netdev: the netdevice1943 * @addr: address to add1944 *1945 * Called by __dev_(mc|uc)_sync when an address needs to be added. We call1946 * __dev_(uc|mc)_sync from .set_rx_mode. Kernel takes addr_list_lock spinlock1947 * meaning we cannot sleep in this context. Due to this, we have to add the1948 * filter and send the virtchnl message asynchronously without waiting for the1949 * response from the other side. We won't know whether or not the operation1950 * actually succeeded until we get the message back. Returns 0 on success,1951 * negative on failure.1952 */1953static int idpf_addr_sync(struct net_device *netdev, const u8 *addr)1954{1955 struct idpf_netdev_priv *np = netdev_priv(netdev);1956 1957 return idpf_add_mac_filter(np->vport, np, addr, true);1958}1959 1960/**1961 * idpf_addr_unsync - Callback for dev_(mc|uc)_sync to remove address1962 * @netdev: the netdevice1963 * @addr: address to add1964 *1965 * Called by __dev_(mc|uc)_sync when an address needs to be added. We call1966 * __dev_(uc|mc)_sync from .set_rx_mode. Kernel takes addr_list_lock spinlock1967 * meaning we cannot sleep in this context. Due to this we have to delete the1968 * filter and send the virtchnl message asynchronously without waiting for the1969 * return from the other side. We won't know whether or not the operation1970 * actually succeeded until we get the message back. Returns 0 on success,1971 * negative on failure.1972 */1973static int idpf_addr_unsync(struct net_device *netdev, const u8 *addr)1974{1975 struct idpf_netdev_priv *np = netdev_priv(netdev);1976 1977 /* Under some circumstances, we might receive a request to delete1978 * our own device address from our uc list. Because we store the1979 * device address in the VSI's MAC filter list, we need to ignore1980 * such requests and not delete our device address from this list.1981 */1982 if (ether_addr_equal(addr, netdev->dev_addr))1983 return 0;1984 1985 idpf_del_mac_filter(np->vport, np, addr, true);1986 1987 return 0;1988}1989 1990/**1991 * idpf_set_rx_mode - NDO callback to set the netdev filters1992 * @netdev: network interface device structure1993 *1994 * Stack takes addr_list_lock spinlock before calling our .set_rx_mode. We1995 * cannot sleep in this context.1996 */1997static void idpf_set_rx_mode(struct net_device *netdev)1998{1999 struct idpf_netdev_priv *np = netdev_priv(netdev);2000 struct idpf_vport_user_config_data *config_data;2001 struct idpf_adapter *adapter;2002 bool changed = false;2003 struct device *dev;2004 int err;2005 2006 adapter = np->adapter;2007 dev = &adapter->pdev->dev;2008 2009 if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_MACFILTER)) {2010 __dev_uc_sync(netdev, idpf_addr_sync, idpf_addr_unsync);2011 __dev_mc_sync(netdev, idpf_addr_sync, idpf_addr_unsync);2012 }2013 2014 if (!idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_PROMISC))2015 return;2016 2017 config_data = &adapter->vport_config[np->vport_idx]->user_config;2018 /* IFF_PROMISC enables both unicast and multicast promiscuous,2019 * while IFF_ALLMULTI only enables multicast such that:2020 *2021 * promisc + allmulti = unicast | multicast2022 * promisc + !allmulti = unicast | multicast2023 * !promisc + allmulti = multicast2024 */2025 if ((netdev->flags & IFF_PROMISC) &&2026 !test_and_set_bit(__IDPF_PROMISC_UC, config_data->user_flags)) {2027 changed = true;2028 dev_info(&adapter->pdev->dev, "Entering promiscuous mode\n");2029 if (!test_and_set_bit(__IDPF_PROMISC_MC, adapter->flags))2030 dev_info(dev, "Entering multicast promiscuous mode\n");2031 }2032 2033 if (!(netdev->flags & IFF_PROMISC) &&2034 test_and_clear_bit(__IDPF_PROMISC_UC, config_data->user_flags)) {2035 changed = true;2036 dev_info(dev, "Leaving promiscuous mode\n");2037 }2038 2039 if (netdev->flags & IFF_ALLMULTI &&2040 !test_and_set_bit(__IDPF_PROMISC_MC, config_data->user_flags)) {2041 changed = true;2042 dev_info(dev, "Entering multicast promiscuous mode\n");2043 }2044 2045 if (!(netdev->flags & (IFF_ALLMULTI | IFF_PROMISC)) &&2046 test_and_clear_bit(__IDPF_PROMISC_MC, config_data->user_flags)) {2047 changed = true;2048 dev_info(dev, "Leaving multicast promiscuous mode\n");2049 }2050 2051 if (!changed)2052 return;2053 2054 err = idpf_set_promiscuous(adapter, config_data, np->vport_id);2055 if (err)2056 dev_err(dev, "Failed to set promiscuous mode: %d\n", err);2057}2058 2059/**2060 * idpf_vport_manage_rss_lut - disable/enable RSS2061 * @vport: the vport being changed2062 *2063 * In the event of disable request for RSS, this function will zero out RSS2064 * LUT, while in the event of enable request for RSS, it will reconfigure RSS2065 * LUT with the default LUT configuration.2066 */2067static int idpf_vport_manage_rss_lut(struct idpf_vport *vport)2068{2069 bool ena = idpf_is_feature_ena(vport, NETIF_F_RXHASH);2070 struct idpf_rss_data *rss_data;2071 u16 idx = vport->idx;2072 int lut_size;2073 2074 rss_data = &vport->adapter->vport_config[idx]->user_config.rss_data;2075 lut_size = rss_data->rss_lut_size * sizeof(u32);2076 2077 if (ena) {2078 /* This will contain the default or user configured LUT */2079 memcpy(rss_data->rss_lut, rss_data->cached_lut, lut_size);2080 } else {2081 /* Save a copy of the current LUT to be restored later if2082 * requested.2083 */2084 memcpy(rss_data->cached_lut, rss_data->rss_lut, lut_size);2085 2086 /* Zero out the current LUT to disable */2087 memset(rss_data->rss_lut, 0, lut_size);2088 }2089 2090 return idpf_config_rss(vport);2091}2092 2093/**2094 * idpf_set_features - set the netdev feature flags2095 * @netdev: ptr to the netdev being adjusted2096 * @features: the feature set that the stack is suggesting2097 */2098static int idpf_set_features(struct net_device *netdev,2099 netdev_features_t features)2100{2101 netdev_features_t changed = netdev->features ^ features;2102 struct idpf_adapter *adapter;2103 struct idpf_vport *vport;2104 int err = 0;2105 2106 idpf_vport_ctrl_lock(netdev);2107 vport = idpf_netdev_to_vport(netdev);2108 2109 adapter = vport->adapter;2110 2111 if (idpf_is_reset_in_prog(adapter)) {2112 dev_err(&adapter->pdev->dev, "Device is resetting, changing netdev features temporarily unavailable.\n");2113 err = -EBUSY;2114 goto unlock_mutex;2115 }2116 2117 if (changed & NETIF_F_RXHASH) {2118 netdev->features ^= NETIF_F_RXHASH;2119 err = idpf_vport_manage_rss_lut(vport);2120 if (err)2121 goto unlock_mutex;2122 }2123 2124 if (changed & NETIF_F_GRO_HW) {2125 netdev->features ^= NETIF_F_GRO_HW;2126 err = idpf_initiate_soft_reset(vport, IDPF_SR_RSC_CHANGE);2127 if (err)2128 goto unlock_mutex;2129 }2130 2131 if (changed & NETIF_F_LOOPBACK) {2132 netdev->features ^= NETIF_F_LOOPBACK;2133 err = idpf_send_ena_dis_loopback_msg(vport);2134 }2135 2136unlock_mutex:2137 idpf_vport_ctrl_unlock(netdev);2138 2139 return err;2140}2141 2142/**2143 * idpf_open - Called when a network interface becomes active2144 * @netdev: network interface device structure2145 *2146 * The open entry point is called when a network interface is made2147 * active by the system (IFF_UP). At this point all resources needed2148 * for transmit and receive operations are allocated, the interrupt2149 * handler is registered with the OS, the netdev watchdog is enabled,2150 * and the stack is notified that the interface is ready.2151 *2152 * Returns 0 on success, negative value on failure2153 */2154static int idpf_open(struct net_device *netdev)2155{2156 struct idpf_vport *vport;2157 int err;2158 2159 idpf_vport_ctrl_lock(netdev);2160 vport = idpf_netdev_to_vport(netdev);2161 2162 err = idpf_vport_open(vport);2163 2164 idpf_vport_ctrl_unlock(netdev);2165 2166 return err;2167}2168 2169/**2170 * idpf_change_mtu - NDO callback to change the MTU2171 * @netdev: network interface device structure2172 * @new_mtu: new value for maximum frame size2173 *2174 * Returns 0 on success, negative on failure2175 */2176static int idpf_change_mtu(struct net_device *netdev, int new_mtu)2177{2178 struct idpf_vport *vport;2179 int err;2180 2181 idpf_vport_ctrl_lock(netdev);2182 vport = idpf_netdev_to_vport(netdev);2183 2184 WRITE_ONCE(netdev->mtu, new_mtu);2185 2186 err = idpf_initiate_soft_reset(vport, IDPF_SR_MTU_CHANGE);2187 2188 idpf_vport_ctrl_unlock(netdev);2189 2190 return err;2191}2192 2193/**2194 * idpf_features_check - Validate packet conforms to limits2195 * @skb: skb buffer2196 * @netdev: This port's netdev2197 * @features: Offload features that the stack believes apply2198 */2199static netdev_features_t idpf_features_check(struct sk_buff *skb,2200 struct net_device *netdev,2201 netdev_features_t features)2202{2203 struct idpf_vport *vport = idpf_netdev_to_vport(netdev);2204 struct idpf_adapter *adapter = vport->adapter;2205 size_t len;2206 2207 /* No point in doing any of this if neither checksum nor GSO are2208 * being requested for this frame. We can rule out both by just2209 * checking for CHECKSUM_PARTIAL2210 */2211 if (skb->ip_summed != CHECKSUM_PARTIAL)2212 return features;2213 2214 /* We cannot support GSO if the MSS is going to be less than2215 * 88 bytes. If it is then we need to drop support for GSO.2216 */2217 if (skb_is_gso(skb) &&2218 (skb_shinfo(skb)->gso_size < IDPF_TX_TSO_MIN_MSS))2219 features &= ~NETIF_F_GSO_MASK;2220 2221 /* Ensure MACLEN is <= 126 bytes (63 words) and not an odd size */2222 len = skb_network_offset(skb);2223 if (unlikely(len & ~(126)))2224 goto unsupported;2225 2226 len = skb_network_header_len(skb);2227 if (unlikely(len > idpf_get_max_tx_hdr_size(adapter)))2228 goto unsupported;2229 2230 if (!skb->encapsulation)2231 return features;2232 2233 /* L4TUNLEN can support 127 words */2234 len = skb_inner_network_header(skb) - skb_transport_header(skb);2235 if (unlikely(len & ~(127 * 2)))2236 goto unsupported;2237 2238 /* IPLEN can support at most 127 dwords */2239 len = skb_inner_network_header_len(skb);2240 if (unlikely(len > idpf_get_max_tx_hdr_size(adapter)))2241 goto unsupported;2242 2243 /* No need to validate L4LEN as TCP is the only protocol with a2244 * a flexible value and we support all possible values supported2245 * by TCP, which is at most 15 dwords2246 */2247 2248 return features;2249 2250unsupported:2251 return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);2252}2253 2254/**2255 * idpf_set_mac - NDO callback to set port mac address2256 * @netdev: network interface device structure2257 * @p: pointer to an address structure2258 *2259 * Returns 0 on success, negative on failure2260 **/2261static int idpf_set_mac(struct net_device *netdev, void *p)2262{2263 struct idpf_netdev_priv *np = netdev_priv(netdev);2264 struct idpf_vport_config *vport_config;2265 struct sockaddr *addr = p;2266 struct idpf_vport *vport;2267 int err = 0;2268 2269 idpf_vport_ctrl_lock(netdev);2270 vport = idpf_netdev_to_vport(netdev);2271 2272 if (!idpf_is_cap_ena(vport->adapter, IDPF_OTHER_CAPS,2273 VIRTCHNL2_CAP_MACFILTER)) {2274 dev_info(&vport->adapter->pdev->dev, "Setting MAC address is not supported\n");2275 err = -EOPNOTSUPP;2276 goto unlock_mutex;2277 }2278 2279 if (!is_valid_ether_addr(addr->sa_data)) {2280 dev_info(&vport->adapter->pdev->dev, "Invalid MAC address: %pM\n",2281 addr->sa_data);2282 err = -EADDRNOTAVAIL;2283 goto unlock_mutex;2284 }2285 2286 if (ether_addr_equal(netdev->dev_addr, addr->sa_data))2287 goto unlock_mutex;2288 2289 vport_config = vport->adapter->vport_config[vport->idx];2290 err = idpf_add_mac_filter(vport, np, addr->sa_data, false);2291 if (err) {2292 __idpf_del_mac_filter(vport_config, addr->sa_data);2293 goto unlock_mutex;2294 }2295 2296 if (is_valid_ether_addr(vport->default_mac_addr))2297 idpf_del_mac_filter(vport, np, vport->default_mac_addr, false);2298 2299 ether_addr_copy(vport->default_mac_addr, addr->sa_data);2300 eth_hw_addr_set(netdev, addr->sa_data);2301 2302unlock_mutex:2303 idpf_vport_ctrl_unlock(netdev);2304 2305 return err;2306}2307 2308/**2309 * idpf_alloc_dma_mem - Allocate dma memory2310 * @hw: pointer to hw struct2311 * @mem: pointer to dma_mem struct2312 * @size: size of the memory to allocate2313 */2314void *idpf_alloc_dma_mem(struct idpf_hw *hw, struct idpf_dma_mem *mem, u64 size)2315{2316 struct idpf_adapter *adapter = hw->back;2317 size_t sz = ALIGN(size, 4096);2318 2319 mem->va = dma_alloc_coherent(&adapter->pdev->dev, sz,2320 &mem->pa, GFP_KERNEL);2321 mem->size = sz;2322 2323 return mem->va;2324}2325 2326/**2327 * idpf_free_dma_mem - Free the allocated dma memory2328 * @hw: pointer to hw struct2329 * @mem: pointer to dma_mem struct2330 */2331void idpf_free_dma_mem(struct idpf_hw *hw, struct idpf_dma_mem *mem)2332{2333 struct idpf_adapter *adapter = hw->back;2334 2335 dma_free_coherent(&adapter->pdev->dev, mem->size,2336 mem->va, mem->pa);2337 mem->size = 0;2338 mem->va = NULL;2339 mem->pa = 0;2340}2341 2342static const struct net_device_ops idpf_netdev_ops = {2343 .ndo_open = idpf_open,2344 .ndo_stop = idpf_stop,2345 .ndo_start_xmit = idpf_tx_start,2346 .ndo_features_check = idpf_features_check,2347 .ndo_set_rx_mode = idpf_set_rx_mode,2348 .ndo_validate_addr = eth_validate_addr,2349 .ndo_set_mac_address = idpf_set_mac,2350 .ndo_change_mtu = idpf_change_mtu,2351 .ndo_get_stats64 = idpf_get_stats64,2352 .ndo_set_features = idpf_set_features,2353 .ndo_tx_timeout = idpf_tx_timeout,2354};2355