1/******************************************************************************* 2 * 3 * Intel Ethernet Controller XL710 Family Linux Virtual Function Driver 4 * Copyright(c) 2013 - 2015 Intel Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms and conditions of the GNU General Public License, 8 * version 2, as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 * more details. 14 * 15 * You should have received a copy of the GNU General Public License along 16 * with this program. If not, see <http://www.gnu.org/licenses/>. 17 * 18 * The full GNU General Public License is included in this distribution in 19 * the file called "COPYING". 20 * 21 * Contact Information: 22 * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> 23 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 24 * 25 ******************************************************************************/ 26 27#include "i40evf.h" 28#include "i40e_prototype.h" 29static int i40evf_setup_all_tx_resources(struct i40evf_adapter *adapter); 30static int i40evf_setup_all_rx_resources(struct i40evf_adapter *adapter); 31static int i40evf_close(struct net_device *netdev); 32 33char i40evf_driver_name[] = "i40evf"; 34static const char i40evf_driver_string[] = 35 "Intel(R) XL710/X710 Virtual Function Network Driver"; 36 37#define DRV_VERSION "1.2.25" 38const char i40evf_driver_version[] = DRV_VERSION; 39static const char i40evf_copyright[] = 40 "Copyright (c) 2013 - 2014 Intel Corporation."; 41 42/* i40evf_pci_tbl - PCI Device ID Table 43 * 44 * Wildcard entries (PCI_ANY_ID) should come last 45 * Last entry must be all 0s 46 * 47 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, 48 * Class, Class Mask, private data (not used) } 49 */ 50static const struct pci_device_id i40evf_pci_tbl[] = { 51 {PCI_VDEVICE(INTEL, I40E_DEV_ID_VF), 0}, 52 /* required last entry */ 53 {0, } 54}; 55 56MODULE_DEVICE_TABLE(pci, i40evf_pci_tbl); 57 58MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>"); 59MODULE_DESCRIPTION("Intel(R) XL710 X710 Virtual Function Network Driver"); 60MODULE_LICENSE("GPL"); 61MODULE_VERSION(DRV_VERSION); 62 63/** 64 * i40evf_allocate_dma_mem_d - OS specific memory alloc for shared code 65 * @hw: pointer to the HW structure 66 * @mem: ptr to mem struct to fill out 67 * @size: size of memory requested 68 * @alignment: what to align the allocation to 69 **/ 70i40e_status i40evf_allocate_dma_mem_d(struct i40e_hw *hw, 71 struct i40e_dma_mem *mem, 72 u64 size, u32 alignment) 73{ 74 struct i40evf_adapter *adapter = (struct i40evf_adapter *)hw->back; 75 76 if (!mem) 77 return I40E_ERR_PARAM; 78 79 mem->size = ALIGN(size, alignment); 80 mem->va = dma_alloc_coherent(&adapter->pdev->dev, mem->size, 81 (dma_addr_t *)&mem->pa, GFP_KERNEL); 82 if (mem->va) 83 return 0; 84 else 85 return I40E_ERR_NO_MEMORY; 86} 87 88/** 89 * i40evf_free_dma_mem_d - OS specific memory free for shared code 90 * @hw: pointer to the HW structure 91 * @mem: ptr to mem struct to free 92 **/ 93i40e_status i40evf_free_dma_mem_d(struct i40e_hw *hw, struct i40e_dma_mem *mem) 94{ 95 struct i40evf_adapter *adapter = (struct i40evf_adapter *)hw->back; 96 97 if (!mem || !mem->va) 98 return I40E_ERR_PARAM; 99 dma_free_coherent(&adapter->pdev->dev, mem->size, 100 mem->va, (dma_addr_t)mem->pa); 101 return 0; 102} 103 104/** 105 * i40evf_allocate_virt_mem_d - OS specific memory alloc for shared code 106 * @hw: pointer to the HW structure 107 * @mem: ptr to mem struct to fill out 108 * @size: size of memory requested 109 **/ 110i40e_status i40evf_allocate_virt_mem_d(struct i40e_hw *hw, 111 struct i40e_virt_mem *mem, u32 size) 112{ 113 if (!mem) 114 return I40E_ERR_PARAM; 115 116 mem->size = size; 117 mem->va = kzalloc(size, GFP_KERNEL); 118 119 if (mem->va) 120 return 0; 121 else 122 return I40E_ERR_NO_MEMORY; 123} 124 125/** 126 * i40evf_free_virt_mem_d - OS specific memory free for shared code 127 * @hw: pointer to the HW structure 128 * @mem: ptr to mem struct to free 129 **/ 130i40e_status i40evf_free_virt_mem_d(struct i40e_hw *hw, 131 struct i40e_virt_mem *mem) 132{ 133 if (!mem) 134 return I40E_ERR_PARAM; 135 136 /* it's ok to kfree a NULL pointer */ 137 kfree(mem->va); 138 139 return 0; 140} 141 142/** 143 * i40evf_debug_d - OS dependent version of debug printing 144 * @hw: pointer to the HW structure 145 * @mask: debug level mask 146 * @fmt_str: printf-type format description 147 **/ 148void i40evf_debug_d(void *hw, u32 mask, char *fmt_str, ...) 149{ 150 char buf[512]; 151 va_list argptr; 152 153 if (!(mask & ((struct i40e_hw *)hw)->debug_mask)) 154 return; 155 156 va_start(argptr, fmt_str); 157 vsnprintf(buf, sizeof(buf), fmt_str, argptr); 158 va_end(argptr); 159 160 /* the debug string is already formatted with a newline */ 161 pr_info("%s", buf); 162} 163 164/** 165 * i40evf_tx_timeout - Respond to a Tx Hang 166 * @netdev: network interface device structure 167 **/ 168static void i40evf_tx_timeout(struct net_device *netdev) 169{ 170 struct i40evf_adapter *adapter = netdev_priv(netdev); 171 172 adapter->tx_timeout_count++; 173 if (!(adapter->flags & I40EVF_FLAG_RESET_PENDING)) { 174 adapter->flags |= I40EVF_FLAG_RESET_NEEDED; 175 schedule_work(&adapter->reset_task); 176 } 177} 178 179/** 180 * i40evf_misc_irq_disable - Mask off interrupt generation on the NIC 181 * @adapter: board private structure 182 **/ 183static void i40evf_misc_irq_disable(struct i40evf_adapter *adapter) 184{ 185 struct i40e_hw *hw = &adapter->hw; 186 187 wr32(hw, I40E_VFINT_DYN_CTL01, 0); 188 189 /* read flush */ 190 rd32(hw, I40E_VFGEN_RSTAT); 191 192 synchronize_irq(adapter->msix_entries[0].vector); 193} 194 195/** 196 * i40evf_misc_irq_enable - Enable default interrupt generation settings 197 * @adapter: board private structure 198 **/ 199static void i40evf_misc_irq_enable(struct i40evf_adapter *adapter) 200{ 201 struct i40e_hw *hw = &adapter->hw; 202 203 wr32(hw, I40E_VFINT_DYN_CTL01, I40E_VFINT_DYN_CTL01_INTENA_MASK | 204 I40E_VFINT_DYN_CTL01_ITR_INDX_MASK); 205 wr32(hw, I40E_VFINT_ICR0_ENA1, I40E_VFINT_ICR0_ENA_ADMINQ_MASK); 206 207 /* read flush */ 208 rd32(hw, I40E_VFGEN_RSTAT); 209} 210 211/** 212 * i40evf_irq_disable - Mask off interrupt generation on the NIC 213 * @adapter: board private structure 214 **/ 215static void i40evf_irq_disable(struct i40evf_adapter *adapter) 216{ 217 int i; 218 struct i40e_hw *hw = &adapter->hw; 219 220 if (!adapter->msix_entries) 221 return; 222 223 for (i = 1; i < adapter->num_msix_vectors; i++) { 224 wr32(hw, I40E_VFINT_DYN_CTLN1(i - 1), 0); 225 synchronize_irq(adapter->msix_entries[i].vector); 226 } 227 /* read flush */ 228 rd32(hw, I40E_VFGEN_RSTAT); 229} 230 231/** 232 * i40evf_irq_enable_queues - Enable interrupt for specified queues 233 * @adapter: board private structure 234 * @mask: bitmap of queues to enable 235 **/ 236void i40evf_irq_enable_queues(struct i40evf_adapter *adapter, u32 mask) 237{ 238 struct i40e_hw *hw = &adapter->hw; 239 int i; 240 241 for (i = 1; i < adapter->num_msix_vectors; i++) { 242 if (mask & (1 << (i - 1))) { 243 wr32(hw, I40E_VFINT_DYN_CTLN1(i - 1), 244 I40E_VFINT_DYN_CTLN1_INTENA_MASK | 245 I40E_VFINT_DYN_CTLN1_ITR_INDX_MASK | 246 I40E_VFINT_DYN_CTLN_CLEARPBA_MASK); 247 } 248 } 249} 250 251/** 252 * i40evf_fire_sw_int - Generate SW interrupt for specified vectors 253 * @adapter: board private structure 254 * @mask: bitmap of vectors to trigger 255 **/ 256static void i40evf_fire_sw_int(struct i40evf_adapter *adapter, u32 mask) 257{ 258 struct i40e_hw *hw = &adapter->hw; 259 int i; 260 uint32_t dyn_ctl; 261 262 if (mask & 1) { 263 dyn_ctl = rd32(hw, I40E_VFINT_DYN_CTL01); 264 dyn_ctl |= I40E_VFINT_DYN_CTLN_SWINT_TRIG_MASK | 265 I40E_VFINT_DYN_CTLN1_ITR_INDX_MASK | 266 I40E_VFINT_DYN_CTLN_CLEARPBA_MASK; 267 wr32(hw, I40E_VFINT_DYN_CTL01, dyn_ctl); 268 } 269 for (i = 1; i < adapter->num_msix_vectors; i++) { 270 if (mask & (1 << i)) { 271 dyn_ctl = rd32(hw, I40E_VFINT_DYN_CTLN1(i - 1)); 272 dyn_ctl |= I40E_VFINT_DYN_CTLN_SWINT_TRIG_MASK | 273 I40E_VFINT_DYN_CTLN1_ITR_INDX_MASK | 274 I40E_VFINT_DYN_CTLN_CLEARPBA_MASK; 275 wr32(hw, I40E_VFINT_DYN_CTLN1(i - 1), dyn_ctl); 276 } 277 } 278} 279 280/** 281 * i40evf_irq_enable - Enable default interrupt generation settings 282 * @adapter: board private structure 283 **/ 284void i40evf_irq_enable(struct i40evf_adapter *adapter, bool flush) 285{ 286 struct i40e_hw *hw = &adapter->hw; 287 288 i40evf_misc_irq_enable(adapter); 289 i40evf_irq_enable_queues(adapter, ~0); 290 291 if (flush) 292 rd32(hw, I40E_VFGEN_RSTAT); 293} 294 295/** 296 * i40evf_msix_aq - Interrupt handler for vector 0 297 * @irq: interrupt number 298 * @data: pointer to netdev 299 **/ 300static irqreturn_t i40evf_msix_aq(int irq, void *data) 301{ 302 struct net_device *netdev = data; 303 struct i40evf_adapter *adapter = netdev_priv(netdev); 304 struct i40e_hw *hw = &adapter->hw; 305 u32 val; 306 u32 ena_mask; 307 308 /* handle non-queue interrupts */ 309 val = rd32(hw, I40E_VFINT_ICR01); 310 ena_mask = rd32(hw, I40E_VFINT_ICR0_ENA1); 311 312 313 val = rd32(hw, I40E_VFINT_DYN_CTL01); 314 val = val | I40E_PFINT_DYN_CTL0_CLEARPBA_MASK; 315 wr32(hw, I40E_VFINT_DYN_CTL01, val); 316 317 /* schedule work on the private workqueue */ 318 schedule_work(&adapter->adminq_task); 319 320 return IRQ_HANDLED; 321} 322 323/** 324 * i40evf_msix_clean_rings - MSIX mode Interrupt Handler 325 * @irq: interrupt number 326 * @data: pointer to a q_vector 327 **/ 328static irqreturn_t i40evf_msix_clean_rings(int irq, void *data) 329{ 330 struct i40e_q_vector *q_vector = data; 331 332 if (!q_vector->tx.ring && !q_vector->rx.ring) 333 return IRQ_HANDLED; 334 335 napi_schedule(&q_vector->napi); 336 337 return IRQ_HANDLED; 338} 339 340/** 341 * i40evf_map_vector_to_rxq - associate irqs with rx queues 342 * @adapter: board private structure 343 * @v_idx: interrupt number 344 * @r_idx: queue number 345 **/ 346static void 347i40evf_map_vector_to_rxq(struct i40evf_adapter *adapter, int v_idx, int r_idx) 348{ 349 struct i40e_q_vector *q_vector = adapter->q_vector[v_idx]; 350 struct i40e_ring *rx_ring = adapter->rx_rings[r_idx]; 351 352 rx_ring->q_vector = q_vector; 353 rx_ring->next = q_vector->rx.ring; 354 rx_ring->vsi = &adapter->vsi; 355 q_vector->rx.ring = rx_ring; 356 q_vector->rx.count++; 357 q_vector->rx.latency_range = I40E_LOW_LATENCY; 358} 359 360/** 361 * i40evf_map_vector_to_txq - associate irqs with tx queues 362 * @adapter: board private structure 363 * @v_idx: interrupt number 364 * @t_idx: queue number 365 **/ 366static void 367i40evf_map_vector_to_txq(struct i40evf_adapter *adapter, int v_idx, int t_idx) 368{ 369 struct i40e_q_vector *q_vector = adapter->q_vector[v_idx]; 370 struct i40e_ring *tx_ring = adapter->tx_rings[t_idx]; 371 372 tx_ring->q_vector = q_vector; 373 tx_ring->next = q_vector->tx.ring; 374 tx_ring->vsi = &adapter->vsi; 375 q_vector->tx.ring = tx_ring; 376 q_vector->tx.count++; 377 q_vector->tx.latency_range = I40E_LOW_LATENCY; 378 q_vector->num_ringpairs++; 379 q_vector->ring_mask |= (1 << t_idx); 380} 381 382/** 383 * i40evf_map_rings_to_vectors - Maps descriptor rings to vectors 384 * @adapter: board private structure to initialize 385 * 386 * This function maps descriptor rings to the queue-specific vectors 387 * we were allotted through the MSI-X enabling code. Ideally, we'd have 388 * one vector per ring/queue, but on a constrained vector budget, we 389 * group the rings as "efficiently" as possible. You would add new 390 * mapping configurations in here. 391 **/ 392static int i40evf_map_rings_to_vectors(struct i40evf_adapter *adapter) 393{ 394 int q_vectors; 395 int v_start = 0; 396 int rxr_idx = 0, txr_idx = 0; 397 int rxr_remaining = adapter->num_active_queues; 398 int txr_remaining = adapter->num_active_queues; 399 int i, j; 400 int rqpv, tqpv; 401 int err = 0; 402 403 q_vectors = adapter->num_msix_vectors - NONQ_VECS; 404 405 /* The ideal configuration... 406 * We have enough vectors to map one per queue. 407 */ 408 if (q_vectors == (rxr_remaining * 2)) { 409 for (; rxr_idx < rxr_remaining; v_start++, rxr_idx++) 410 i40evf_map_vector_to_rxq(adapter, v_start, rxr_idx); 411 412 for (; txr_idx < txr_remaining; v_start++, txr_idx++) 413 i40evf_map_vector_to_txq(adapter, v_start, txr_idx); 414 goto out; 415 } 416 417 /* If we don't have enough vectors for a 1-to-1 418 * mapping, we'll have to group them so there are 419 * multiple queues per vector. 420 * Re-adjusting *qpv takes care of the remainder. 421 */ 422 for (i = v_start; i < q_vectors; i++) { 423 rqpv = DIV_ROUND_UP(rxr_remaining, q_vectors - i); 424 for (j = 0; j < rqpv; j++) { 425 i40evf_map_vector_to_rxq(adapter, i, rxr_idx); 426 rxr_idx++; 427 rxr_remaining--; 428 } 429 } 430 for (i = v_start; i < q_vectors; i++) { 431 tqpv = DIV_ROUND_UP(txr_remaining, q_vectors - i); 432 for (j = 0; j < tqpv; j++) { 433 i40evf_map_vector_to_txq(adapter, i, txr_idx); 434 txr_idx++; 435 txr_remaining--; 436 } 437 } 438 439out: 440 adapter->aq_required |= I40EVF_FLAG_AQ_MAP_VECTORS; 441 442 return err; 443} 444 445/** 446 * i40evf_request_traffic_irqs - Initialize MSI-X interrupts 447 * @adapter: board private structure 448 * 449 * Allocates MSI-X vectors for tx and rx handling, and requests 450 * interrupts from the kernel. 451 **/ 452static int 453i40evf_request_traffic_irqs(struct i40evf_adapter *adapter, char *basename) 454{ 455 int vector, err, q_vectors; 456 int rx_int_idx = 0, tx_int_idx = 0; 457 458 i40evf_irq_disable(adapter); 459 /* Decrement for Other and TCP Timer vectors */ 460 q_vectors = adapter->num_msix_vectors - NONQ_VECS; 461 462 for (vector = 0; vector < q_vectors; vector++) { 463 struct i40e_q_vector *q_vector = adapter->q_vector[vector]; 464 465 if (q_vector->tx.ring && q_vector->rx.ring) { 466 snprintf(q_vector->name, sizeof(q_vector->name) - 1, 467 "i40evf-%s-%s-%d", basename, 468 "TxRx", rx_int_idx++); 469 tx_int_idx++; 470 } else if (q_vector->rx.ring) { 471 snprintf(q_vector->name, sizeof(q_vector->name) - 1, 472 "i40evf-%s-%s-%d", basename, 473 "rx", rx_int_idx++); 474 } else if (q_vector->tx.ring) { 475 snprintf(q_vector->name, sizeof(q_vector->name) - 1, 476 "i40evf-%s-%s-%d", basename, 477 "tx", tx_int_idx++); 478 } else { 479 /* skip this unused q_vector */ 480 continue; 481 } 482 err = request_irq( 483 adapter->msix_entries[vector + NONQ_VECS].vector, 484 i40evf_msix_clean_rings, 485 0, 486 q_vector->name, 487 q_vector); 488 if (err) { 489 dev_info(&adapter->pdev->dev, 490 "%s: request_irq failed, error: %d\n", 491 __func__, err); 492 goto free_queue_irqs; 493 } 494 /* assign the mask for this irq */ 495 irq_set_affinity_hint( 496 adapter->msix_entries[vector + NONQ_VECS].vector, 497 q_vector->affinity_mask); 498 } 499 500 return 0; 501 502free_queue_irqs: 503 while (vector) { 504 vector--; 505 irq_set_affinity_hint( 506 adapter->msix_entries[vector + NONQ_VECS].vector, 507 NULL); 508 free_irq(adapter->msix_entries[vector + NONQ_VECS].vector, 509 adapter->q_vector[vector]); 510 } 511 return err; 512} 513 514/** 515 * i40evf_request_misc_irq - Initialize MSI-X interrupts 516 * @adapter: board private structure 517 * 518 * Allocates MSI-X vector 0 and requests interrupts from the kernel. This 519 * vector is only for the admin queue, and stays active even when the netdev 520 * is closed. 521 **/ 522static int i40evf_request_misc_irq(struct i40evf_adapter *adapter) 523{ 524 struct net_device *netdev = adapter->netdev; 525 int err; 526 527 snprintf(adapter->misc_vector_name, 528 sizeof(adapter->misc_vector_name) - 1, "i40evf-%s:mbx", 529 dev_name(&adapter->pdev->dev)); 530 err = request_irq(adapter->msix_entries[0].vector, 531 &i40evf_msix_aq, 0, 532 adapter->misc_vector_name, netdev); 533 if (err) { 534 dev_err(&adapter->pdev->dev, 535 "request_irq for %s failed: %d\n", 536 adapter->misc_vector_name, err); 537 free_irq(adapter->msix_entries[0].vector, netdev); 538 } 539 return err; 540} 541 542/** 543 * i40evf_free_traffic_irqs - Free MSI-X interrupts 544 * @adapter: board private structure 545 * 546 * Frees all MSI-X vectors other than 0. 547 **/ 548static void i40evf_free_traffic_irqs(struct i40evf_adapter *adapter) 549{ 550 int i; 551 int q_vectors; 552 553 q_vectors = adapter->num_msix_vectors - NONQ_VECS; 554 555 for (i = 0; i < q_vectors; i++) { 556 irq_set_affinity_hint(adapter->msix_entries[i+1].vector, 557 NULL); 558 free_irq(adapter->msix_entries[i+1].vector, 559 adapter->q_vector[i]); 560 } 561} 562 563/** 564 * i40evf_free_misc_irq - Free MSI-X miscellaneous vector 565 * @adapter: board private structure 566 * 567 * Frees MSI-X vector 0. 568 **/ 569static void i40evf_free_misc_irq(struct i40evf_adapter *adapter) 570{ 571 struct net_device *netdev = adapter->netdev; 572 573 free_irq(adapter->msix_entries[0].vector, netdev); 574} 575 576/** 577 * i40evf_configure_tx - Configure Transmit Unit after Reset 578 * @adapter: board private structure 579 * 580 * Configure the Tx unit of the MAC after a reset. 581 **/ 582static void i40evf_configure_tx(struct i40evf_adapter *adapter) 583{ 584 struct i40e_hw *hw = &adapter->hw; 585 int i; 586 587 for (i = 0; i < adapter->num_active_queues; i++) 588 adapter->tx_rings[i]->tail = hw->hw_addr + I40E_QTX_TAIL1(i); 589} 590 591/** 592 * i40evf_configure_rx - Configure Receive Unit after Reset 593 * @adapter: board private structure 594 * 595 * Configure the Rx unit of the MAC after a reset. 596 **/ 597static void i40evf_configure_rx(struct i40evf_adapter *adapter) 598{ 599 struct i40e_hw *hw = &adapter->hw; 600 struct net_device *netdev = adapter->netdev; 601 int max_frame = netdev->mtu + ETH_HLEN + ETH_FCS_LEN; 602 int i; 603 int rx_buf_len; 604 605 606 adapter->flags &= ~I40EVF_FLAG_RX_PS_CAPABLE; 607 adapter->flags |= I40EVF_FLAG_RX_1BUF_CAPABLE; 608 609 /* Decide whether to use packet split mode or not */ 610 if (netdev->mtu > ETH_DATA_LEN) { 611 if (adapter->flags & I40EVF_FLAG_RX_PS_CAPABLE) 612 adapter->flags |= I40EVF_FLAG_RX_PS_ENABLED; 613 else 614 adapter->flags &= ~I40EVF_FLAG_RX_PS_ENABLED; 615 } else { 616 if (adapter->flags & I40EVF_FLAG_RX_1BUF_CAPABLE) 617 adapter->flags &= ~I40EVF_FLAG_RX_PS_ENABLED; 618 else 619 adapter->flags |= I40EVF_FLAG_RX_PS_ENABLED; 620 } 621 622 /* Set the RX buffer length according to the mode */ 623 if (adapter->flags & I40EVF_FLAG_RX_PS_ENABLED) { 624 rx_buf_len = I40E_RX_HDR_SIZE; 625 } else { 626 if (netdev->mtu <= ETH_DATA_LEN) 627 rx_buf_len = I40EVF_RXBUFFER_2048; 628 else 629 rx_buf_len = ALIGN(max_frame, 1024); 630 } 631 632 for (i = 0; i < adapter->num_active_queues; i++) { 633 adapter->rx_rings[i]->tail = hw->hw_addr + I40E_QRX_TAIL1(i); 634 adapter->rx_rings[i]->rx_buf_len = rx_buf_len; 635 } 636} 637 638/** 639 * i40evf_find_vlan - Search filter list for specific vlan filter 640 * @adapter: board private structure 641 * @vlan: vlan tag 642 * 643 * Returns ptr to the filter object or NULL 644 **/ 645static struct 646i40evf_vlan_filter *i40evf_find_vlan(struct i40evf_adapter *adapter, u16 vlan) 647{ 648 struct i40evf_vlan_filter *f; 649 650 list_for_each_entry(f, &adapter->vlan_filter_list, list) { 651 if (vlan == f->vlan) 652 return f; 653 } 654 return NULL; 655} 656 657/** 658 * i40evf_add_vlan - Add a vlan filter to the list 659 * @adapter: board private structure 660 * @vlan: VLAN tag 661 * 662 * Returns ptr to the filter object or NULL when no memory available. 663 **/ 664static struct 665i40evf_vlan_filter *i40evf_add_vlan(struct i40evf_adapter *adapter, u16 vlan) 666{ 667 struct i40evf_vlan_filter *f = NULL; 668 int count = 50; 669 670 while (test_and_set_bit(__I40EVF_IN_CRITICAL_TASK, 671 &adapter->crit_section)) { 672 udelay(1); 673 if (--count == 0) 674 goto out; 675 } 676 677 f = i40evf_find_vlan(adapter, vlan); 678 if (!f) { 679 f = kzalloc(sizeof(*f), GFP_ATOMIC); 680 if (!f) 681 goto clearout; 682 683 f->vlan = vlan; 684 685 INIT_LIST_HEAD(&f->list); 686 list_add(&f->list, &adapter->vlan_filter_list); 687 f->add = true; 688 adapter->aq_required |= I40EVF_FLAG_AQ_ADD_VLAN_FILTER; 689 } 690 691clearout: 692 clear_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section); 693out: 694 return f; 695} 696 697/** 698 * i40evf_del_vlan - Remove a vlan filter from the list 699 * @adapter: board private structure 700 * @vlan: VLAN tag 701 **/ 702static void i40evf_del_vlan(struct i40evf_adapter *adapter, u16 vlan) 703{ 704 struct i40evf_vlan_filter *f; 705 int count = 50; 706 707 while (test_and_set_bit(__I40EVF_IN_CRITICAL_TASK, 708 &adapter->crit_section)) { 709 udelay(1); 710 if (--count == 0) 711 return; 712 } 713 714 f = i40evf_find_vlan(adapter, vlan); 715 if (f) { 716 f->remove = true; 717 adapter->aq_required |= I40EVF_FLAG_AQ_DEL_VLAN_FILTER; 718 } 719 clear_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section); 720} 721 722/** 723 * i40evf_vlan_rx_add_vid - Add a VLAN filter to a device 724 * @netdev: network device struct 725 * @vid: VLAN tag 726 **/ 727static int i40evf_vlan_rx_add_vid(struct net_device *netdev, 728 __always_unused __be16 proto, u16 vid) 729{ 730 struct i40evf_adapter *adapter = netdev_priv(netdev); 731 732 if (i40evf_add_vlan(adapter, vid) == NULL) 733 return -ENOMEM; 734 return 0; 735} 736 737/** 738 * i40evf_vlan_rx_kill_vid - Remove a VLAN filter from a device 739 * @netdev: network device struct 740 * @vid: VLAN tag 741 **/ 742static int i40evf_vlan_rx_kill_vid(struct net_device *netdev, 743 __always_unused __be16 proto, u16 vid) 744{ 745 struct i40evf_adapter *adapter = netdev_priv(netdev); 746 747 i40evf_del_vlan(adapter, vid); 748 return 0; 749} 750 751/** 752 * i40evf_find_filter - Search filter list for specific mac filter 753 * @adapter: board private structure 754 * @macaddr: the MAC address 755 * 756 * Returns ptr to the filter object or NULL 757 **/ 758static struct 759i40evf_mac_filter *i40evf_find_filter(struct i40evf_adapter *adapter, 760 u8 *macaddr) 761{ 762 struct i40evf_mac_filter *f; 763 764 if (!macaddr) 765 return NULL; 766 767 list_for_each_entry(f, &adapter->mac_filter_list, list) { 768 if (ether_addr_equal(macaddr, f->macaddr)) 769 return f; 770 } 771 return NULL; 772} 773 774/** 775 * i40e_add_filter - Add a mac filter to the filter list 776 * @adapter: board private structure 777 * @macaddr: the MAC address 778 * 779 * Returns ptr to the filter object or NULL when no memory available. 780 **/ 781static struct 782i40evf_mac_filter *i40evf_add_filter(struct i40evf_adapter *adapter, 783 u8 *macaddr) 784{ 785 struct i40evf_mac_filter *f; 786 int count = 50; 787 788 if (!macaddr) 789 return NULL; 790 791 while (test_and_set_bit(__I40EVF_IN_CRITICAL_TASK, 792 &adapter->crit_section)) { 793 udelay(1); 794 if (--count == 0) 795 return NULL; 796 } 797 798 f = i40evf_find_filter(adapter, macaddr); 799 if (!f) { 800 f = kzalloc(sizeof(*f), GFP_ATOMIC); 801 if (!f) { 802 clear_bit(__I40EVF_IN_CRITICAL_TASK, 803 &adapter->crit_section); 804 return NULL; 805 } 806 807 ether_addr_copy(f->macaddr, macaddr); 808 809 list_add(&f->list, &adapter->mac_filter_list); 810 f->add = true; 811 adapter->aq_required |= I40EVF_FLAG_AQ_ADD_MAC_FILTER; 812 } 813 814 clear_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section); 815 return f; 816} 817 818/** 819 * i40evf_set_mac - NDO callback to set port mac address 820 * @netdev: network interface device structure 821 * @p: pointer to an address structure 822 * 823 * Returns 0 on success, negative on failure 824 **/ 825static int i40evf_set_mac(struct net_device *netdev, void *p) 826{ 827 struct i40evf_adapter *adapter = netdev_priv(netdev); 828 struct i40e_hw *hw = &adapter->hw; 829 struct i40evf_mac_filter *f; 830 struct sockaddr *addr = p; 831 832 if (!is_valid_ether_addr(addr->sa_data)) 833 return -EADDRNOTAVAIL; 834 835 if (ether_addr_equal(netdev->dev_addr, addr->sa_data)) 836 return 0; 837 838 f = i40evf_add_filter(adapter, addr->sa_data); 839 if (f) { 840 ether_addr_copy(hw->mac.addr, addr->sa_data); 841 ether_addr_copy(netdev->dev_addr, adapter->hw.mac.addr); 842 } 843 844 return (f == NULL) ? -ENOMEM : 0; 845} 846 847/** 848 * i40evf_set_rx_mode - NDO callback to set the netdev filters 849 * @netdev: network interface device structure 850 **/ 851static void i40evf_set_rx_mode(struct net_device *netdev) 852{ 853 struct i40evf_adapter *adapter = netdev_priv(netdev); 854 struct i40evf_mac_filter *f, *ftmp; 855 struct netdev_hw_addr *uca; 856 struct netdev_hw_addr *mca; 857 int count = 50; 858 859 /* add addr if not already in the filter list */ 860 netdev_for_each_uc_addr(uca, netdev) { 861 i40evf_add_filter(adapter, uca->addr); 862 } 863 netdev_for_each_mc_addr(mca, netdev) { 864 i40evf_add_filter(adapter, mca->addr); 865 } 866 867 while (test_and_set_bit(__I40EVF_IN_CRITICAL_TASK, 868 &adapter->crit_section)) { 869 udelay(1); 870 if (--count == 0) { 871 dev_err(&adapter->pdev->dev, 872 "Failed to get lock in %s\n", __func__); 873 return; 874 } 875 } 876 /* remove filter if not in netdev list */ 877 list_for_each_entry_safe(f, ftmp, &adapter->mac_filter_list, list) { 878 bool found = false; 879 880 if (is_multicast_ether_addr(f->macaddr)) { 881 netdev_for_each_mc_addr(mca, netdev) { 882 if (ether_addr_equal(mca->addr, f->macaddr)) { 883 found = true; 884 break; 885 } 886 } 887 } else { 888 netdev_for_each_uc_addr(uca, netdev) { 889 if (ether_addr_equal(uca->addr, f->macaddr)) { 890 found = true; 891 break; 892 } 893 } 894 } 895 if (found) { 896 f->remove = true; 897 adapter->aq_required |= I40EVF_FLAG_AQ_DEL_MAC_FILTER; 898 } 899 } 900 clear_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section); 901} 902 903/** 904 * i40evf_napi_enable_all - enable NAPI on all queue vectors 905 * @adapter: board private structure 906 **/ 907static void i40evf_napi_enable_all(struct i40evf_adapter *adapter) 908{ 909 int q_idx; 910 struct i40e_q_vector *q_vector; 911 int q_vectors = adapter->num_msix_vectors - NONQ_VECS; 912 913 for (q_idx = 0; q_idx < q_vectors; q_idx++) { 914 struct napi_struct *napi; 915 916 q_vector = adapter->q_vector[q_idx]; 917 napi = &q_vector->napi; 918 napi_enable(napi); 919 } 920} 921 922/** 923 * i40evf_napi_disable_all - disable NAPI on all queue vectors 924 * @adapter: board private structure 925 **/ 926static void i40evf_napi_disable_all(struct i40evf_adapter *adapter) 927{ 928 int q_idx; 929 struct i40e_q_vector *q_vector; 930 int q_vectors = adapter->num_msix_vectors - NONQ_VECS; 931 932 for (q_idx = 0; q_idx < q_vectors; q_idx++) { 933 q_vector = adapter->q_vector[q_idx]; 934 napi_disable(&q_vector->napi); 935 } 936} 937 938/** 939 * i40evf_configure - set up transmit and receive data structures 940 * @adapter: board private structure 941 **/ 942static void i40evf_configure(struct i40evf_adapter *adapter) 943{ 944 struct net_device *netdev = adapter->netdev; 945 int i; 946 947 i40evf_set_rx_mode(netdev); 948 949 i40evf_configure_tx(adapter); 950 i40evf_configure_rx(adapter); 951 adapter->aq_required |= I40EVF_FLAG_AQ_CONFIGURE_QUEUES; 952 953 for (i = 0; i < adapter->num_active_queues; i++) { 954 struct i40e_ring *ring = adapter->rx_rings[i]; 955 956 i40evf_alloc_rx_buffers_1buf(ring, ring->count); 957 ring->next_to_use = ring->count - 1; 958 writel(ring->next_to_use, ring->tail); 959 } 960} 961 962/** 963 * i40evf_up_complete - Finish the last steps of bringing up a connection 964 * @adapter: board private structure 965 **/ 966static int i40evf_up_complete(struct i40evf_adapter *adapter) 967{ 968 adapter->state = __I40EVF_RUNNING; 969 clear_bit(__I40E_DOWN, &adapter->vsi.state); 970 971 i40evf_napi_enable_all(adapter); 972 973 adapter->aq_required |= I40EVF_FLAG_AQ_ENABLE_QUEUES; 974 mod_timer_pending(&adapter->watchdog_timer, jiffies + 1); 975 return 0; 976} 977 978/** 979 * i40e_down - Shutdown the connection processing 980 * @adapter: board private structure 981 **/ 982void i40evf_down(struct i40evf_adapter *adapter) 983{ 984 struct net_device *netdev = adapter->netdev; 985 struct i40evf_mac_filter *f; 986 987 if (adapter->state == __I40EVF_DOWN) 988 return; 989 990 while (test_and_set_bit(__I40EVF_IN_CRITICAL_TASK, 991 &adapter->crit_section)) 992 usleep_range(500, 1000); 993 994 netif_carrier_off(netdev); 995 netif_tx_disable(netdev); 996 i40evf_napi_disable_all(adapter); 997 i40evf_irq_disable(adapter); 998 999 /* remove all MAC filters */ 1000 list_for_each_entry(f, &adapter->mac_filter_list, list) { 1001 f->remove = true; 1002 } 1003 /* remove all VLAN filters */ 1004 list_for_each_entry(f, &adapter->vlan_filter_list, list) { 1005 f->remove = true; 1006 } 1007 if (!(adapter->flags & I40EVF_FLAG_PF_COMMS_FAILED) && 1008 adapter->state != __I40EVF_RESETTING) { 1009 /* cancel any current operation */ 1010 adapter->current_op = I40E_VIRTCHNL_OP_UNKNOWN; 1011 /* Schedule operations to close down the HW. Don't wait 1012 * here for this to complete. The watchdog is still running 1013 * and it will take care of this. 1014 */ 1015 adapter->aq_required = I40EVF_FLAG_AQ_DEL_MAC_FILTER; 1016 adapter->aq_required |= I40EVF_FLAG_AQ_DEL_VLAN_FILTER; 1017 adapter->aq_required |= I40EVF_FLAG_AQ_DISABLE_QUEUES; 1018 } 1019 1020 clear_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section); 1021} 1022 1023/** 1024 * i40evf_acquire_msix_vectors - Setup the MSIX capability 1025 * @adapter: board private structure 1026 * @vectors: number of vectors to request 1027 * 1028 * Work with the OS to set up the MSIX vectors needed. 1029 * 1030 * Returns 0 on success, negative on failure 1031 **/ 1032static int 1033i40evf_acquire_msix_vectors(struct i40evf_adapter *adapter, int vectors) 1034{ 1035 int err, vector_threshold; 1036 1037 /* We'll want at least 3 (vector_threshold): 1038 * 0) Other (Admin Queue and link, mostly) 1039 * 1) TxQ[0] Cleanup 1040 * 2) RxQ[0] Cleanup 1041 */ 1042 vector_threshold = MIN_MSIX_COUNT; 1043 1044 /* The more we get, the more we will assign to Tx/Rx Cleanup 1045 * for the separate queues...where Rx Cleanup >= Tx Cleanup. 1046 * Right now, we simply care about how many we'll get; we'll 1047 * set them up later while requesting irq's. 1048 */ 1049 err = pci_enable_msix_range(adapter->pdev, adapter->msix_entries, 1050 vector_threshold, vectors); 1051 if (err < 0) { 1052 dev_err(&adapter->pdev->dev, "Unable to allocate MSI-X interrupts\n"); 1053 kfree(adapter->msix_entries); 1054 adapter->msix_entries = NULL; 1055 return err; 1056 } 1057 1058 /* Adjust for only the vectors we'll use, which is minimum 1059 * of max_msix_q_vectors + NONQ_VECS, or the number of 1060 * vectors we were allocated. 1061 */ 1062 adapter->num_msix_vectors = err; 1063 return 0; 1064} 1065 1066/** 1067 * i40evf_free_queues - Free memory for all rings 1068 * @adapter: board private structure to initialize 1069 * 1070 * Free all of the memory associated with queue pairs. 1071 **/ 1072static void i40evf_free_queues(struct i40evf_adapter *adapter) 1073{ 1074 int i; 1075 1076 if (!adapter->vsi_res) 1077 return; 1078 for (i = 0; i < adapter->num_active_queues; i++) { 1079 if (adapter->tx_rings[i]) 1080 kfree_rcu(adapter->tx_rings[i], rcu); 1081 adapter->tx_rings[i] = NULL; 1082 adapter->rx_rings[i] = NULL; 1083 } 1084} 1085 1086/** 1087 * i40evf_alloc_queues - Allocate memory for all rings 1088 * @adapter: board private structure to initialize 1089 * 1090 * We allocate one ring per queue at run-time since we don't know the 1091 * number of queues at compile-time. The polling_netdev array is 1092 * intended for Multiqueue, but should work fine with a single queue. 1093 **/ 1094static int i40evf_alloc_queues(struct i40evf_adapter *adapter) 1095{ 1096 int i; 1097 1098 for (i = 0; i < adapter->num_active_queues; i++) { 1099 struct i40e_ring *tx_ring; 1100 struct i40e_ring *rx_ring; 1101 1102 tx_ring = kzalloc(sizeof(*tx_ring) * 2, GFP_KERNEL); 1103 if (!tx_ring) 1104 goto err_out; 1105 1106 tx_ring->queue_index = i; 1107 tx_ring->netdev = adapter->netdev; 1108 tx_ring->dev = &adapter->pdev->dev; 1109 tx_ring->count = adapter->tx_desc_count; 1110 adapter->tx_rings[i] = tx_ring; 1111 1112 rx_ring = &tx_ring[1]; 1113 rx_ring->queue_index = i; 1114 rx_ring->netdev = adapter->netdev; 1115 rx_ring->dev = &adapter->pdev->dev; 1116 rx_ring->count = adapter->rx_desc_count; 1117 adapter->rx_rings[i] = rx_ring; 1118 } 1119 1120 return 0; 1121 1122err_out: 1123 i40evf_free_queues(adapter); 1124 return -ENOMEM; 1125} 1126 1127/** 1128 * i40evf_set_interrupt_capability - set MSI-X or FAIL if not supported 1129 * @adapter: board private structure to initialize 1130 * 1131 * Attempt to configure the interrupts using the best available 1132 * capabilities of the hardware and the kernel. 1133 **/ 1134static int i40evf_set_interrupt_capability(struct i40evf_adapter *adapter) 1135{ 1136 int vector, v_budget; 1137 int pairs = 0; 1138 int err = 0; 1139 1140 if (!adapter->vsi_res) { 1141 err = -EIO; 1142 goto out; 1143 } 1144 pairs = adapter->num_active_queues; 1145 1146 /* It's easy to be greedy for MSI-X vectors, but it really 1147 * doesn't do us much good if we have a lot more vectors 1148 * than CPU's. So let's be conservative and only ask for 1149 * (roughly) twice the number of vectors as there are CPU's. 1150 */ 1151 v_budget = min_t(int, pairs, (int)(num_online_cpus() * 2)) + NONQ_VECS; 1152 v_budget = min_t(int, v_budget, (int)adapter->vf_res->max_vectors); 1153 1154 adapter->msix_entries = kcalloc(v_budget, 1155 sizeof(struct msix_entry), GFP_KERNEL); 1156 if (!adapter->msix_entries) { 1157 err = -ENOMEM; 1158 goto out; 1159 } 1160 1161 for (vector = 0; vector < v_budget; vector++) 1162 adapter->msix_entries[vector].entry = vector; 1163 1164 i40evf_acquire_msix_vectors(adapter, v_budget); 1165 1166out: 1167 adapter->netdev->real_num_tx_queues = pairs; 1168 return err; 1169} 1170 1171/** 1172 * i40evf_alloc_q_vectors - Allocate memory for interrupt vectors 1173 * @adapter: board private structure to initialize 1174 * 1175 * We allocate one q_vector per queue interrupt. If allocation fails we 1176 * return -ENOMEM. 1177 **/ 1178static int i40evf_alloc_q_vectors(struct i40evf_adapter *adapter) 1179{ 1180 int q_idx, num_q_vectors; 1181 struct i40e_q_vector *q_vector; 1182 1183 num_q_vectors = adapter->num_msix_vectors - NONQ_VECS; 1184 1185 for (q_idx = 0; q_idx < num_q_vectors; q_idx++) { 1186 q_vector = kzalloc(sizeof(*q_vector), GFP_KERNEL); 1187 if (!q_vector) 1188 goto err_out; 1189 q_vector->adapter = adapter; 1190 q_vector->vsi = &adapter->vsi; 1191 q_vector->v_idx = q_idx; 1192 netif_napi_add(adapter->netdev, &q_vector->napi, 1193 i40evf_napi_poll, NAPI_POLL_WEIGHT); 1194 adapter->q_vector[q_idx] = q_vector; 1195 } 1196 1197 return 0; 1198 1199err_out: 1200 while (q_idx) { 1201 q_idx--; 1202 q_vector = adapter->q_vector[q_idx]; 1203 netif_napi_del(&q_vector->napi); 1204 kfree(q_vector); 1205 adapter->q_vector[q_idx] = NULL; 1206 } 1207 return -ENOMEM; 1208} 1209 1210/** 1211 * i40evf_free_q_vectors - Free memory allocated for interrupt vectors 1212 * @adapter: board private structure to initialize 1213 * 1214 * This function frees the memory allocated to the q_vectors. In addition if 1215 * NAPI is enabled it will delete any references to the NAPI struct prior 1216 * to freeing the q_vector. 1217 **/ 1218static void i40evf_free_q_vectors(struct i40evf_adapter *adapter) 1219{ 1220 int q_idx, num_q_vectors; 1221 int napi_vectors; 1222 1223 num_q_vectors = adapter->num_msix_vectors - NONQ_VECS; 1224 napi_vectors = adapter->num_active_queues; 1225 1226 for (q_idx = 0; q_idx < num_q_vectors; q_idx++) { 1227 struct i40e_q_vector *q_vector = adapter->q_vector[q_idx]; 1228 1229 adapter->q_vector[q_idx] = NULL; 1230 if (q_idx < napi_vectors) 1231 netif_napi_del(&q_vector->napi); 1232 kfree(q_vector); 1233 } 1234} 1235 1236/** 1237 * i40evf_reset_interrupt_capability - Reset MSIX setup 1238 * @adapter: board private structure 1239 * 1240 **/ 1241void i40evf_reset_interrupt_capability(struct i40evf_adapter *adapter) 1242{ 1243 pci_disable_msix(adapter->pdev); 1244 kfree(adapter->msix_entries); 1245 adapter->msix_entries = NULL; 1246} 1247 1248/** 1249 * i40evf_init_interrupt_scheme - Determine if MSIX is supported and init 1250 * @adapter: board private structure to initialize 1251 * 1252 **/ 1253int i40evf_init_interrupt_scheme(struct i40evf_adapter *adapter) 1254{ 1255 int err; 1256 1257 err = i40evf_set_interrupt_capability(adapter); 1258 if (err) { 1259 dev_err(&adapter->pdev->dev, 1260 "Unable to setup interrupt capabilities\n"); 1261 goto err_set_interrupt; 1262 } 1263 1264 err = i40evf_alloc_q_vectors(adapter); 1265 if (err) { 1266 dev_err(&adapter->pdev->dev, 1267 "Unable to allocate memory for queue vectors\n"); 1268 goto err_alloc_q_vectors; 1269 } 1270 1271 err = i40evf_alloc_queues(adapter); 1272 if (err) { 1273 dev_err(&adapter->pdev->dev, 1274 "Unable to allocate memory for queues\n"); 1275 goto err_alloc_queues; 1276 } 1277 1278 dev_info(&adapter->pdev->dev, "Multiqueue %s: Queue pair count = %u", 1279 (adapter->num_active_queues > 1) ? "Enabled" : "Disabled", 1280 adapter->num_active_queues); 1281 1282 return 0; 1283err_alloc_queues: 1284 i40evf_free_q_vectors(adapter); 1285err_alloc_q_vectors: 1286 i40evf_reset_interrupt_capability(adapter); 1287err_set_interrupt: 1288 return err; 1289} 1290 1291/** 1292 * i40evf_watchdog_timer - Periodic call-back timer 1293 * @data: pointer to adapter disguised as unsigned long 1294 **/ 1295static void i40evf_watchdog_timer(unsigned long data) 1296{ 1297 struct i40evf_adapter *adapter = (struct i40evf_adapter *)data; 1298 1299 schedule_work(&adapter->watchdog_task); 1300 /* timer will be rescheduled in watchdog task */ 1301} 1302 1303/** 1304 * i40evf_watchdog_task - Periodic call-back task 1305 * @work: pointer to work_struct 1306 **/ 1307static void i40evf_watchdog_task(struct work_struct *work) 1308{ 1309 struct i40evf_adapter *adapter = container_of(work, 1310 struct i40evf_adapter, 1311 watchdog_task); 1312 struct i40e_hw *hw = &adapter->hw; 1313 uint32_t rstat_val; 1314 1315 if (test_and_set_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section)) 1316 goto restart_watchdog; 1317 1318 if (adapter->flags & I40EVF_FLAG_PF_COMMS_FAILED) { 1319 rstat_val = rd32(hw, I40E_VFGEN_RSTAT) & 1320 I40E_VFGEN_RSTAT_VFR_STATE_MASK; 1321 if ((rstat_val == I40E_VFR_VFACTIVE) || 1322 (rstat_val == I40E_VFR_COMPLETED)) { 1323 /* A chance for redemption! */ 1324 dev_err(&adapter->pdev->dev, "Hardware came out of reset. Attempting reinit.\n"); 1325 adapter->state = __I40EVF_STARTUP; 1326 adapter->flags &= ~I40EVF_FLAG_PF_COMMS_FAILED; 1327 schedule_delayed_work(&adapter->init_task, 10); 1328 clear_bit(__I40EVF_IN_CRITICAL_TASK, 1329 &adapter->crit_section); 1330 /* Don't reschedule the watchdog, since we've restarted 1331 * the init task. When init_task contacts the PF and 1332 * gets everything set up again, it'll restart the 1333 * watchdog for us. Down, boy. Sit. Stay. Woof. 1334 */ 1335 return; 1336 } 1337 adapter->aq_required = 0; 1338 adapter->current_op = I40E_VIRTCHNL_OP_UNKNOWN; 1339 goto watchdog_done; 1340 } 1341 1342 if ((adapter->state < __I40EVF_DOWN) || 1343 (adapter->flags & I40EVF_FLAG_RESET_PENDING)) 1344 goto watchdog_done; 1345 1346 /* check for reset */ 1347 rstat_val = rd32(hw, I40E_VFGEN_RSTAT) & 1348 I40E_VFGEN_RSTAT_VFR_STATE_MASK; 1349 if (!(adapter->flags & I40EVF_FLAG_RESET_PENDING) && 1350 (rstat_val != I40E_VFR_VFACTIVE) && 1351 (rstat_val != I40E_VFR_COMPLETED)) { 1352 adapter->state = __I40EVF_RESETTING; 1353 adapter->flags |= I40EVF_FLAG_RESET_PENDING; 1354 dev_err(&adapter->pdev->dev, "Hardware reset detected\n"); 1355 schedule_work(&adapter->reset_task); 1356 adapter->aq_required = 0; 1357 adapter->current_op = I40E_VIRTCHNL_OP_UNKNOWN; 1358 goto watchdog_done; 1359 } 1360 1361 /* Process admin queue tasks. After init, everything gets done 1362 * here so we don't race on the admin queue. 1363 */ 1364 if (adapter->current_op) { 1365 if (!i40evf_asq_done(hw)) { 1366 dev_dbg(&adapter->pdev->dev, "Admin queue timeout\n"); 1367 i40evf_send_api_ver(adapter); 1368 } 1369 goto watchdog_done; 1370 } 1371 1372 if (adapter->aq_required & I40EVF_FLAG_AQ_DISABLE_QUEUES) { 1373 i40evf_disable_queues(adapter); 1374 goto watchdog_done; 1375 } 1376 1377 if (adapter->aq_required & I40EVF_FLAG_AQ_MAP_VECTORS) { 1378 i40evf_map_queues(adapter); 1379 goto watchdog_done; 1380 } 1381 1382 if (adapter->aq_required & I40EVF_FLAG_AQ_ADD_MAC_FILTER) { 1383 i40evf_add_ether_addrs(adapter); 1384 goto watchdog_done; 1385 } 1386 1387 if (adapter->aq_required & I40EVF_FLAG_AQ_ADD_VLAN_FILTER) { 1388 i40evf_add_vlans(adapter); 1389 goto watchdog_done; 1390 } 1391 1392 if (adapter->aq_required & I40EVF_FLAG_AQ_DEL_MAC_FILTER) { 1393 i40evf_del_ether_addrs(adapter); 1394 goto watchdog_done; 1395 } 1396 1397 if (adapter->aq_required & I40EVF_FLAG_AQ_DEL_VLAN_FILTER) { 1398 i40evf_del_vlans(adapter); 1399 goto watchdog_done; 1400 } 1401 1402 if (adapter->aq_required & I40EVF_FLAG_AQ_CONFIGURE_QUEUES) { 1403 i40evf_configure_queues(adapter); 1404 goto watchdog_done; 1405 } 1406 1407 if (adapter->aq_required & I40EVF_FLAG_AQ_ENABLE_QUEUES) { 1408 i40evf_enable_queues(adapter); 1409 goto watchdog_done; 1410 } 1411 1412 if (adapter->state == __I40EVF_RUNNING) 1413 i40evf_request_stats(adapter); 1414watchdog_done: 1415 if (adapter->state == __I40EVF_RUNNING) { 1416 i40evf_irq_enable_queues(adapter, ~0); 1417 i40evf_fire_sw_int(adapter, 0xFF); 1418 } else { 1419 i40evf_fire_sw_int(adapter, 0x1); 1420 } 1421 1422 clear_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section); 1423restart_watchdog: 1424 if (adapter->state == __I40EVF_REMOVE) 1425 return; 1426 if (adapter->aq_required) 1427 mod_timer(&adapter->watchdog_timer, 1428 jiffies + msecs_to_jiffies(20)); 1429 else 1430 mod_timer(&adapter->watchdog_timer, jiffies + (HZ * 2)); 1431 schedule_work(&adapter->adminq_task); 1432} 1433 1434/** 1435 * i40evf_configure_rss - Prepare for RSS 1436 * @adapter: board private structure 1437 **/ 1438static void i40evf_configure_rss(struct i40evf_adapter *adapter) 1439{ 1440 u32 rss_key[I40E_VFQF_HKEY_MAX_INDEX + 1]; 1441 struct i40e_hw *hw = &adapter->hw; 1442 u32 cqueue = 0; 1443 u32 lut = 0; 1444 int i, j; 1445 u64 hena; 1446 1447 /* Hash type is configured by the PF - we just supply the key */ 1448 netdev_rss_key_fill(rss_key, sizeof(rss_key)); 1449 1450 /* Fill out hash function seed */ 1451 for (i = 0; i <= I40E_VFQF_HKEY_MAX_INDEX; i++) 1452 wr32(hw, I40E_VFQF_HKEY(i), rss_key[i]); 1453 1454 /* Enable PCTYPES for RSS, TCP/UDP with IPv4/IPv6 */ 1455 hena = I40E_DEFAULT_RSS_HENA; 1456 wr32(hw, I40E_VFQF_HENA(0), (u32)hena); 1457 wr32(hw, I40E_VFQF_HENA(1), (u32)(hena >> 32)); 1458 1459 /* Populate the LUT with max no. of queues in round robin fashion */ 1460 for (i = 0; i <= I40E_VFQF_HLUT_MAX_INDEX; i++) { 1461 lut = 0; 1462 for (j = 0; j < 4; j++) { 1463 if (cqueue == adapter->vsi_res->num_queue_pairs) 1464 cqueue = 0; 1465 lut |= ((cqueue) << (8 * j)); 1466 cqueue++; 1467 } 1468 wr32(hw, I40E_VFQF_HLUT(i), lut); 1469 } 1470 i40e_flush(hw); 1471} 1472 1473#define I40EVF_RESET_WAIT_MS 100 1474#define I40EVF_RESET_WAIT_COUNT 200 1475/** 1476 * i40evf_reset_task - Call-back task to handle hardware reset 1477 * @work: pointer to work_struct 1478 * 1479 * During reset we need to shut down and reinitialize the admin queue 1480 * before we can use it to communicate with the PF again. We also clear 1481 * and reinit the rings because that context is lost as well. 1482 **/ 1483static void i40evf_reset_task(struct work_struct *work) 1484{ 1485 struct i40evf_adapter *adapter = container_of(work, 1486 struct i40evf_adapter, 1487 reset_task); 1488 struct net_device *netdev = adapter->netdev; 1489 struct i40e_hw *hw = &adapter->hw; 1490 struct i40evf_mac_filter *f; 1491 uint32_t rstat_val; 1492 int i = 0, err; 1493 1494 while (test_and_set_bit(__I40EVF_IN_CRITICAL_TASK, 1495 &adapter->crit_section)) 1496 usleep_range(500, 1000); 1497 1498 if (adapter->flags & I40EVF_FLAG_RESET_NEEDED) { 1499 dev_info(&adapter->pdev->dev, "Requesting reset from PF\n"); 1500 i40evf_request_reset(adapter); 1501 } 1502 1503 /* poll until we see the reset actually happen */ 1504 for (i = 0; i < I40EVF_RESET_WAIT_COUNT; i++) { 1505 rstat_val = rd32(hw, I40E_VFGEN_RSTAT) & 1506 I40E_VFGEN_RSTAT_VFR_STATE_MASK; 1507 if ((rstat_val != I40E_VFR_VFACTIVE) && 1508 (rstat_val != I40E_VFR_COMPLETED)) 1509 break; 1510 msleep(I40EVF_RESET_WAIT_MS); 1511 } 1512 if (i == I40EVF_RESET_WAIT_COUNT) { 1513 adapter->flags &= ~I40EVF_FLAG_RESET_PENDING; 1514 goto continue_reset; /* act like the reset happened */ 1515 } 1516 1517 /* wait until the reset is complete and the PF is responding to us */ 1518 for (i = 0; i < I40EVF_RESET_WAIT_COUNT; i++) { 1519 rstat_val = rd32(hw, I40E_VFGEN_RSTAT) & 1520 I40E_VFGEN_RSTAT_VFR_STATE_MASK; 1521 if ((rstat_val == I40E_VFR_VFACTIVE) || 1522 (rstat_val == I40E_VFR_COMPLETED)) 1523 break; 1524 msleep(I40EVF_RESET_WAIT_MS); 1525 } 1526 if (i == I40EVF_RESET_WAIT_COUNT) { 1527 struct i40evf_mac_filter *f, *ftmp; 1528 struct i40evf_vlan_filter *fv, *fvtmp; 1529 1530 /* reset never finished */ 1531 dev_err(&adapter->pdev->dev, "Reset never finished (%x)\n", 1532 rstat_val); 1533 adapter->flags |= I40EVF_FLAG_PF_COMMS_FAILED; 1534 1535 if (netif_running(adapter->netdev)) { 1536 set_bit(__I40E_DOWN, &adapter->vsi.state); 1537 i40evf_irq_disable(adapter); 1538 i40evf_napi_disable_all(adapter); 1539 netif_tx_disable(netdev); 1540 netif_tx_stop_all_queues(netdev); 1541 netif_carrier_off(netdev); 1542 i40evf_free_traffic_irqs(adapter); 1543 i40evf_free_all_tx_resources(adapter); 1544 i40evf_free_all_rx_resources(adapter); 1545 } 1546 1547 /* Delete all of the filters, both MAC and VLAN. */ 1548 list_for_each_entry_safe(f, ftmp, &adapter->mac_filter_list, 1549 list) { 1550 list_del(&f->list); 1551 kfree(f); 1552 } 1553 list_for_each_entry_safe(fv, fvtmp, &adapter->vlan_filter_list, 1554 list) { 1555 list_del(&fv->list); 1556 kfree(fv); 1557 } 1558 1559 i40evf_free_misc_irq(adapter); 1560 i40evf_reset_interrupt_capability(adapter); 1561 i40evf_free_queues(adapter); 1562 i40evf_free_q_vectors(adapter); 1563 kfree(adapter->vf_res); 1564 i40evf_shutdown_adminq(hw); 1565 adapter->netdev->flags &= ~IFF_UP; 1566 clear_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section); 1567 return; /* Do not attempt to reinit. It's dead, Jim. */ 1568 } 1569 1570continue_reset: 1571 adapter->flags &= ~I40EVF_FLAG_RESET_PENDING; 1572 1573 i40evf_irq_disable(adapter); 1574 1575 if (netif_running(adapter->netdev)) { 1576 i40evf_napi_disable_all(adapter); 1577 netif_tx_disable(netdev); 1578 netif_tx_stop_all_queues(netdev); 1579 netif_carrier_off(netdev); 1580 } 1581 1582 adapter->state = __I40EVF_RESETTING; 1583 1584 /* kill and reinit the admin queue */ 1585 if (i40evf_shutdown_adminq(hw)) 1586 dev_warn(&adapter->pdev->dev, "Failed to shut down adminq\n"); 1587 adapter->current_op = I40E_VIRTCHNL_OP_UNKNOWN; 1588 err = i40evf_init_adminq(hw); 1589 if (err) 1590 dev_info(&adapter->pdev->dev, "Failed to init adminq: %d\n", 1591 err); 1592 1593 i40evf_map_queues(adapter); 1594 1595 /* re-add all MAC filters */ 1596 list_for_each_entry(f, &adapter->mac_filter_list, list) { 1597 f->add = true; 1598 } 1599 /* re-add all VLAN filters */ 1600 list_for_each_entry(f, &adapter->vlan_filter_list, list) { 1601 f->add = true; 1602 } 1603 adapter->aq_required = I40EVF_FLAG_AQ_ADD_MAC_FILTER; 1604 adapter->aq_required |= I40EVF_FLAG_AQ_ADD_VLAN_FILTER; 1605 clear_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section); 1606 1607 mod_timer(&adapter->watchdog_timer, jiffies + 2); 1608 1609 if (netif_running(adapter->netdev)) { 1610 /* allocate transmit descriptors */ 1611 err = i40evf_setup_all_tx_resources(adapter); 1612 if (err) 1613 goto reset_err; 1614 1615 /* allocate receive descriptors */ 1616 err = i40evf_setup_all_rx_resources(adapter); 1617 if (err) 1618 goto reset_err; 1619 1620 i40evf_configure(adapter); 1621 1622 err = i40evf_up_complete(adapter); 1623 if (err) 1624 goto reset_err; 1625 1626 i40evf_irq_enable(adapter, true); 1627 } 1628 return; 1629reset_err: 1630 dev_err(&adapter->pdev->dev, "failed to allocate resources during reinit\n"); 1631 i40evf_close(adapter->netdev); 1632} 1633 1634/** 1635 * i40evf_adminq_task - worker thread to clean the admin queue 1636 * @work: pointer to work_struct containing our data 1637 **/ 1638static void i40evf_adminq_task(struct work_struct *work) 1639{ 1640 struct i40evf_adapter *adapter = 1641 container_of(work, struct i40evf_adapter, adminq_task); 1642 struct i40e_hw *hw = &adapter->hw; 1643 struct i40e_arq_event_info event; 1644 struct i40e_virtchnl_msg *v_msg; 1645 i40e_status ret; 1646 u32 val, oldval; 1647 u16 pending; 1648 1649 if (adapter->flags & I40EVF_FLAG_PF_COMMS_FAILED) 1650 goto out; 1651 1652 event.buf_len = I40EVF_MAX_AQ_BUF_SIZE; 1653 event.msg_buf = kzalloc(event.buf_len, GFP_KERNEL); 1654 if (!event.msg_buf) 1655 goto out; 1656 1657 v_msg = (struct i40e_virtchnl_msg *)&event.desc; 1658 do { 1659 ret = i40evf_clean_arq_element(hw, &event, &pending); 1660 if (ret || !v_msg->v_opcode) 1661 break; /* No event to process or error cleaning ARQ */ 1662 1663 i40evf_virtchnl_completion(adapter, v_msg->v_opcode, 1664 v_msg->v_retval, event.msg_buf, 1665 event.msg_len); 1666 if (pending != 0) 1667 memset(event.msg_buf, 0, I40EVF_MAX_AQ_BUF_SIZE); 1668 } while (pending); 1669 1670 /* check for error indications */ 1671 val = rd32(hw, hw->aq.arq.len); 1672 oldval = val; 1673 if (val & I40E_VF_ARQLEN_ARQVFE_MASK) { 1674 dev_info(&adapter->pdev->dev, "ARQ VF Error detected\n"); 1675 val &= ~I40E_VF_ARQLEN_ARQVFE_MASK; 1676 } 1677 if (val & I40E_VF_ARQLEN_ARQOVFL_MASK) { 1678 dev_info(&adapter->pdev->dev, "ARQ Overflow Error detected\n"); 1679 val &= ~I40E_VF_ARQLEN_ARQOVFL_MASK; 1680 } 1681 if (val & I40E_VF_ARQLEN_ARQCRIT_MASK) { 1682 dev_info(&adapter->pdev->dev, "ARQ Critical Error detected\n"); 1683 val &= ~I40E_VF_ARQLEN_ARQCRIT_MASK; 1684 } 1685 if (oldval != val) 1686 wr32(hw, hw->aq.arq.len, val); 1687 1688 val = rd32(hw, hw->aq.asq.len); 1689 oldval = val; 1690 if (val & I40E_VF_ATQLEN_ATQVFE_MASK) { 1691 dev_info(&adapter->pdev->dev, "ASQ VF Error detected\n"); 1692 val &= ~I40E_VF_ATQLEN_ATQVFE_MASK; 1693 } 1694 if (val & I40E_VF_ATQLEN_ATQOVFL_MASK) { 1695 dev_info(&adapter->pdev->dev, "ASQ Overflow Error detected\n"); 1696 val &= ~I40E_VF_ATQLEN_ATQOVFL_MASK; 1697 } 1698 if (val & I40E_VF_ATQLEN_ATQCRIT_MASK) { 1699 dev_info(&adapter->pdev->dev, "ASQ Critical Error detected\n"); 1700 val &= ~I40E_VF_ATQLEN_ATQCRIT_MASK; 1701 } 1702 if (oldval != val) 1703 wr32(hw, hw->aq.asq.len, val); 1704 1705 kfree(event.msg_buf); 1706out: 1707 /* re-enable Admin queue interrupt cause */ 1708 i40evf_misc_irq_enable(adapter); 1709} 1710 1711/** 1712 * i40evf_free_all_tx_resources - Free Tx Resources for All Queues 1713 * @adapter: board private structure 1714 * 1715 * Free all transmit software resources 1716 **/ 1717void i40evf_free_all_tx_resources(struct i40evf_adapter *adapter) 1718{ 1719 int i; 1720 1721 for (i = 0; i < adapter->num_active_queues; i++) 1722 if (adapter->tx_rings[i]->desc) 1723 i40evf_free_tx_resources(adapter->tx_rings[i]); 1724} 1725 1726/** 1727 * i40evf_setup_all_tx_resources - allocate all queues Tx resources 1728 * @adapter: board private structure 1729 * 1730 * If this function returns with an error, then it's possible one or 1731 * more of the rings is populated (while the rest are not). It is the 1732 * callers duty to clean those orphaned rings. 1733 * 1734 * Return 0 on success, negative on failure 1735 **/ 1736static int i40evf_setup_all_tx_resources(struct i40evf_adapter *adapter) 1737{ 1738 int i, err = 0; 1739 1740 for (i = 0; i < adapter->num_active_queues; i++) { 1741 adapter->tx_rings[i]->count = adapter->tx_desc_count; 1742 err = i40evf_setup_tx_descriptors(adapter->tx_rings[i]); 1743 if (!err) 1744 continue; 1745 dev_err(&adapter->pdev->dev, 1746 "%s: Allocation for Tx Queue %u failed\n", 1747 __func__, i); 1748 break; 1749 } 1750 1751 return err; 1752} 1753 1754/** 1755 * i40evf_setup_all_rx_resources - allocate all queues Rx resources 1756 * @adapter: board private structure 1757 * 1758 * If this function returns with an error, then it's possible one or 1759 * more of the rings is populated (while the rest are not). It is the 1760 * callers duty to clean those orphaned rings. 1761 * 1762 * Return 0 on success, negative on failure 1763 **/ 1764static int i40evf_setup_all_rx_resources(struct i40evf_adapter *adapter) 1765{ 1766 int i, err = 0; 1767 1768 for (i = 0; i < adapter->num_active_queues; i++) { 1769 adapter->rx_rings[i]->count = adapter->rx_desc_count; 1770 err = i40evf_setup_rx_descriptors(adapter->rx_rings[i]); 1771 if (!err) 1772 continue; 1773 dev_err(&adapter->pdev->dev, 1774 "%s: Allocation for Rx Queue %u failed\n", 1775 __func__, i); 1776 break; 1777 } 1778 return err; 1779} 1780 1781/** 1782 * i40evf_free_all_rx_resources - Free Rx Resources for All Queues 1783 * @adapter: board private structure 1784 * 1785 * Free all receive software resources 1786 **/ 1787void i40evf_free_all_rx_resources(struct i40evf_adapter *adapter) 1788{ 1789 int i; 1790 1791 for (i = 0; i < adapter->num_active_queues; i++) 1792 if (adapter->rx_rings[i]->desc) 1793 i40evf_free_rx_resources(adapter->rx_rings[i]); 1794} 1795 1796/** 1797 * i40evf_open - Called when a network interface is made active 1798 * @netdev: network interface device structure 1799 * 1800 * Returns 0 on success, negative value on failure 1801 * 1802 * The open entry point is called when a network interface is made 1803 * active by the system (IFF_UP). At this point all resources needed 1804 * for transmit and receive operations are allocated, the interrupt 1805 * handler is registered with the OS, the watchdog timer is started, 1806 * and the stack is notified that the interface is ready. 1807 **/ 1808static int i40evf_open(struct net_device *netdev) 1809{ 1810 struct i40evf_adapter *adapter = netdev_priv(netdev); 1811 int err; 1812 1813 if (adapter->flags & I40EVF_FLAG_PF_COMMS_FAILED) { 1814 dev_err(&adapter->pdev->dev, "Unable to open device due to PF driver failure.\n"); 1815 return -EIO; 1816 } 1817 if (adapter->state != __I40EVF_DOWN || adapter->aq_required) 1818 return -EBUSY; 1819 1820 /* allocate transmit descriptors */ 1821 err = i40evf_setup_all_tx_resources(adapter); 1822 if (err) 1823 goto err_setup_tx; 1824 1825 /* allocate receive descriptors */ 1826 err = i40evf_setup_all_rx_resources(adapter); 1827 if (err) 1828 goto err_setup_rx; 1829 1830 /* clear any pending interrupts, may auto mask */ 1831 err = i40evf_request_traffic_irqs(adapter, netdev->name); 1832 if (err) 1833 goto err_req_irq; 1834 1835 i40evf_configure(adapter); 1836 1837 err = i40evf_up_complete(adapter); 1838 if (err) 1839 goto err_req_irq; 1840 1841 i40evf_irq_enable(adapter, true); 1842 1843 return 0; 1844 1845err_req_irq: 1846 i40evf_down(adapter); 1847 i40evf_free_traffic_irqs(adapter); 1848err_setup_rx: 1849 i40evf_free_all_rx_resources(adapter); 1850err_setup_tx: 1851 i40evf_free_all_tx_resources(adapter); 1852 1853 return err; 1854} 1855 1856/** 1857 * i40evf_close - Disables a network interface 1858 * @netdev: network interface device structure 1859 * 1860 * Returns 0, this is not allowed to fail 1861 * 1862 * The close entry point is called when an interface is de-activated 1863 * by the OS. The hardware is still under the drivers control, but 1864 * needs to be disabled. All IRQs except vector 0 (reserved for admin queue) 1865 * are freed, along with all transmit and receive resources. 1866 **/ 1867static int i40evf_close(struct net_device *netdev) 1868{ 1869 struct i40evf_adapter *adapter = netdev_priv(netdev); 1870 1871 if (adapter->state <= __I40EVF_DOWN) 1872 return 0; 1873 1874 1875 set_bit(__I40E_DOWN, &adapter->vsi.state); 1876 1877 i40evf_down(adapter); 1878 adapter->state = __I40EVF_DOWN; 1879 i40evf_free_traffic_irqs(adapter); 1880 1881 return 0; 1882} 1883 1884/** 1885 * i40evf_get_stats - Get System Network Statistics 1886 * @netdev: network interface device structure 1887 * 1888 * Returns the address of the device statistics structure. 1889 * The statistics are actually updated from the timer callback. 1890 **/ 1891static struct net_device_stats *i40evf_get_stats(struct net_device *netdev) 1892{ 1893 struct i40evf_adapter *adapter = netdev_priv(netdev); 1894 1895 /* only return the current stats */ 1896 return &adapter->net_stats; 1897} 1898 1899/** 1900 * i40evf_reinit_locked - Software reinit 1901 * @adapter: board private structure 1902 * 1903 * Reinititalizes the ring structures in response to a software configuration 1904 * change. Roughly the same as close followed by open, but skips releasing 1905 * and reallocating the interrupts. 1906 **/ 1907void i40evf_reinit_locked(struct i40evf_adapter *adapter) 1908{ 1909 struct net_device *netdev = adapter->netdev; 1910 int err; 1911 1912 WARN_ON(in_interrupt()); 1913 1914 i40evf_down(adapter); 1915 1916 /* allocate transmit descriptors */ 1917 err = i40evf_setup_all_tx_resources(adapter); 1918 if (err) 1919 goto err_reinit; 1920 1921 /* allocate receive descriptors */ 1922 err = i40evf_setup_all_rx_resources(adapter); 1923 if (err) 1924 goto err_reinit; 1925 1926 i40evf_configure(adapter); 1927 1928 err = i40evf_up_complete(adapter); 1929 if (err) 1930 goto err_reinit; 1931 1932 i40evf_irq_enable(adapter, true); 1933 return; 1934 1935err_reinit: 1936 dev_err(&adapter->pdev->dev, "failed to allocate resources during reinit\n"); 1937 i40evf_close(netdev); 1938} 1939 1940/** 1941 * i40evf_change_mtu - Change the Maximum Transfer Unit 1942 * @netdev: network interface device structure 1943 * @new_mtu: new value for maximum frame size 1944 * 1945 * Returns 0 on success, negative on failure 1946 **/ 1947static int i40evf_change_mtu(struct net_device *netdev, int new_mtu) 1948{ 1949 struct i40evf_adapter *adapter = netdev_priv(netdev); 1950 int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN; 1951 1952 if ((new_mtu < 68) || (max_frame > I40E_MAX_RXBUFFER)) 1953 return -EINVAL; 1954 1955 /* must set new MTU before calling down or up */ 1956 netdev->mtu = new_mtu; 1957 i40evf_reinit_locked(adapter); 1958 return 0; 1959} 1960 1961static const struct net_device_ops i40evf_netdev_ops = { 1962 .ndo_open = i40evf_open, 1963 .ndo_stop = i40evf_close, 1964 .ndo_start_xmit = i40evf_xmit_frame, 1965 .ndo_get_stats = i40evf_get_stats, 1966 .ndo_set_rx_mode = i40evf_set_rx_mode, 1967 .ndo_validate_addr = eth_validate_addr, 1968 .ndo_set_mac_address = i40evf_set_mac, 1969 .ndo_change_mtu = i40evf_change_mtu, 1970 .ndo_tx_timeout = i40evf_tx_timeout, 1971 .ndo_vlan_rx_add_vid = i40evf_vlan_rx_add_vid, 1972 .ndo_vlan_rx_kill_vid = i40evf_vlan_rx_kill_vid, 1973}; 1974 1975/** 1976 * i40evf_check_reset_complete - check that VF reset is complete 1977 * @hw: pointer to hw struct 1978 * 1979 * Returns 0 if device is ready to use, or -EBUSY if it's in reset. 1980 **/ 1981static int i40evf_check_reset_complete(struct i40e_hw *hw) 1982{ 1983 u32 rstat; 1984 int i; 1985 1986 for (i = 0; i < 100; i++) { 1987 rstat = rd32(hw, I40E_VFGEN_RSTAT) & 1988 I40E_VFGEN_RSTAT_VFR_STATE_MASK; 1989 if ((rstat == I40E_VFR_VFACTIVE) || 1990 (rstat == I40E_VFR_COMPLETED)) 1991 return 0; 1992 usleep_range(10, 20); 1993 } 1994 return -EBUSY; 1995} 1996 1997/** 1998 * i40evf_init_task - worker thread to perform delayed initialization 1999 * @work: pointer to work_struct containing our data 2000 * 2001 * This task completes the work that was begun in probe. Due to the nature 2002 * of VF-PF communications, we may need to wait tens of milliseconds to get 2003 * responses back from the PF. Rather than busy-wait in probe and bog down the 2004 * whole system, we'll do it in a task so we can sleep. 2005 * This task only runs during driver init. Once we've established 2006 * communications with the PF driver and set up our netdev, the watchdog 2007 * takes over. 2008 **/ 2009static void i40evf_init_task(struct work_struct *work) 2010{ 2011 struct i40evf_adapter *adapter = container_of(work, 2012 struct i40evf_adapter, 2013 init_task.work); 2014 struct net_device *netdev = adapter->netdev; 2015 struct i40evf_mac_filter *f; 2016 struct i40e_hw *hw = &adapter->hw; 2017 struct pci_dev *pdev = adapter->pdev; 2018 int i, err, bufsz; 2019 2020 switch (adapter->state) { 2021 case __I40EVF_STARTUP: 2022 /* driver loaded, probe complete */ 2023 adapter->flags &= ~I40EVF_FLAG_PF_COMMS_FAILED; 2024 adapter->flags &= ~I40EVF_FLAG_RESET_PENDING; 2025 err = i40e_set_mac_type(hw); 2026 if (err) { 2027 dev_err(&pdev->dev, "Failed to set MAC type (%d)\n", 2028 err); 2029 goto err; 2030 } 2031 err = i40evf_check_reset_complete(hw); 2032 if (err) { 2033 dev_info(&pdev->dev, "Device is still in reset (%d), retrying\n", 2034 err); 2035 goto err; 2036 } 2037 hw->aq.num_arq_entries = I40EVF_AQ_LEN; 2038 hw->aq.num_asq_entries = I40EVF_AQ_LEN; 2039 hw->aq.arq_buf_size = I40EVF_MAX_AQ_BUF_SIZE; 2040 hw->aq.asq_buf_size = I40EVF_MAX_AQ_BUF_SIZE; 2041 2042 err = i40evf_init_adminq(hw); 2043 if (err) { 2044 dev_err(&pdev->dev, "Failed to init Admin Queue (%d)\n", 2045 err); 2046 goto err; 2047 } 2048 err = i40evf_send_api_ver(adapter); 2049 if (err) { 2050 dev_err(&pdev->dev, "Unable to send to PF (%d)\n", err); 2051 i40evf_shutdown_adminq(hw); 2052 goto err; 2053 } 2054 adapter->state = __I40EVF_INIT_VERSION_CHECK; 2055 goto restart; 2056 case __I40EVF_INIT_VERSION_CHECK: 2057 if (!i40evf_asq_done(hw)) { 2058 dev_err(&pdev->dev, "Admin queue command never completed\n"); 2059 i40evf_shutdown_adminq(hw); 2060 adapter->state = __I40EVF_STARTUP; 2061 goto err; 2062 } 2063 2064 /* aq msg sent, awaiting reply */ 2065 err = i40evf_verify_api_ver(adapter); 2066 if (err) { 2067 if (err == I40E_ERR_ADMIN_QUEUE_NO_WORK) 2068 err = i40evf_send_api_ver(adapter); 2069 goto err; 2070 } 2071 err = i40evf_send_vf_config_msg(adapter); 2072 if (err) { 2073 dev_err(&pdev->dev, "Unable to send config request (%d)\n", 2074 err); 2075 goto err; 2076 } 2077 adapter->state = __I40EVF_INIT_GET_RESOURCES; 2078 goto restart; 2079 case __I40EVF_INIT_GET_RESOURCES: 2080 /* aq msg sent, awaiting reply */ 2081 if (!adapter->vf_res) { 2082 bufsz = sizeof(struct i40e_virtchnl_vf_resource) + 2083 (I40E_MAX_VF_VSI * 2084 sizeof(struct i40e_virtchnl_vsi_resource)); 2085 adapter->vf_res = kzalloc(bufsz, GFP_KERNEL); 2086 if (!adapter->vf_res) 2087 goto err; 2088 } 2089 err = i40evf_get_vf_config(adapter); 2090 if (err == I40E_ERR_ADMIN_QUEUE_NO_WORK) { 2091 err = i40evf_send_vf_config_msg(adapter); 2092 goto err; 2093 } 2094 if (err) { 2095 dev_err(&pdev->dev, "Unable to get VF config (%d)\n", 2096 err); 2097 goto err_alloc; 2098 } 2099 adapter->state = __I40EVF_INIT_SW; 2100 break; 2101 default: 2102 goto err_alloc; 2103 } 2104 /* got VF config message back from PF, now we can parse it */ 2105 for (i = 0; i < adapter->vf_res->num_vsis; i++) { 2106 if (adapter->vf_res->vsi_res[i].vsi_type == I40E_VSI_SRIOV) 2107 adapter->vsi_res = &adapter->vf_res->vsi_res[i]; 2108 } 2109 if (!adapter->vsi_res) { 2110 dev_err(&pdev->dev, "No LAN VSI found\n"); 2111 goto err_alloc; 2112 } 2113 2114 adapter->flags |= I40EVF_FLAG_RX_CSUM_ENABLED; 2115 2116 netdev->netdev_ops = &i40evf_netdev_ops; 2117 i40evf_set_ethtool_ops(netdev); 2118 netdev->watchdog_timeo = 5 * HZ; 2119 netdev->features |= NETIF_F_HIGHDMA | 2120 NETIF_F_SG | 2121 NETIF_F_IP_CSUM | 2122 NETIF_F_SCTP_CSUM | 2123 NETIF_F_IPV6_CSUM | 2124 NETIF_F_TSO | 2125 NETIF_F_TSO6 | 2126 NETIF_F_RXCSUM | 2127 NETIF_F_GRO; 2128 2129 if (adapter->vf_res->vf_offload_flags 2130 & I40E_VIRTCHNL_VF_OFFLOAD_VLAN) { 2131 netdev->vlan_features = netdev->features; 2132 netdev->features |= NETIF_F_HW_VLAN_CTAG_TX | 2133 NETIF_F_HW_VLAN_CTAG_RX | 2134 NETIF_F_HW_VLAN_CTAG_FILTER; 2135 } 2136 2137 /* copy netdev features into list of user selectable features */ 2138 netdev->hw_features |= netdev->features; 2139 netdev->hw_features &= ~NETIF_F_RXCSUM; 2140 2141 if (!is_valid_ether_addr(adapter->hw.mac.addr)) { 2142 dev_info(&pdev->dev, "Invalid MAC address %pM, using random\n", 2143 adapter->hw.mac.addr); 2144 random_ether_addr(adapter->hw.mac.addr); 2145 } 2146 ether_addr_copy(netdev->dev_addr, adapter->hw.mac.addr); 2147 ether_addr_copy(netdev->perm_addr, adapter->hw.mac.addr); 2148 2149 f = kzalloc(sizeof(*f), GFP_ATOMIC); 2150 if (!f) 2151 goto err_sw_init; 2152 2153 ether_addr_copy(f->macaddr, adapter->hw.mac.addr); 2154 f->add = true; 2155 adapter->aq_required |= I40EVF_FLAG_AQ_ADD_MAC_FILTER; 2156 2157 list_add(&f->list, &adapter->mac_filter_list); 2158 2159 init_timer(&adapter->watchdog_timer); 2160 adapter->watchdog_timer.function = &i40evf_watchdog_timer; 2161 adapter->watchdog_timer.data = (unsigned long)adapter; 2162 mod_timer(&adapter->watchdog_timer, jiffies + 1); 2163 2164 adapter->num_active_queues = min_t(int, 2165 adapter->vsi_res->num_queue_pairs, 2166 (int)(num_online_cpus())); 2167 adapter->tx_desc_count = I40EVF_DEFAULT_TXD; 2168 adapter->rx_desc_count = I40EVF_DEFAULT_RXD; 2169 err = i40evf_init_interrupt_scheme(adapter); 2170 if (err) 2171 goto err_sw_init; 2172 i40evf_map_rings_to_vectors(adapter); 2173 i40evf_configure_rss(adapter); 2174 err = i40evf_request_misc_irq(adapter); 2175 if (err) 2176 goto err_sw_init; 2177 2178 netif_carrier_off(netdev); 2179 2180 adapter->vsi.id = adapter->vsi_res->vsi_id; 2181 adapter->vsi.seid = adapter->vsi_res->vsi_id; /* dummy */ 2182 adapter->vsi.back = adapter; 2183 adapter->vsi.base_vector = 1; 2184 adapter->vsi.work_limit = I40E_DEFAULT_IRQ_WORK; 2185 adapter->vsi.rx_itr_setting = (I40E_ITR_DYNAMIC | 2186 ITR_REG_TO_USEC(I40E_ITR_RX_DEF)); 2187 adapter->vsi.tx_itr_setting = (I40E_ITR_DYNAMIC | 2188 ITR_REG_TO_USEC(I40E_ITR_TX_DEF)); 2189 adapter->vsi.netdev = adapter->netdev; 2190 2191 if (!adapter->netdev_registered) { 2192 err = register_netdev(netdev); 2193 if (err) 2194 goto err_register; 2195 } 2196 2197 adapter->netdev_registered = true; 2198 2199 netif_tx_stop_all_queues(netdev); 2200 2201 dev_info(&pdev->dev, "MAC address: %pM\n", adapter->hw.mac.addr); 2202 if (netdev->features & NETIF_F_GRO) 2203 dev_info(&pdev->dev, "GRO is enabled\n"); 2204 2205 dev_info(&pdev->dev, "%s\n", i40evf_driver_string); 2206 adapter->state = __I40EVF_DOWN; 2207 set_bit(__I40E_DOWN, &adapter->vsi.state); 2208 i40evf_misc_irq_enable(adapter); 2209 return; 2210restart: 2211 schedule_delayed_work(&adapter->init_task, 2212 msecs_to_jiffies(50)); 2213 return; 2214 2215err_register: 2216 i40evf_free_misc_irq(adapter); 2217err_sw_init: 2218 i40evf_reset_interrupt_capability(adapter); 2219err_alloc: 2220 kfree(adapter->vf_res); 2221 adapter->vf_res = NULL; 2222err: 2223 /* Things went into the weeds, so try again later */ 2224 if (++adapter->aq_wait_count > I40EVF_AQ_MAX_ERR) { 2225 dev_err(&pdev->dev, "Failed to communicate with PF; giving up\n"); 2226 adapter->flags |= I40EVF_FLAG_PF_COMMS_FAILED; 2227 return; /* do not reschedule */ 2228 } 2229 schedule_delayed_work(&adapter->init_task, HZ * 3); 2230} 2231 2232/** 2233 * i40evf_shutdown - Shutdown the device in preparation for a reboot 2234 * @pdev: pci device structure 2235 **/ 2236static void i40evf_shutdown(struct pci_dev *pdev) 2237{ 2238 struct net_device *netdev = pci_get_drvdata(pdev); 2239 struct i40evf_adapter *adapter = netdev_priv(netdev); 2240 2241 netif_device_detach(netdev); 2242 2243 if (netif_running(netdev)) 2244 i40evf_close(netdev); 2245 2246 /* Prevent the watchdog from running. */ 2247 adapter->state = __I40EVF_REMOVE; 2248 adapter->aq_required = 0; 2249 2250#ifdef CONFIG_PM 2251 pci_save_state(pdev); 2252 2253#endif 2254 pci_disable_device(pdev); 2255} 2256 2257/** 2258 * i40evf_probe - Device Initialization Routine 2259 * @pdev: PCI device information struct 2260 * @ent: entry in i40evf_pci_tbl 2261 * 2262 * Returns 0 on success, negative on failure 2263 * 2264 * i40evf_probe initializes an adapter identified by a pci_dev structure. 2265 * The OS initialization, configuring of the adapter private structure, 2266 * and a hardware reset occur. 2267 **/ 2268static int i40evf_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 2269{ 2270 struct net_device *netdev; 2271 struct i40evf_adapter *adapter = NULL; 2272 struct i40e_hw *hw = NULL; 2273 int err; 2274 2275 err = pci_enable_device(pdev); 2276 if (err) 2277 return err; 2278 2279 err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)); 2280 if (err) { 2281 err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); 2282 if (err) { 2283 dev_err(&pdev->dev, 2284 "DMA configuration failed: 0x%x\n", err); 2285 goto err_dma; 2286 } 2287 } 2288 2289 err = pci_request_regions(pdev, i40evf_driver_name); 2290 if (err) { 2291 dev_err(&pdev->dev, 2292 "pci_request_regions failed 0x%x\n", err); 2293 goto err_pci_reg; 2294 } 2295 2296 pci_enable_pcie_error_reporting(pdev); 2297 2298 pci_set_master(pdev); 2299 2300 netdev = alloc_etherdev_mq(sizeof(struct i40evf_adapter), 2301 MAX_TX_QUEUES); 2302 if (!netdev) { 2303 err = -ENOMEM; 2304 goto err_alloc_etherdev; 2305 } 2306 2307 SET_NETDEV_DEV(netdev, &pdev->dev); 2308 2309 pci_set_drvdata(pdev, netdev); 2310 adapter = netdev_priv(netdev); 2311 2312 adapter->netdev = netdev; 2313 adapter->pdev = pdev; 2314 2315 hw = &adapter->hw; 2316 hw->back = adapter; 2317 2318 adapter->msg_enable = (1 << DEFAULT_DEBUG_LEVEL_SHIFT) - 1; 2319 adapter->state = __I40EVF_STARTUP; 2320 2321 /* Call save state here because it relies on the adapter struct. */ 2322 pci_save_state(pdev); 2323 2324 hw->hw_addr = ioremap(pci_resource_start(pdev, 0), 2325 pci_resource_len(pdev, 0)); 2326 if (!hw->hw_addr) { 2327 err = -EIO; 2328 goto err_ioremap; 2329 } 2330 hw->vendor_id = pdev->vendor; 2331 hw->device_id = pdev->device; 2332 pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id); 2333 hw->subsystem_vendor_id = pdev->subsystem_vendor; 2334 hw->subsystem_device_id = pdev->subsystem_device; 2335 hw->bus.device = PCI_SLOT(pdev->devfn); 2336 hw->bus.func = PCI_FUNC(pdev->devfn); 2337 2338 INIT_LIST_HEAD(&adapter->mac_filter_list); 2339 INIT_LIST_HEAD(&adapter->vlan_filter_list); 2340 2341 INIT_WORK(&adapter->reset_task, i40evf_reset_task); 2342 INIT_WORK(&adapter->adminq_task, i40evf_adminq_task); 2343 INIT_WORK(&adapter->watchdog_task, i40evf_watchdog_task); 2344 INIT_DELAYED_WORK(&adapter->init_task, i40evf_init_task); 2345 schedule_delayed_work(&adapter->init_task, 10); 2346 2347 return 0; 2348 2349err_ioremap: 2350 free_netdev(netdev); 2351err_alloc_etherdev: 2352 pci_release_regions(pdev); 2353err_pci_reg: 2354err_dma: 2355 pci_disable_device(pdev); 2356 return err; 2357} 2358 2359#ifdef CONFIG_PM 2360/** 2361 * i40evf_suspend - Power management suspend routine 2362 * @pdev: PCI device information struct 2363 * @state: unused 2364 * 2365 * Called when the system (VM) is entering sleep/suspend. 2366 **/ 2367static int i40evf_suspend(struct pci_dev *pdev, pm_message_t state) 2368{ 2369 struct net_device *netdev = pci_get_drvdata(pdev); 2370 struct i40evf_adapter *adapter = netdev_priv(netdev); 2371 int retval = 0; 2372 2373 netif_device_detach(netdev); 2374 2375 if (netif_running(netdev)) { 2376 rtnl_lock(); 2377 i40evf_down(adapter); 2378 rtnl_unlock(); 2379 } 2380 i40evf_free_misc_irq(adapter); 2381 i40evf_reset_interrupt_capability(adapter); 2382 2383 retval = pci_save_state(pdev); 2384 if (retval) 2385 return retval; 2386 2387 pci_disable_device(pdev); 2388 2389 return 0; 2390} 2391 2392/** 2393 * i40evf_resume - Power management resume routine 2394 * @pdev: PCI device information struct 2395 * 2396 * Called when the system (VM) is resumed from sleep/suspend. 2397 **/ 2398static int i40evf_resume(struct pci_dev *pdev) 2399{ 2400 struct i40evf_adapter *adapter = pci_get_drvdata(pdev); 2401 struct net_device *netdev = adapter->netdev; 2402 u32 err; 2403 2404 pci_set_power_state(pdev, PCI_D0); 2405 pci_restore_state(pdev); 2406 /* pci_restore_state clears dev->state_saved so call 2407 * pci_save_state to restore it. 2408 */ 2409 pci_save_state(pdev); 2410 2411 err = pci_enable_device_mem(pdev); 2412 if (err) { 2413 dev_err(&pdev->dev, "Cannot enable PCI device from suspend.\n"); 2414 return err; 2415 } 2416 pci_set_master(pdev); 2417 2418 rtnl_lock(); 2419 err = i40evf_set_interrupt_capability(adapter); 2420 if (err) { 2421 dev_err(&pdev->dev, "Cannot enable MSI-X interrupts.\n"); 2422 return err; 2423 } 2424 err = i40evf_request_misc_irq(adapter); 2425 rtnl_unlock(); 2426 if (err) { 2427 dev_err(&pdev->dev, "Cannot get interrupt vector.\n"); 2428 return err; 2429 } 2430 2431 schedule_work(&adapter->reset_task); 2432 2433 netif_device_attach(netdev); 2434 2435 return err; 2436} 2437 2438#endif /* CONFIG_PM */ 2439/** 2440 * i40evf_remove - Device Removal Routine 2441 * @pdev: PCI device information struct 2442 * 2443 * i40evf_remove is called by the PCI subsystem to alert the driver 2444 * that it should release a PCI device. The could be caused by a 2445 * Hot-Plug event, or because the driver is going to be removed from 2446 * memory. 2447 **/ 2448static void i40evf_remove(struct pci_dev *pdev) 2449{ 2450 struct net_device *netdev = pci_get_drvdata(pdev); 2451 struct i40evf_adapter *adapter = netdev_priv(netdev); 2452 struct i40evf_mac_filter *f, *ftmp; 2453 struct i40e_hw *hw = &adapter->hw; 2454 2455 cancel_delayed_work_sync(&adapter->init_task); 2456 cancel_work_sync(&adapter->reset_task); 2457 2458 if (adapter->netdev_registered) { 2459 unregister_netdev(netdev); 2460 adapter->netdev_registered = false; 2461 } 2462 2463 /* Shut down all the garbage mashers on the detention level */ 2464 adapter->state = __I40EVF_REMOVE; 2465 adapter->aq_required = 0; 2466 i40evf_request_reset(adapter); 2467 msleep(20); 2468 /* If the FW isn't responding, kick it once, but only once. */ 2469 if (!i40evf_asq_done(hw)) { 2470 i40evf_request_reset(adapter); 2471 msleep(20); 2472 } 2473 2474 if (adapter->msix_entries) { 2475 i40evf_misc_irq_disable(adapter); 2476 i40evf_free_misc_irq(adapter); 2477 i40evf_reset_interrupt_capability(adapter); 2478 i40evf_free_q_vectors(adapter); 2479 } 2480 2481 if (adapter->watchdog_timer.function) 2482 del_timer_sync(&adapter->watchdog_timer); 2483 2484 flush_scheduled_work(); 2485 2486 if (hw->aq.asq.count) 2487 i40evf_shutdown_adminq(hw); 2488 2489 iounmap(hw->hw_addr); 2490 pci_release_regions(pdev); 2491 2492 i40evf_free_all_tx_resources(adapter); 2493 i40evf_free_all_rx_resources(adapter); 2494 i40evf_free_queues(adapter); 2495 kfree(adapter->vf_res); 2496 /* If we got removed before an up/down sequence, we've got a filter 2497 * hanging out there that we need to get rid of. 2498 */ 2499 list_for_each_entry_safe(f, ftmp, &adapter->mac_filter_list, list) { 2500 list_del(&f->list); 2501 kfree(f); 2502 } 2503 list_for_each_entry_safe(f, ftmp, &adapter->vlan_filter_list, list) { 2504 list_del(&f->list); 2505 kfree(f); 2506 } 2507 2508 free_netdev(netdev); 2509 2510 pci_disable_pcie_error_reporting(pdev); 2511 2512 pci_disable_device(pdev); 2513} 2514 2515static struct pci_driver i40evf_driver = { 2516 .name = i40evf_driver_name, 2517 .id_table = i40evf_pci_tbl, 2518 .probe = i40evf_probe, 2519 .remove = i40evf_remove, 2520#ifdef CONFIG_PM 2521 .suspend = i40evf_suspend, 2522 .resume = i40evf_resume, 2523#endif 2524 .shutdown = i40evf_shutdown, 2525}; 2526 2527/** 2528 * i40e_init_module - Driver Registration Routine 2529 * 2530 * i40e_init_module is the first routine called when the driver is 2531 * loaded. All it does is register with the PCI subsystem. 2532 **/ 2533static int __init i40evf_init_module(void) 2534{ 2535 int ret; 2536 2537 pr_info("i40evf: %s - version %s\n", i40evf_driver_string, 2538 i40evf_driver_version); 2539 2540 pr_info("%s\n", i40evf_copyright); 2541 2542 ret = pci_register_driver(&i40evf_driver); 2543 return ret; 2544} 2545 2546module_init(i40evf_init_module); 2547 2548/** 2549 * i40e_exit_module - Driver Exit Cleanup Routine 2550 * 2551 * i40e_exit_module is called just before the driver is removed 2552 * from memory. 2553 **/ 2554static void __exit i40evf_exit_module(void) 2555{ 2556 pci_unregister_driver(&i40evf_driver); 2557} 2558 2559module_exit(i40evf_exit_module); 2560 2561/* i40evf_main.c */ 2562