1/******************************************************************************* 2 3 Intel(R) 82576 Virtual Function Linux driver 4 Copyright(c) 2009 - 2012 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 with 16 this program; if not, write to the Free Software Foundation, Inc., 17 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 18 19 The full GNU General Public License is included in this distribution in 20 the file called "COPYING". 21 22 Contact Information: 23 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> 24 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 25 26*******************************************************************************/ 27 28#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 29 30#include <linux/module.h> 31#include <linux/types.h> 32#include <linux/init.h> 33#include <linux/pci.h> 34#include <linux/vmalloc.h> 35#include <linux/pagemap.h> 36#include <linux/delay.h> 37#include <linux/netdevice.h> 38#include <linux/tcp.h> 39#include <linux/ipv6.h> 40#include <linux/slab.h> 41#include <net/checksum.h> 42#include <net/ip6_checksum.h> 43#include <linux/mii.h> 44#include <linux/ethtool.h> 45#include <linux/if_vlan.h> 46#include <linux/prefetch.h> 47 48#include "igbvf.h" 49 50#define DRV_VERSION "2.0.1-k" 51char igbvf_driver_name[] = "igbvf"; 52const char igbvf_driver_version[] = DRV_VERSION; 53static const char igbvf_driver_string[] = 54 "Intel(R) Gigabit Virtual Function Network Driver"; 55static const char igbvf_copyright[] = 56 "Copyright (c) 2009 - 2012 Intel Corporation."; 57 58#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK) 59static int debug = -1; 60module_param(debug, int, 0); 61MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)"); 62 63static int igbvf_poll(struct napi_struct *napi, int budget); 64static void igbvf_reset(struct igbvf_adapter *); 65static void igbvf_set_interrupt_capability(struct igbvf_adapter *); 66static void igbvf_reset_interrupt_capability(struct igbvf_adapter *); 67 68static struct igbvf_info igbvf_vf_info = { 69 .mac = e1000_vfadapt, 70 .flags = 0, 71 .pba = 10, 72 .init_ops = e1000_init_function_pointers_vf, 73}; 74 75static struct igbvf_info igbvf_i350_vf_info = { 76 .mac = e1000_vfadapt_i350, 77 .flags = 0, 78 .pba = 10, 79 .init_ops = e1000_init_function_pointers_vf, 80}; 81 82static const struct igbvf_info *igbvf_info_tbl[] = { 83 [board_vf] = &igbvf_vf_info, 84 [board_i350_vf] = &igbvf_i350_vf_info, 85}; 86 87/** 88 * igbvf_desc_unused - calculate if we have unused descriptors 89 **/ 90static int igbvf_desc_unused(struct igbvf_ring *ring) 91{ 92 if (ring->next_to_clean > ring->next_to_use) 93 return ring->next_to_clean - ring->next_to_use - 1; 94 95 return ring->count + ring->next_to_clean - ring->next_to_use - 1; 96} 97 98/** 99 * igbvf_receive_skb - helper function to handle Rx indications 100 * @adapter: board private structure 101 * @status: descriptor status field as written by hardware 102 * @vlan: descriptor vlan field as written by hardware (no le/be conversion) 103 * @skb: pointer to sk_buff to be indicated to stack 104 **/ 105static void igbvf_receive_skb(struct igbvf_adapter *adapter, 106 struct net_device *netdev, 107 struct sk_buff *skb, 108 u32 status, u16 vlan) 109{ 110 if (status & E1000_RXD_STAT_VP) { 111 u16 vid = le16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK; 112 if (test_bit(vid, adapter->active_vlans)) 113 __vlan_hwaccel_put_tag(skb, vid); 114 } 115 netif_receive_skb(skb); 116} 117 118static inline void igbvf_rx_checksum_adv(struct igbvf_adapter *adapter, 119 u32 status_err, struct sk_buff *skb) 120{ 121 skb_checksum_none_assert(skb); 122 123 /* Ignore Checksum bit is set or checksum is disabled through ethtool */ 124 if ((status_err & E1000_RXD_STAT_IXSM) || 125 (adapter->flags & IGBVF_FLAG_RX_CSUM_DISABLED)) 126 return; 127 128 /* TCP/UDP checksum error bit is set */ 129 if (status_err & 130 (E1000_RXDEXT_STATERR_TCPE | E1000_RXDEXT_STATERR_IPE)) { 131 /* let the stack verify checksum errors */ 132 adapter->hw_csum_err++; 133 return; 134 } 135 136 /* It must be a TCP or UDP packet with a valid checksum */ 137 if (status_err & (E1000_RXD_STAT_TCPCS | E1000_RXD_STAT_UDPCS)) 138 skb->ip_summed = CHECKSUM_UNNECESSARY; 139 140 adapter->hw_csum_good++; 141} 142 143/** 144 * igbvf_alloc_rx_buffers - Replace used receive buffers; packet split 145 * @rx_ring: address of ring structure to repopulate 146 * @cleaned_count: number of buffers to repopulate 147 **/ 148static void igbvf_alloc_rx_buffers(struct igbvf_ring *rx_ring, 149 int cleaned_count) 150{ 151 struct igbvf_adapter *adapter = rx_ring->adapter; 152 struct net_device *netdev = adapter->netdev; 153 struct pci_dev *pdev = adapter->pdev; 154 union e1000_adv_rx_desc *rx_desc; 155 struct igbvf_buffer *buffer_info; 156 struct sk_buff *skb; 157 unsigned int i; 158 int bufsz; 159 160 i = rx_ring->next_to_use; 161 buffer_info = &rx_ring->buffer_info[i]; 162 163 if (adapter->rx_ps_hdr_size) 164 bufsz = adapter->rx_ps_hdr_size; 165 else 166 bufsz = adapter->rx_buffer_len; 167 168 while (cleaned_count--) { 169 rx_desc = IGBVF_RX_DESC_ADV(*rx_ring, i); 170 171 if (adapter->rx_ps_hdr_size && !buffer_info->page_dma) { 172 if (!buffer_info->page) { 173 buffer_info->page = alloc_page(GFP_ATOMIC); 174 if (!buffer_info->page) { 175 adapter->alloc_rx_buff_failed++; 176 goto no_buffers; 177 } 178 buffer_info->page_offset = 0; 179 } else { 180 buffer_info->page_offset ^= PAGE_SIZE / 2; 181 } 182 buffer_info->page_dma = 183 dma_map_page(&pdev->dev, buffer_info->page, 184 buffer_info->page_offset, 185 PAGE_SIZE / 2, 186 DMA_FROM_DEVICE); 187 } 188 189 if (!buffer_info->skb) { 190 skb = netdev_alloc_skb_ip_align(netdev, bufsz); 191 if (!skb) { 192 adapter->alloc_rx_buff_failed++; 193 goto no_buffers; 194 } 195 196 buffer_info->skb = skb; 197 buffer_info->dma = dma_map_single(&pdev->dev, skb->data, 198 bufsz, 199 DMA_FROM_DEVICE); 200 } 201 /* Refresh the desc even if buffer_addrs didn't change because 202 * each write-back erases this info. */ 203 if (adapter->rx_ps_hdr_size) { 204 rx_desc->read.pkt_addr = 205 cpu_to_le64(buffer_info->page_dma); 206 rx_desc->read.hdr_addr = cpu_to_le64(buffer_info->dma); 207 } else { 208 rx_desc->read.pkt_addr = 209 cpu_to_le64(buffer_info->dma); 210 rx_desc->read.hdr_addr = 0; 211 } 212 213 i++; 214 if (i == rx_ring->count) 215 i = 0; 216 buffer_info = &rx_ring->buffer_info[i]; 217 } 218 219no_buffers: 220 if (rx_ring->next_to_use != i) { 221 rx_ring->next_to_use = i; 222 if (i == 0) 223 i = (rx_ring->count - 1); 224 else 225 i--; 226 227 /* Force memory writes to complete before letting h/w 228 * know there are new descriptors to fetch. (Only 229 * applicable for weak-ordered memory model archs, 230 * such as IA-64). */ 231 wmb(); 232 writel(i, adapter->hw.hw_addr + rx_ring->tail); 233 } 234} 235 236/** 237 * igbvf_clean_rx_irq - Send received data up the network stack; legacy 238 * @adapter: board private structure 239 * 240 * the return value indicates whether actual cleaning was done, there 241 * is no guarantee that everything was cleaned 242 **/ 243static bool igbvf_clean_rx_irq(struct igbvf_adapter *adapter, 244 int *work_done, int work_to_do) 245{ 246 struct igbvf_ring *rx_ring = adapter->rx_ring; 247 struct net_device *netdev = adapter->netdev; 248 struct pci_dev *pdev = adapter->pdev; 249 union e1000_adv_rx_desc *rx_desc, *next_rxd; 250 struct igbvf_buffer *buffer_info, *next_buffer; 251 struct sk_buff *skb; 252 bool cleaned = false; 253 int cleaned_count = 0; 254 unsigned int total_bytes = 0, total_packets = 0; 255 unsigned int i; 256 u32 length, hlen, staterr; 257 258 i = rx_ring->next_to_clean; 259 rx_desc = IGBVF_RX_DESC_ADV(*rx_ring, i); 260 staterr = le32_to_cpu(rx_desc->wb.upper.status_error); 261 262 while (staterr & E1000_RXD_STAT_DD) { 263 if (*work_done >= work_to_do) 264 break; 265 (*work_done)++; 266 rmb(); /* read descriptor and rx_buffer_info after status DD */ 267 268 buffer_info = &rx_ring->buffer_info[i]; 269 270 /* HW will not DMA in data larger than the given buffer, even 271 * if it parses the (NFS, of course) header to be larger. In 272 * that case, it fills the header buffer and spills the rest 273 * into the page. 274 */ 275 hlen = (le16_to_cpu(rx_desc->wb.lower.lo_dword.hs_rss.hdr_info) & 276 E1000_RXDADV_HDRBUFLEN_MASK) >> E1000_RXDADV_HDRBUFLEN_SHIFT; 277 if (hlen > adapter->rx_ps_hdr_size) 278 hlen = adapter->rx_ps_hdr_size; 279 280 length = le16_to_cpu(rx_desc->wb.upper.length); 281 cleaned = true; 282 cleaned_count++; 283 284 skb = buffer_info->skb; 285 prefetch(skb->data - NET_IP_ALIGN); 286 buffer_info->skb = NULL; 287 if (!adapter->rx_ps_hdr_size) { 288 dma_unmap_single(&pdev->dev, buffer_info->dma, 289 adapter->rx_buffer_len, 290 DMA_FROM_DEVICE); 291 buffer_info->dma = 0; 292 skb_put(skb, length); 293 goto send_up; 294 } 295 296 if (!skb_shinfo(skb)->nr_frags) { 297 dma_unmap_single(&pdev->dev, buffer_info->dma, 298 adapter->rx_ps_hdr_size, 299 DMA_FROM_DEVICE); 300 skb_put(skb, hlen); 301 } 302 303 if (length) { 304 dma_unmap_page(&pdev->dev, buffer_info->page_dma, 305 PAGE_SIZE / 2, 306 DMA_FROM_DEVICE); 307 buffer_info->page_dma = 0; 308 309 skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags, 310 buffer_info->page, 311 buffer_info->page_offset, 312 length); 313 314 if ((adapter->rx_buffer_len > (PAGE_SIZE / 2)) || 315 (page_count(buffer_info->page) != 1)) 316 buffer_info->page = NULL; 317 else 318 get_page(buffer_info->page); 319 320 skb->len += length; 321 skb->data_len += length; 322 skb->truesize += PAGE_SIZE / 2; 323 } 324send_up: 325 i++; 326 if (i == rx_ring->count) 327 i = 0; 328 next_rxd = IGBVF_RX_DESC_ADV(*rx_ring, i); 329 prefetch(next_rxd); 330 next_buffer = &rx_ring->buffer_info[i]; 331 332 if (!(staterr & E1000_RXD_STAT_EOP)) { 333 buffer_info->skb = next_buffer->skb; 334 buffer_info->dma = next_buffer->dma; 335 next_buffer->skb = skb; 336 next_buffer->dma = 0; 337 goto next_desc; 338 } 339 340 if (staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK) { 341 dev_kfree_skb_irq(skb); 342 goto next_desc; 343 } 344 345 total_bytes += skb->len; 346 total_packets++; 347 348 igbvf_rx_checksum_adv(adapter, staterr, skb); 349 350 skb->protocol = eth_type_trans(skb, netdev); 351 352 igbvf_receive_skb(adapter, netdev, skb, staterr, 353 rx_desc->wb.upper.vlan); 354 355next_desc: 356 rx_desc->wb.upper.status_error = 0; 357 358 /* return some buffers to hardware, one at a time is too slow */ 359 if (cleaned_count >= IGBVF_RX_BUFFER_WRITE) { 360 igbvf_alloc_rx_buffers(rx_ring, cleaned_count); 361 cleaned_count = 0; 362 } 363 364 /* use prefetched values */ 365 rx_desc = next_rxd; 366 buffer_info = next_buffer; 367 368 staterr = le32_to_cpu(rx_desc->wb.upper.status_error); 369 } 370 371 rx_ring->next_to_clean = i; 372 cleaned_count = igbvf_desc_unused(rx_ring); 373 374 if (cleaned_count) 375 igbvf_alloc_rx_buffers(rx_ring, cleaned_count); 376 377 adapter->total_rx_packets += total_packets; 378 adapter->total_rx_bytes += total_bytes; 379 adapter->net_stats.rx_bytes += total_bytes; 380 adapter->net_stats.rx_packets += total_packets; 381 return cleaned; 382} 383 384static void igbvf_put_txbuf(struct igbvf_adapter *adapter, 385 struct igbvf_buffer *buffer_info) 386{ 387 if (buffer_info->dma) { 388 if (buffer_info->mapped_as_page) 389 dma_unmap_page(&adapter->pdev->dev, 390 buffer_info->dma, 391 buffer_info->length, 392 DMA_TO_DEVICE); 393 else 394 dma_unmap_single(&adapter->pdev->dev, 395 buffer_info->dma, 396 buffer_info->length, 397 DMA_TO_DEVICE); 398 buffer_info->dma = 0; 399 } 400 if (buffer_info->skb) { 401 dev_kfree_skb_any(buffer_info->skb); 402 buffer_info->skb = NULL; 403 } 404 buffer_info->time_stamp = 0; 405} 406 407/** 408 * igbvf_setup_tx_resources - allocate Tx resources (Descriptors) 409 * @adapter: board private structure 410 * 411 * Return 0 on success, negative on failure 412 **/ 413int igbvf_setup_tx_resources(struct igbvf_adapter *adapter, 414 struct igbvf_ring *tx_ring) 415{ 416 struct pci_dev *pdev = adapter->pdev; 417 int size; 418 419 size = sizeof(struct igbvf_buffer) * tx_ring->count; 420 tx_ring->buffer_info = vzalloc(size); 421 if (!tx_ring->buffer_info) 422 goto err; 423 424 /* round up to nearest 4K */ 425 tx_ring->size = tx_ring->count * sizeof(union e1000_adv_tx_desc); 426 tx_ring->size = ALIGN(tx_ring->size, 4096); 427 428 tx_ring->desc = dma_alloc_coherent(&pdev->dev, tx_ring->size, 429 &tx_ring->dma, GFP_KERNEL); 430 431 if (!tx_ring->desc) 432 goto err; 433 434 tx_ring->adapter = adapter; 435 tx_ring->next_to_use = 0; 436 tx_ring->next_to_clean = 0; 437 438 return 0; 439err: 440 vfree(tx_ring->buffer_info); 441 dev_err(&adapter->pdev->dev, 442 "Unable to allocate memory for the transmit descriptor ring\n"); 443 return -ENOMEM; 444} 445 446/** 447 * igbvf_setup_rx_resources - allocate Rx resources (Descriptors) 448 * @adapter: board private structure 449 * 450 * Returns 0 on success, negative on failure 451 **/ 452int igbvf_setup_rx_resources(struct igbvf_adapter *adapter, 453 struct igbvf_ring *rx_ring) 454{ 455 struct pci_dev *pdev = adapter->pdev; 456 int size, desc_len; 457 458 size = sizeof(struct igbvf_buffer) * rx_ring->count; 459 rx_ring->buffer_info = vzalloc(size); 460 if (!rx_ring->buffer_info) 461 goto err; 462 463 desc_len = sizeof(union e1000_adv_rx_desc); 464 465 /* Round up to nearest 4K */ 466 rx_ring->size = rx_ring->count * desc_len; 467 rx_ring->size = ALIGN(rx_ring->size, 4096); 468 469 rx_ring->desc = dma_alloc_coherent(&pdev->dev, rx_ring->size, 470 &rx_ring->dma, GFP_KERNEL); 471 472 if (!rx_ring->desc) 473 goto err; 474 475 rx_ring->next_to_clean = 0; 476 rx_ring->next_to_use = 0; 477 478 rx_ring->adapter = adapter; 479 480 return 0; 481 482err: 483 vfree(rx_ring->buffer_info); 484 rx_ring->buffer_info = NULL; 485 dev_err(&adapter->pdev->dev, 486 "Unable to allocate memory for the receive descriptor ring\n"); 487 return -ENOMEM; 488} 489 490/** 491 * igbvf_clean_tx_ring - Free Tx Buffers 492 * @tx_ring: ring to be cleaned 493 **/ 494static void igbvf_clean_tx_ring(struct igbvf_ring *tx_ring) 495{ 496 struct igbvf_adapter *adapter = tx_ring->adapter; 497 struct igbvf_buffer *buffer_info; 498 unsigned long size; 499 unsigned int i; 500 501 if (!tx_ring->buffer_info) 502 return; 503 504 /* Free all the Tx ring sk_buffs */ 505 for (i = 0; i < tx_ring->count; i++) { 506 buffer_info = &tx_ring->buffer_info[i]; 507 igbvf_put_txbuf(adapter, buffer_info); 508 } 509 510 size = sizeof(struct igbvf_buffer) * tx_ring->count; 511 memset(tx_ring->buffer_info, 0, size); 512 513 /* Zero out the descriptor ring */ 514 memset(tx_ring->desc, 0, tx_ring->size); 515 516 tx_ring->next_to_use = 0; 517 tx_ring->next_to_clean = 0; 518 519 writel(0, adapter->hw.hw_addr + tx_ring->head); 520 writel(0, adapter->hw.hw_addr + tx_ring->tail); 521} 522 523/** 524 * igbvf_free_tx_resources - Free Tx Resources per Queue 525 * @tx_ring: ring to free resources from 526 * 527 * Free all transmit software resources 528 **/ 529void igbvf_free_tx_resources(struct igbvf_ring *tx_ring) 530{ 531 struct pci_dev *pdev = tx_ring->adapter->pdev; 532 533 igbvf_clean_tx_ring(tx_ring); 534 535 vfree(tx_ring->buffer_info); 536 tx_ring->buffer_info = NULL; 537 538 dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc, 539 tx_ring->dma); 540 541 tx_ring->desc = NULL; 542} 543 544/** 545 * igbvf_clean_rx_ring - Free Rx Buffers per Queue 546 * @adapter: board private structure 547 **/ 548static void igbvf_clean_rx_ring(struct igbvf_ring *rx_ring) 549{ 550 struct igbvf_adapter *adapter = rx_ring->adapter; 551 struct igbvf_buffer *buffer_info; 552 struct pci_dev *pdev = adapter->pdev; 553 unsigned long size; 554 unsigned int i; 555 556 if (!rx_ring->buffer_info) 557 return; 558 559 /* Free all the Rx ring sk_buffs */ 560 for (i = 0; i < rx_ring->count; i++) { 561 buffer_info = &rx_ring->buffer_info[i]; 562 if (buffer_info->dma) { 563 if (adapter->rx_ps_hdr_size){ 564 dma_unmap_single(&pdev->dev, buffer_info->dma, 565 adapter->rx_ps_hdr_size, 566 DMA_FROM_DEVICE); 567 } else { 568 dma_unmap_single(&pdev->dev, buffer_info->dma, 569 adapter->rx_buffer_len, 570 DMA_FROM_DEVICE); 571 } 572 buffer_info->dma = 0; 573 } 574 575 if (buffer_info->skb) { 576 dev_kfree_skb(buffer_info->skb); 577 buffer_info->skb = NULL; 578 } 579 580 if (buffer_info->page) { 581 if (buffer_info->page_dma) 582 dma_unmap_page(&pdev->dev, 583 buffer_info->page_dma, 584 PAGE_SIZE / 2, 585 DMA_FROM_DEVICE); 586 put_page(buffer_info->page); 587 buffer_info->page = NULL; 588 buffer_info->page_dma = 0; 589 buffer_info->page_offset = 0; 590 } 591 } 592 593 size = sizeof(struct igbvf_buffer) * rx_ring->count; 594 memset(rx_ring->buffer_info, 0, size); 595 596 /* Zero out the descriptor ring */ 597 memset(rx_ring->desc, 0, rx_ring->size); 598 599 rx_ring->next_to_clean = 0; 600 rx_ring->next_to_use = 0; 601 602 writel(0, adapter->hw.hw_addr + rx_ring->head); 603 writel(0, adapter->hw.hw_addr + rx_ring->tail); 604} 605 606/** 607 * igbvf_free_rx_resources - Free Rx Resources 608 * @rx_ring: ring to clean the resources from 609 * 610 * Free all receive software resources 611 **/ 612 613void igbvf_free_rx_resources(struct igbvf_ring *rx_ring) 614{ 615 struct pci_dev *pdev = rx_ring->adapter->pdev; 616 617 igbvf_clean_rx_ring(rx_ring); 618 619 vfree(rx_ring->buffer_info); 620 rx_ring->buffer_info = NULL; 621 622 dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc, 623 rx_ring->dma); 624 rx_ring->desc = NULL; 625} 626 627/** 628 * igbvf_update_itr - update the dynamic ITR value based on statistics 629 * @adapter: pointer to adapter 630 * @itr_setting: current adapter->itr 631 * @packets: the number of packets during this measurement interval 632 * @bytes: the number of bytes during this measurement interval 633 * 634 * Stores a new ITR value based on packets and byte 635 * counts during the last interrupt. The advantage of per interrupt 636 * computation is faster updates and more accurate ITR for the current 637 * traffic pattern. Constants in this function were computed 638 * based on theoretical maximum wire speed and thresholds were set based 639 * on testing data as well as attempting to minimize response time 640 * while increasing bulk throughput. 641 **/ 642static enum latency_range igbvf_update_itr(struct igbvf_adapter *adapter, 643 enum latency_range itr_setting, 644 int packets, int bytes) 645{ 646 enum latency_range retval = itr_setting; 647 648 if (packets == 0) 649 goto update_itr_done; 650 651 switch (itr_setting) { 652 case lowest_latency: 653 /* handle TSO and jumbo frames */ 654 if (bytes/packets > 8000) 655 retval = bulk_latency; 656 else if ((packets < 5) && (bytes > 512)) 657 retval = low_latency; 658 break; 659 case low_latency: /* 50 usec aka 20000 ints/s */ 660 if (bytes > 10000) { 661 /* this if handles the TSO accounting */ 662 if (bytes/packets > 8000) 663 retval = bulk_latency; 664 else if ((packets < 10) || ((bytes/packets) > 1200)) 665 retval = bulk_latency; 666 else if ((packets > 35)) 667 retval = lowest_latency; 668 } else if (bytes/packets > 2000) { 669 retval = bulk_latency; 670 } else if (packets <= 2 && bytes < 512) { 671 retval = lowest_latency; 672 } 673 break; 674 case bulk_latency: /* 250 usec aka 4000 ints/s */ 675 if (bytes > 25000) { 676 if (packets > 35) 677 retval = low_latency; 678 } else if (bytes < 6000) { 679 retval = low_latency; 680 } 681 break; 682 default: 683 break; 684 } 685 686update_itr_done: 687 return retval; 688} 689 690static int igbvf_range_to_itr(enum latency_range current_range) 691{ 692 int new_itr; 693 694 switch (current_range) { 695 /* counts and packets in update_itr are dependent on these numbers */ 696 case lowest_latency: 697 new_itr = IGBVF_70K_ITR; 698 break; 699 case low_latency: 700 new_itr = IGBVF_20K_ITR; 701 break; 702 case bulk_latency: 703 new_itr = IGBVF_4K_ITR; 704 break; 705 default: 706 new_itr = IGBVF_START_ITR; 707 break; 708 } 709 return new_itr; 710} 711 712static void igbvf_set_itr(struct igbvf_adapter *adapter) 713{ 714 u32 new_itr; 715 716 adapter->tx_ring->itr_range = 717 igbvf_update_itr(adapter, 718 adapter->tx_ring->itr_val, 719 adapter->total_tx_packets, 720 adapter->total_tx_bytes); 721 722 /* conservative mode (itr 3) eliminates the lowest_latency setting */ 723 if (adapter->requested_itr == 3 && 724 adapter->tx_ring->itr_range == lowest_latency) 725 adapter->tx_ring->itr_range = low_latency; 726 727 new_itr = igbvf_range_to_itr(adapter->tx_ring->itr_range); 728 729 730 if (new_itr != adapter->tx_ring->itr_val) { 731 u32 current_itr = adapter->tx_ring->itr_val; 732 /* 733 * this attempts to bias the interrupt rate towards Bulk 734 * by adding intermediate steps when interrupt rate is 735 * increasing 736 */ 737 new_itr = new_itr > current_itr ? 738 min(current_itr + (new_itr >> 2), new_itr) : 739 new_itr; 740 adapter->tx_ring->itr_val = new_itr; 741 742 adapter->tx_ring->set_itr = 1; 743 } 744 745 adapter->rx_ring->itr_range = 746 igbvf_update_itr(adapter, adapter->rx_ring->itr_val, 747 adapter->total_rx_packets, 748 adapter->total_rx_bytes); 749 if (adapter->requested_itr == 3 && 750 adapter->rx_ring->itr_range == lowest_latency) 751 adapter->rx_ring->itr_range = low_latency; 752 753 new_itr = igbvf_range_to_itr(adapter->rx_ring->itr_range); 754 755 if (new_itr != adapter->rx_ring->itr_val) { 756 u32 current_itr = adapter->rx_ring->itr_val; 757 new_itr = new_itr > current_itr ? 758 min(current_itr + (new_itr >> 2), new_itr) : 759 new_itr; 760 adapter->rx_ring->itr_val = new_itr; 761 762 adapter->rx_ring->set_itr = 1; 763 } 764} 765 766/** 767 * igbvf_clean_tx_irq - Reclaim resources after transmit completes 768 * @adapter: board private structure 769 * returns true if ring is completely cleaned 770 **/ 771static bool igbvf_clean_tx_irq(struct igbvf_ring *tx_ring) 772{ 773 struct igbvf_adapter *adapter = tx_ring->adapter; 774 struct net_device *netdev = adapter->netdev; 775 struct igbvf_buffer *buffer_info; 776 struct sk_buff *skb; 777 union e1000_adv_tx_desc *tx_desc, *eop_desc; 778 unsigned int total_bytes = 0, total_packets = 0; 779 unsigned int i, eop, count = 0; 780 bool cleaned = false; 781 782 i = tx_ring->next_to_clean; 783 eop = tx_ring->buffer_info[i].next_to_watch; 784 eop_desc = IGBVF_TX_DESC_ADV(*tx_ring, eop); 785 786 while ((eop_desc->wb.status & cpu_to_le32(E1000_TXD_STAT_DD)) && 787 (count < tx_ring->count)) { 788 rmb(); /* read buffer_info after eop_desc status */ 789 for (cleaned = false; !cleaned; count++) { 790 tx_desc = IGBVF_TX_DESC_ADV(*tx_ring, i); 791 buffer_info = &tx_ring->buffer_info[i]; 792 cleaned = (i == eop); 793 skb = buffer_info->skb; 794 795 if (skb) { 796 unsigned int segs, bytecount; 797 798 /* gso_segs is currently only valid for tcp */ 799 segs = skb_shinfo(skb)->gso_segs ?: 1; 800 /* multiply data chunks by size of headers */ 801 bytecount = ((segs - 1) * skb_headlen(skb)) + 802 skb->len; 803 total_packets += segs; 804 total_bytes += bytecount; 805 } 806 807 igbvf_put_txbuf(adapter, buffer_info); 808 tx_desc->wb.status = 0; 809 810 i++; 811 if (i == tx_ring->count) 812 i = 0; 813 } 814 eop = tx_ring->buffer_info[i].next_to_watch; 815 eop_desc = IGBVF_TX_DESC_ADV(*tx_ring, eop); 816 } 817 818 tx_ring->next_to_clean = i; 819 820 if (unlikely(count && 821 netif_carrier_ok(netdev) && 822 igbvf_desc_unused(tx_ring) >= IGBVF_TX_QUEUE_WAKE)) { 823 /* Make sure that anybody stopping the queue after this 824 * sees the new next_to_clean. 825 */ 826 smp_mb(); 827 if (netif_queue_stopped(netdev) && 828 !(test_bit(__IGBVF_DOWN, &adapter->state))) { 829 netif_wake_queue(netdev); 830 ++adapter->restart_queue; 831 } 832 } 833 834 adapter->net_stats.tx_bytes += total_bytes; 835 adapter->net_stats.tx_packets += total_packets; 836 return count < tx_ring->count; 837} 838 839static irqreturn_t igbvf_msix_other(int irq, void *data) 840{ 841 struct net_device *netdev = data; 842 struct igbvf_adapter *adapter = netdev_priv(netdev); 843 struct e1000_hw *hw = &adapter->hw; 844 845 adapter->int_counter1++; 846 847 netif_carrier_off(netdev); 848 hw->mac.get_link_status = 1; 849 if (!test_bit(__IGBVF_DOWN, &adapter->state)) 850 mod_timer(&adapter->watchdog_timer, jiffies + 1); 851 852 ew32(EIMS, adapter->eims_other); 853 854 return IRQ_HANDLED; 855} 856 857static irqreturn_t igbvf_intr_msix_tx(int irq, void *data) 858{ 859 struct net_device *netdev = data; 860 struct igbvf_adapter *adapter = netdev_priv(netdev); 861 struct e1000_hw *hw = &adapter->hw; 862 struct igbvf_ring *tx_ring = adapter->tx_ring; 863 864 if (tx_ring->set_itr) { 865 writel(tx_ring->itr_val, 866 adapter->hw.hw_addr + tx_ring->itr_register); 867 adapter->tx_ring->set_itr = 0; 868 } 869 870 adapter->total_tx_bytes = 0; 871 adapter->total_tx_packets = 0; 872 873 /* auto mask will automatically reenable the interrupt when we write 874 * EICS */ 875 if (!igbvf_clean_tx_irq(tx_ring)) 876 /* Ring was not completely cleaned, so fire another interrupt */ 877 ew32(EICS, tx_ring->eims_value); 878 else 879 ew32(EIMS, tx_ring->eims_value); 880 881 return IRQ_HANDLED; 882} 883 884static irqreturn_t igbvf_intr_msix_rx(int irq, void *data) 885{ 886 struct net_device *netdev = data; 887 struct igbvf_adapter *adapter = netdev_priv(netdev); 888 889 adapter->int_counter0++; 890 891 /* Write the ITR value calculated at the end of the 892 * previous interrupt. 893 */ 894 if (adapter->rx_ring->set_itr) { 895 writel(adapter->rx_ring->itr_val, 896 adapter->hw.hw_addr + adapter->rx_ring->itr_register); 897 adapter->rx_ring->set_itr = 0; 898 } 899 900 if (napi_schedule_prep(&adapter->rx_ring->napi)) { 901 adapter->total_rx_bytes = 0; 902 adapter->total_rx_packets = 0; 903 __napi_schedule(&adapter->rx_ring->napi); 904 } 905 906 return IRQ_HANDLED; 907} 908 909#define IGBVF_NO_QUEUE -1 910 911static void igbvf_assign_vector(struct igbvf_adapter *adapter, int rx_queue, 912 int tx_queue, int msix_vector) 913{ 914 struct e1000_hw *hw = &adapter->hw; 915 u32 ivar, index; 916 917 /* 82576 uses a table-based method for assigning vectors. 918 Each queue has a single entry in the table to which we write 919 a vector number along with a "valid" bit. Sadly, the layout 920 of the table is somewhat counterintuitive. */ 921 if (rx_queue > IGBVF_NO_QUEUE) { 922 index = (rx_queue >> 1); 923 ivar = array_er32(IVAR0, index); 924 if (rx_queue & 0x1) { 925 /* vector goes into third byte of register */ 926 ivar = ivar & 0xFF00FFFF; 927 ivar |= (msix_vector | E1000_IVAR_VALID) << 16; 928 } else { 929 /* vector goes into low byte of register */ 930 ivar = ivar & 0xFFFFFF00; 931 ivar |= msix_vector | E1000_IVAR_VALID; 932 } 933 adapter->rx_ring[rx_queue].eims_value = 1 << msix_vector; 934 array_ew32(IVAR0, index, ivar); 935 } 936 if (tx_queue > IGBVF_NO_QUEUE) { 937 index = (tx_queue >> 1); 938 ivar = array_er32(IVAR0, index); 939 if (tx_queue & 0x1) { 940 /* vector goes into high byte of register */ 941 ivar = ivar & 0x00FFFFFF; 942 ivar |= (msix_vector | E1000_IVAR_VALID) << 24; 943 } else { 944 /* vector goes into second byte of register */ 945 ivar = ivar & 0xFFFF00FF; 946 ivar |= (msix_vector | E1000_IVAR_VALID) << 8; 947 } 948 adapter->tx_ring[tx_queue].eims_value = 1 << msix_vector; 949 array_ew32(IVAR0, index, ivar); 950 } 951} 952 953/** 954 * igbvf_configure_msix - Configure MSI-X hardware 955 * 956 * igbvf_configure_msix sets up the hardware to properly 957 * generate MSI-X interrupts. 958 **/ 959static void igbvf_configure_msix(struct igbvf_adapter *adapter) 960{ 961 u32 tmp; 962 struct e1000_hw *hw = &adapter->hw; 963 struct igbvf_ring *tx_ring = adapter->tx_ring; 964 struct igbvf_ring *rx_ring = adapter->rx_ring; 965 int vector = 0; 966 967 adapter->eims_enable_mask = 0; 968 969 igbvf_assign_vector(adapter, IGBVF_NO_QUEUE, 0, vector++); 970 adapter->eims_enable_mask |= tx_ring->eims_value; 971 writel(tx_ring->itr_val, hw->hw_addr + tx_ring->itr_register); 972 igbvf_assign_vector(adapter, 0, IGBVF_NO_QUEUE, vector++); 973 adapter->eims_enable_mask |= rx_ring->eims_value; 974 writel(rx_ring->itr_val, hw->hw_addr + rx_ring->itr_register); 975 976 /* set vector for other causes, i.e. link changes */ 977 978 tmp = (vector++ | E1000_IVAR_VALID); 979 980 ew32(IVAR_MISC, tmp); 981 982 adapter->eims_enable_mask = (1 << (vector)) - 1; 983 adapter->eims_other = 1 << (vector - 1); 984 e1e_flush(); 985} 986 987static void igbvf_reset_interrupt_capability(struct igbvf_adapter *adapter) 988{ 989 if (adapter->msix_entries) { 990 pci_disable_msix(adapter->pdev); 991 kfree(adapter->msix_entries); 992 adapter->msix_entries = NULL; 993 } 994} 995 996/** 997 * igbvf_set_interrupt_capability - set MSI or MSI-X if supported 998 * 999 * Attempt to configure interrupts using the best available 1000 * capabilities of the hardware and kernel. 1001 **/ 1002static void igbvf_set_interrupt_capability(struct igbvf_adapter *adapter) 1003{ 1004 int err = -ENOMEM; 1005 int i; 1006 1007 /* we allocate 3 vectors, 1 for tx, 1 for rx, one for pf messages */ 1008 adapter->msix_entries = kcalloc(3, sizeof(struct msix_entry), 1009 GFP_KERNEL); 1010 if (adapter->msix_entries) { 1011 for (i = 0; i < 3; i++) 1012 adapter->msix_entries[i].entry = i; 1013 1014 err = pci_enable_msix(adapter->pdev, 1015 adapter->msix_entries, 3); 1016 } 1017 1018 if (err) { 1019 /* MSI-X failed */ 1020 dev_err(&adapter->pdev->dev, 1021 "Failed to initialize MSI-X interrupts.\n"); 1022 igbvf_reset_interrupt_capability(adapter); 1023 } 1024} 1025 1026/** 1027 * igbvf_request_msix - Initialize MSI-X interrupts 1028 * 1029 * igbvf_request_msix allocates MSI-X vectors and requests interrupts from the 1030 * kernel. 1031 **/ 1032static int igbvf_request_msix(struct igbvf_adapter *adapter) 1033{ 1034 struct net_device *netdev = adapter->netdev; 1035 int err = 0, vector = 0; 1036 1037 if (strlen(netdev->name) < (IFNAMSIZ - 5)) { 1038 sprintf(adapter->tx_ring->name, "%s-tx-0", netdev->name); 1039 sprintf(adapter->rx_ring->name, "%s-rx-0", netdev->name); 1040 } else { 1041 memcpy(adapter->tx_ring->name, netdev->name, IFNAMSIZ); 1042 memcpy(adapter->rx_ring->name, netdev->name, IFNAMSIZ); 1043 } 1044 1045 err = request_irq(adapter->msix_entries[vector].vector, 1046 igbvf_intr_msix_tx, 0, adapter->tx_ring->name, 1047 netdev); 1048 if (err) 1049 goto out; 1050 1051 adapter->tx_ring->itr_register = E1000_EITR(vector); 1052 adapter->tx_ring->itr_val = adapter->current_itr; 1053 vector++; 1054 1055 err = request_irq(adapter->msix_entries[vector].vector, 1056 igbvf_intr_msix_rx, 0, adapter->rx_ring->name, 1057 netdev); 1058 if (err) 1059 goto out; 1060 1061 adapter->rx_ring->itr_register = E1000_EITR(vector); 1062 adapter->rx_ring->itr_val = adapter->current_itr; 1063 vector++; 1064 1065 err = request_irq(adapter->msix_entries[vector].vector, 1066 igbvf_msix_other, 0, netdev->name, netdev); 1067 if (err) 1068 goto out; 1069 1070 igbvf_configure_msix(adapter); 1071 return 0; 1072out: 1073 return err; 1074} 1075 1076/** 1077 * igbvf_alloc_queues - Allocate memory for all rings 1078 * @adapter: board private structure to initialize 1079 **/ 1080static int __devinit igbvf_alloc_queues(struct igbvf_adapter *adapter) 1081{ 1082 struct net_device *netdev = adapter->netdev; 1083 1084 adapter->tx_ring = kzalloc(sizeof(struct igbvf_ring), GFP_KERNEL); 1085 if (!adapter->tx_ring) 1086 return -ENOMEM; 1087 1088 adapter->rx_ring = kzalloc(sizeof(struct igbvf_ring), GFP_KERNEL); 1089 if (!adapter->rx_ring) { 1090 kfree(adapter->tx_ring); 1091 return -ENOMEM; 1092 } 1093 1094 netif_napi_add(netdev, &adapter->rx_ring->napi, igbvf_poll, 64); 1095 1096 return 0; 1097} 1098 1099/** 1100 * igbvf_request_irq - initialize interrupts 1101 * 1102 * Attempts to configure interrupts using the best available 1103 * capabilities of the hardware and kernel. 1104 **/ 1105static int igbvf_request_irq(struct igbvf_adapter *adapter) 1106{ 1107 int err = -1; 1108 1109 /* igbvf supports msi-x only */ 1110 if (adapter->msix_entries) 1111 err = igbvf_request_msix(adapter); 1112 1113 if (!err) 1114 return err; 1115 1116 dev_err(&adapter->pdev->dev, 1117 "Unable to allocate interrupt, Error: %d\n", err); 1118 1119 return err; 1120} 1121 1122static void igbvf_free_irq(struct igbvf_adapter *adapter) 1123{ 1124 struct net_device *netdev = adapter->netdev; 1125 int vector; 1126 1127 if (adapter->msix_entries) { 1128 for (vector = 0; vector < 3; vector++) 1129 free_irq(adapter->msix_entries[vector].vector, netdev); 1130 } 1131} 1132 1133/** 1134 * igbvf_irq_disable - Mask off interrupt generation on the NIC 1135 **/ 1136static void igbvf_irq_disable(struct igbvf_adapter *adapter) 1137{ 1138 struct e1000_hw *hw = &adapter->hw; 1139 1140 ew32(EIMC, ~0); 1141 1142 if (adapter->msix_entries) 1143 ew32(EIAC, 0); 1144} 1145 1146/** 1147 * igbvf_irq_enable - Enable default interrupt generation settings 1148 **/ 1149static void igbvf_irq_enable(struct igbvf_adapter *adapter) 1150{ 1151 struct e1000_hw *hw = &adapter->hw; 1152 1153 ew32(EIAC, adapter->eims_enable_mask); 1154 ew32(EIAM, adapter->eims_enable_mask); 1155 ew32(EIMS, adapter->eims_enable_mask); 1156} 1157 1158/** 1159 * igbvf_poll - NAPI Rx polling callback 1160 * @napi: struct associated with this polling callback 1161 * @budget: amount of packets driver is allowed to process this poll 1162 **/ 1163static int igbvf_poll(struct napi_struct *napi, int budget) 1164{ 1165 struct igbvf_ring *rx_ring = container_of(napi, struct igbvf_ring, napi); 1166 struct igbvf_adapter *adapter = rx_ring->adapter; 1167 struct e1000_hw *hw = &adapter->hw; 1168 int work_done = 0; 1169 1170 igbvf_clean_rx_irq(adapter, &work_done, budget); 1171 1172 /* If not enough Rx work done, exit the polling mode */ 1173 if (work_done < budget) { 1174 napi_complete(napi); 1175 1176 if (adapter->requested_itr & 3) 1177 igbvf_set_itr(adapter); 1178 1179 if (!test_bit(__IGBVF_DOWN, &adapter->state)) 1180 ew32(EIMS, adapter->rx_ring->eims_value); 1181 } 1182 1183 return work_done; 1184} 1185 1186/** 1187 * igbvf_set_rlpml - set receive large packet maximum length 1188 * @adapter: board private structure 1189 * 1190 * Configure the maximum size of packets that will be received 1191 */ 1192static void igbvf_set_rlpml(struct igbvf_adapter *adapter) 1193{ 1194 int max_frame_size; 1195 struct e1000_hw *hw = &adapter->hw; 1196 1197 max_frame_size = adapter->max_frame_size + VLAN_TAG_SIZE; 1198 e1000_rlpml_set_vf(hw, max_frame_size); 1199} 1200 1201static int igbvf_vlan_rx_add_vid(struct net_device *netdev, u16 vid) 1202{ 1203 struct igbvf_adapter *adapter = netdev_priv(netdev); 1204 struct e1000_hw *hw = &adapter->hw; 1205 1206 if (hw->mac.ops.set_vfta(hw, vid, true)) { 1207 dev_err(&adapter->pdev->dev, "Failed to add vlan id %d\n", vid); 1208 return -EINVAL; 1209 } 1210 set_bit(vid, adapter->active_vlans); 1211 return 0; 1212} 1213 1214static int igbvf_vlan_rx_kill_vid(struct net_device *netdev, u16 vid) 1215{ 1216 struct igbvf_adapter *adapter = netdev_priv(netdev); 1217 struct e1000_hw *hw = &adapter->hw; 1218 1219 if (hw->mac.ops.set_vfta(hw, vid, false)) { 1220 dev_err(&adapter->pdev->dev, 1221 "Failed to remove vlan id %d\n", vid); 1222 return -EINVAL; 1223 } 1224 clear_bit(vid, adapter->active_vlans); 1225 return 0; 1226} 1227 1228static void igbvf_restore_vlan(struct igbvf_adapter *adapter) 1229{ 1230 u16 vid; 1231 1232 for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID) 1233 igbvf_vlan_rx_add_vid(adapter->netdev, vid); 1234} 1235 1236/** 1237 * igbvf_configure_tx - Configure Transmit Unit after Reset 1238 * @adapter: board private structure 1239 * 1240 * Configure the Tx unit of the MAC after a reset. 1241 **/ 1242static void igbvf_configure_tx(struct igbvf_adapter *adapter) 1243{ 1244 struct e1000_hw *hw = &adapter->hw; 1245 struct igbvf_ring *tx_ring = adapter->tx_ring; 1246 u64 tdba; 1247 u32 txdctl, dca_txctrl; 1248 1249 /* disable transmits */ 1250 txdctl = er32(TXDCTL(0)); 1251 ew32(TXDCTL(0), txdctl & ~E1000_TXDCTL_QUEUE_ENABLE); 1252 e1e_flush(); 1253 msleep(10); 1254 1255 /* Setup the HW Tx Head and Tail descriptor pointers */ 1256 ew32(TDLEN(0), tx_ring->count * sizeof(union e1000_adv_tx_desc)); 1257 tdba = tx_ring->dma; 1258 ew32(TDBAL(0), (tdba & DMA_BIT_MASK(32))); 1259 ew32(TDBAH(0), (tdba >> 32)); 1260 ew32(TDH(0), 0); 1261 ew32(TDT(0), 0); 1262 tx_ring->head = E1000_TDH(0); 1263 tx_ring->tail = E1000_TDT(0); 1264 1265 /* Turn off Relaxed Ordering on head write-backs. The writebacks 1266 * MUST be delivered in order or it will completely screw up 1267 * our bookeeping. 1268 */ 1269 dca_txctrl = er32(DCA_TXCTRL(0)); 1270 dca_txctrl &= ~E1000_DCA_TXCTRL_TX_WB_RO_EN; 1271 ew32(DCA_TXCTRL(0), dca_txctrl); 1272 1273 /* enable transmits */ 1274 txdctl |= E1000_TXDCTL_QUEUE_ENABLE; 1275 ew32(TXDCTL(0), txdctl); 1276 1277 /* Setup Transmit Descriptor Settings for eop descriptor */ 1278 adapter->txd_cmd = E1000_ADVTXD_DCMD_EOP | E1000_ADVTXD_DCMD_IFCS; 1279 1280 /* enable Report Status bit */ 1281 adapter->txd_cmd |= E1000_ADVTXD_DCMD_RS; 1282} 1283 1284/** 1285 * igbvf_setup_srrctl - configure the receive control registers 1286 * @adapter: Board private structure 1287 **/ 1288static void igbvf_setup_srrctl(struct igbvf_adapter *adapter) 1289{ 1290 struct e1000_hw *hw = &adapter->hw; 1291 u32 srrctl = 0; 1292 1293 srrctl &= ~(E1000_SRRCTL_DESCTYPE_MASK | 1294 E1000_SRRCTL_BSIZEHDR_MASK | 1295 E1000_SRRCTL_BSIZEPKT_MASK); 1296 1297 /* Enable queue drop to avoid head of line blocking */ 1298 srrctl |= E1000_SRRCTL_DROP_EN; 1299 1300 /* Setup buffer sizes */ 1301 srrctl |= ALIGN(adapter->rx_buffer_len, 1024) >> 1302 E1000_SRRCTL_BSIZEPKT_SHIFT; 1303 1304 if (adapter->rx_buffer_len < 2048) { 1305 adapter->rx_ps_hdr_size = 0; 1306 srrctl |= E1000_SRRCTL_DESCTYPE_ADV_ONEBUF; 1307 } else { 1308 adapter->rx_ps_hdr_size = 128; 1309 srrctl |= adapter->rx_ps_hdr_size << 1310 E1000_SRRCTL_BSIZEHDRSIZE_SHIFT; 1311 srrctl |= E1000_SRRCTL_DESCTYPE_HDR_SPLIT_ALWAYS; 1312 } 1313 1314 ew32(SRRCTL(0), srrctl); 1315} 1316 1317/** 1318 * igbvf_configure_rx - Configure Receive Unit after Reset 1319 * @adapter: board private structure 1320 * 1321 * Configure the Rx unit of the MAC after a reset. 1322 **/ 1323static void igbvf_configure_rx(struct igbvf_adapter *adapter) 1324{ 1325 struct e1000_hw *hw = &adapter->hw; 1326 struct igbvf_ring *rx_ring = adapter->rx_ring; 1327 u64 rdba; 1328 u32 rdlen, rxdctl; 1329 1330 /* disable receives */ 1331 rxdctl = er32(RXDCTL(0)); 1332 ew32(RXDCTL(0), rxdctl & ~E1000_RXDCTL_QUEUE_ENABLE); 1333 e1e_flush(); 1334 msleep(10); 1335 1336 rdlen = rx_ring->count * sizeof(union e1000_adv_rx_desc); 1337 1338 /* 1339 * Setup the HW Rx Head and Tail Descriptor Pointers and 1340 * the Base and Length of the Rx Descriptor Ring 1341 */ 1342 rdba = rx_ring->dma; 1343 ew32(RDBAL(0), (rdba & DMA_BIT_MASK(32))); 1344 ew32(RDBAH(0), (rdba >> 32)); 1345 ew32(RDLEN(0), rx_ring->count * sizeof(union e1000_adv_rx_desc)); 1346 rx_ring->head = E1000_RDH(0); 1347 rx_ring->tail = E1000_RDT(0); 1348 ew32(RDH(0), 0); 1349 ew32(RDT(0), 0); 1350 1351 rxdctl |= E1000_RXDCTL_QUEUE_ENABLE; 1352 rxdctl &= 0xFFF00000; 1353 rxdctl |= IGBVF_RX_PTHRESH; 1354 rxdctl |= IGBVF_RX_HTHRESH << 8; 1355 rxdctl |= IGBVF_RX_WTHRESH << 16; 1356 1357 igbvf_set_rlpml(adapter); 1358 1359 /* enable receives */ 1360 ew32(RXDCTL(0), rxdctl); 1361} 1362 1363/** 1364 * igbvf_set_multi - Multicast and Promiscuous mode set 1365 * @netdev: network interface device structure 1366 * 1367 * The set_multi entry point is called whenever the multicast address 1368 * list or the network interface flags are updated. This routine is 1369 * responsible for configuring the hardware for proper multicast, 1370 * promiscuous mode, and all-multi behavior. 1371 **/ 1372static void igbvf_set_multi(struct net_device *netdev) 1373{ 1374 struct igbvf_adapter *adapter = netdev_priv(netdev); 1375 struct e1000_hw *hw = &adapter->hw; 1376 struct netdev_hw_addr *ha; 1377 u8 *mta_list = NULL; 1378 int i; 1379 1380 if (!netdev_mc_empty(netdev)) { 1381 mta_list = kmalloc(netdev_mc_count(netdev) * 6, GFP_ATOMIC); 1382 if (!mta_list) { 1383 dev_err(&adapter->pdev->dev, 1384 "failed to allocate multicast filter list\n"); 1385 return; 1386 } 1387 } 1388 1389 /* prepare a packed array of only addresses. */ 1390 i = 0; 1391 netdev_for_each_mc_addr(ha, netdev) 1392 memcpy(mta_list + (i++ * ETH_ALEN), ha->addr, ETH_ALEN); 1393 1394 hw->mac.ops.update_mc_addr_list(hw, mta_list, i, 0, 0); 1395 kfree(mta_list); 1396} 1397 1398/** 1399 * igbvf_configure - configure the hardware for Rx and Tx 1400 * @adapter: private board structure 1401 **/ 1402static void igbvf_configure(struct igbvf_adapter *adapter) 1403{ 1404 igbvf_set_multi(adapter->netdev); 1405 1406 igbvf_restore_vlan(adapter); 1407 1408 igbvf_configure_tx(adapter); 1409 igbvf_setup_srrctl(adapter); 1410 igbvf_configure_rx(adapter); 1411 igbvf_alloc_rx_buffers(adapter->rx_ring, 1412 igbvf_desc_unused(adapter->rx_ring)); 1413} 1414 1415/* igbvf_reset - bring the hardware into a known good state 1416 * 1417 * This function boots the hardware and enables some settings that 1418 * require a configuration cycle of the hardware - those cannot be 1419 * set/changed during runtime. After reset the device needs to be 1420 * properly configured for Rx, Tx etc. 1421 */ 1422static void igbvf_reset(struct igbvf_adapter *adapter) 1423{ 1424 struct e1000_mac_info *mac = &adapter->hw.mac; 1425 struct net_device *netdev = adapter->netdev; 1426 struct e1000_hw *hw = &adapter->hw; 1427 1428 /* Allow time for pending master requests to run */ 1429 if (mac->ops.reset_hw(hw)) 1430 dev_err(&adapter->pdev->dev, "PF still resetting\n"); 1431 1432 mac->ops.init_hw(hw); 1433 1434 if (is_valid_ether_addr(adapter->hw.mac.addr)) { 1435 memcpy(netdev->dev_addr, adapter->hw.mac.addr, 1436 netdev->addr_len); 1437 memcpy(netdev->perm_addr, adapter->hw.mac.addr, 1438 netdev->addr_len); 1439 } 1440 1441 adapter->last_reset = jiffies; 1442} 1443 1444int igbvf_up(struct igbvf_adapter *adapter) 1445{ 1446 struct e1000_hw *hw = &adapter->hw; 1447 1448 /* hardware has been reset, we need to reload some things */ 1449 igbvf_configure(adapter); 1450 1451 clear_bit(__IGBVF_DOWN, &adapter->state); 1452 1453 napi_enable(&adapter->rx_ring->napi); 1454 if (adapter->msix_entries) 1455 igbvf_configure_msix(adapter); 1456 1457 /* Clear any pending interrupts. */ 1458 er32(EICR); 1459 igbvf_irq_enable(adapter); 1460 1461 /* start the watchdog */ 1462 hw->mac.get_link_status = 1; 1463 mod_timer(&adapter->watchdog_timer, jiffies + 1); 1464 1465 1466 return 0; 1467} 1468 1469void igbvf_down(struct igbvf_adapter *adapter) 1470{ 1471 struct net_device *netdev = adapter->netdev; 1472 struct e1000_hw *hw = &adapter->hw; 1473 u32 rxdctl, txdctl; 1474 1475 /* 1476 * signal that we're down so the interrupt handler does not 1477 * reschedule our watchdog timer 1478 */ 1479 set_bit(__IGBVF_DOWN, &adapter->state); 1480 1481 /* disable receives in the hardware */ 1482 rxdctl = er32(RXDCTL(0)); 1483 ew32(RXDCTL(0), rxdctl & ~E1000_RXDCTL_QUEUE_ENABLE); 1484 1485 netif_stop_queue(netdev); 1486 1487 /* disable transmits in the hardware */ 1488 txdctl = er32(TXDCTL(0)); 1489 ew32(TXDCTL(0), txdctl & ~E1000_TXDCTL_QUEUE_ENABLE); 1490 1491 /* flush both disables and wait for them to finish */ 1492 e1e_flush(); 1493 msleep(10); 1494 1495 napi_disable(&adapter->rx_ring->napi); 1496 1497 igbvf_irq_disable(adapter); 1498 1499 del_timer_sync(&adapter->watchdog_timer); 1500 1501 netif_carrier_off(netdev); 1502 1503 /* record the stats before reset*/ 1504 igbvf_update_stats(adapter); 1505 1506 adapter->link_speed = 0; 1507 adapter->link_duplex = 0; 1508 1509 igbvf_reset(adapter); 1510 igbvf_clean_tx_ring(adapter->tx_ring); 1511 igbvf_clean_rx_ring(adapter->rx_ring); 1512} 1513 1514void igbvf_reinit_locked(struct igbvf_adapter *adapter) 1515{ 1516 might_sleep(); 1517 while (test_and_set_bit(__IGBVF_RESETTING, &adapter->state)) 1518 msleep(1); 1519 igbvf_down(adapter); 1520 igbvf_up(adapter); 1521 clear_bit(__IGBVF_RESETTING, &adapter->state); 1522} 1523 1524/** 1525 * igbvf_sw_init - Initialize general software structures (struct igbvf_adapter) 1526 * @adapter: board private structure to initialize 1527 * 1528 * igbvf_sw_init initializes the Adapter private data structure. 1529 * Fields are initialized based on PCI device information and 1530 * OS network device settings (MTU size). 1531 **/ 1532static int __devinit igbvf_sw_init(struct igbvf_adapter *adapter) 1533{ 1534 struct net_device *netdev = adapter->netdev; 1535 s32 rc; 1536 1537 adapter->rx_buffer_len = ETH_FRAME_LEN + VLAN_HLEN + ETH_FCS_LEN; 1538 adapter->rx_ps_hdr_size = 0; 1539 adapter->max_frame_size = netdev->mtu + ETH_HLEN + ETH_FCS_LEN; 1540 adapter->min_frame_size = ETH_ZLEN + ETH_FCS_LEN; 1541 1542 adapter->tx_int_delay = 8; 1543 adapter->tx_abs_int_delay = 32; 1544 adapter->rx_int_delay = 0; 1545 adapter->rx_abs_int_delay = 8; 1546 adapter->requested_itr = 3; 1547 adapter->current_itr = IGBVF_START_ITR; 1548 1549 /* Set various function pointers */ 1550 adapter->ei->init_ops(&adapter->hw); 1551 1552 rc = adapter->hw.mac.ops.init_params(&adapter->hw); 1553 if (rc) 1554 return rc; 1555 1556 rc = adapter->hw.mbx.ops.init_params(&adapter->hw); 1557 if (rc) 1558 return rc; 1559 1560 igbvf_set_interrupt_capability(adapter); 1561 1562 if (igbvf_alloc_queues(adapter)) 1563 return -ENOMEM; 1564 1565 spin_lock_init(&adapter->tx_queue_lock); 1566 1567 /* Explicitly disable IRQ since the NIC can be in any state. */ 1568 igbvf_irq_disable(adapter); 1569 1570 spin_lock_init(&adapter->stats_lock); 1571 1572 set_bit(__IGBVF_DOWN, &adapter->state); 1573 return 0; 1574} 1575 1576static void igbvf_initialize_last_counter_stats(struct igbvf_adapter *adapter) 1577{ 1578 struct e1000_hw *hw = &adapter->hw; 1579 1580 adapter->stats.last_gprc = er32(VFGPRC); 1581 adapter->stats.last_gorc = er32(VFGORC); 1582 adapter->stats.last_gptc = er32(VFGPTC); 1583 adapter->stats.last_gotc = er32(VFGOTC); 1584 adapter->stats.last_mprc = er32(VFMPRC); 1585 adapter->stats.last_gotlbc = er32(VFGOTLBC); 1586 adapter->stats.last_gptlbc = er32(VFGPTLBC); 1587 adapter->stats.last_gorlbc = er32(VFGORLBC); 1588 adapter->stats.last_gprlbc = er32(VFGPRLBC); 1589 1590 adapter->stats.base_gprc = er32(VFGPRC); 1591 adapter->stats.base_gorc = er32(VFGORC); 1592 adapter->stats.base_gptc = er32(VFGPTC); 1593 adapter->stats.base_gotc = er32(VFGOTC); 1594 adapter->stats.base_mprc = er32(VFMPRC); 1595 adapter->stats.base_gotlbc = er32(VFGOTLBC); 1596 adapter->stats.base_gptlbc = er32(VFGPTLBC); 1597 adapter->stats.base_gorlbc = er32(VFGORLBC); 1598 adapter->stats.base_gprlbc = er32(VFGPRLBC); 1599} 1600 1601/** 1602 * igbvf_open - Called when a network interface is made active 1603 * @netdev: network interface device structure 1604 * 1605 * Returns 0 on success, negative value on failure 1606 * 1607 * The open entry point is called when a network interface is made 1608 * active by the system (IFF_UP). At this point all resources needed 1609 * for transmit and receive operations are allocated, the interrupt 1610 * handler is registered with the OS, the watchdog timer is started, 1611 * and the stack is notified that the interface is ready. 1612 **/ 1613static int igbvf_open(struct net_device *netdev) 1614{ 1615 struct igbvf_adapter *adapter = netdev_priv(netdev); 1616 struct e1000_hw *hw = &adapter->hw; 1617 int err; 1618 1619 /* disallow open during test */ 1620 if (test_bit(__IGBVF_TESTING, &adapter->state)) 1621 return -EBUSY; 1622 1623 /* allocate transmit descriptors */ 1624 err = igbvf_setup_tx_resources(adapter, adapter->tx_ring); 1625 if (err) 1626 goto err_setup_tx; 1627 1628 /* allocate receive descriptors */ 1629 err = igbvf_setup_rx_resources(adapter, adapter->rx_ring); 1630 if (err) 1631 goto err_setup_rx; 1632 1633 /* 1634 * before we allocate an interrupt, we must be ready to handle it. 1635 * Setting DEBUG_SHIRQ in the kernel makes it fire an interrupt 1636 * as soon as we call pci_request_irq, so we have to setup our 1637 * clean_rx handler before we do so. 1638 */ 1639 igbvf_configure(adapter); 1640 1641 err = igbvf_request_irq(adapter); 1642 if (err) 1643 goto err_req_irq; 1644 1645 /* From here on the code is the same as igbvf_up() */ 1646 clear_bit(__IGBVF_DOWN, &adapter->state); 1647 1648 napi_enable(&adapter->rx_ring->napi); 1649 1650 /* clear any pending interrupts */ 1651 er32(EICR); 1652 1653 igbvf_irq_enable(adapter); 1654 1655 /* start the watchdog */ 1656 hw->mac.get_link_status = 1; 1657 mod_timer(&adapter->watchdog_timer, jiffies + 1); 1658 1659 return 0; 1660 1661err_req_irq: 1662 igbvf_free_rx_resources(adapter->rx_ring); 1663err_setup_rx: 1664 igbvf_free_tx_resources(adapter->tx_ring); 1665err_setup_tx: 1666 igbvf_reset(adapter); 1667 1668 return err; 1669} 1670 1671/** 1672 * igbvf_close - Disables a network interface 1673 * @netdev: network interface device structure 1674 * 1675 * Returns 0, this is not allowed to fail 1676 * 1677 * The close entry point is called when an interface is de-activated 1678 * by the OS. The hardware is still under the drivers control, but 1679 * needs to be disabled. A global MAC reset is issued to stop the 1680 * hardware, and all transmit and receive resources are freed. 1681 **/ 1682static int igbvf_close(struct net_device *netdev) 1683{ 1684 struct igbvf_adapter *adapter = netdev_priv(netdev); 1685 1686 WARN_ON(test_bit(__IGBVF_RESETTING, &adapter->state)); 1687 igbvf_down(adapter); 1688 1689 igbvf_free_irq(adapter); 1690 1691 igbvf_free_tx_resources(adapter->tx_ring); 1692 igbvf_free_rx_resources(adapter->rx_ring); 1693 1694 return 0; 1695} 1696/** 1697 * igbvf_set_mac - Change the Ethernet Address of the NIC 1698 * @netdev: network interface device structure 1699 * @p: pointer to an address structure 1700 * 1701 * Returns 0 on success, negative on failure 1702 **/ 1703static int igbvf_set_mac(struct net_device *netdev, void *p) 1704{ 1705 struct igbvf_adapter *adapter = netdev_priv(netdev); 1706 struct e1000_hw *hw = &adapter->hw; 1707 struct sockaddr *addr = p; 1708 1709 if (!is_valid_ether_addr(addr->sa_data)) 1710 return -EADDRNOTAVAIL; 1711 1712 memcpy(hw->mac.addr, addr->sa_data, netdev->addr_len); 1713 1714 hw->mac.ops.rar_set(hw, hw->mac.addr, 0); 1715 1716 if (memcmp(addr->sa_data, hw->mac.addr, 6)) 1717 return -EADDRNOTAVAIL; 1718 1719 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len); 1720 netdev->addr_assign_type &= ~NET_ADDR_RANDOM; 1721 1722 return 0; 1723} 1724 1725#define UPDATE_VF_COUNTER(reg, name) \ 1726 { \ 1727 u32 current_counter = er32(reg); \ 1728 if (current_counter < adapter->stats.last_##name) \ 1729 adapter->stats.name += 0x100000000LL; \ 1730 adapter->stats.last_##name = current_counter; \ 1731 adapter->stats.name &= 0xFFFFFFFF00000000LL; \ 1732 adapter->stats.name |= current_counter; \ 1733 } 1734 1735/** 1736 * igbvf_update_stats - Update the board statistics counters 1737 * @adapter: board private structure 1738**/ 1739void igbvf_update_stats(struct igbvf_adapter *adapter) 1740{ 1741 struct e1000_hw *hw = &adapter->hw; 1742 struct pci_dev *pdev = adapter->pdev; 1743 1744 /* 1745 * Prevent stats update while adapter is being reset, link is down 1746 * or if the pci connection is down. 1747 */ 1748 if (adapter->link_speed == 0) 1749 return; 1750 1751 if (test_bit(__IGBVF_RESETTING, &adapter->state)) 1752 return; 1753 1754 if (pci_channel_offline(pdev)) 1755 return; 1756 1757 UPDATE_VF_COUNTER(VFGPRC, gprc); 1758 UPDATE_VF_COUNTER(VFGORC, gorc); 1759 UPDATE_VF_COUNTER(VFGPTC, gptc); 1760 UPDATE_VF_COUNTER(VFGOTC, gotc); 1761 UPDATE_VF_COUNTER(VFMPRC, mprc); 1762 UPDATE_VF_COUNTER(VFGOTLBC, gotlbc); 1763 UPDATE_VF_COUNTER(VFGPTLBC, gptlbc); 1764 UPDATE_VF_COUNTER(VFGORLBC, gorlbc); 1765 UPDATE_VF_COUNTER(VFGPRLBC, gprlbc); 1766 1767 /* Fill out the OS statistics structure */ 1768 adapter->net_stats.multicast = adapter->stats.mprc; 1769} 1770 1771static void igbvf_print_link_info(struct igbvf_adapter *adapter) 1772{ 1773 dev_info(&adapter->pdev->dev, "Link is Up %d Mbps %s Duplex\n", 1774 adapter->link_speed, 1775 adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half"); 1776} 1777 1778static bool igbvf_has_link(struct igbvf_adapter *adapter) 1779{ 1780 struct e1000_hw *hw = &adapter->hw; 1781 s32 ret_val = E1000_SUCCESS; 1782 bool link_active; 1783 1784 /* If interface is down, stay link down */ 1785 if (test_bit(__IGBVF_DOWN, &adapter->state)) 1786 return false; 1787 1788 ret_val = hw->mac.ops.check_for_link(hw); 1789 link_active = !hw->mac.get_link_status; 1790 1791 /* if check for link returns error we will need to reset */ 1792 if (ret_val && time_after(jiffies, adapter->last_reset + (10 * HZ))) 1793 schedule_work(&adapter->reset_task); 1794 1795 return link_active; 1796} 1797 1798/** 1799 * igbvf_watchdog - Timer Call-back 1800 * @data: pointer to adapter cast into an unsigned long 1801 **/ 1802static void igbvf_watchdog(unsigned long data) 1803{ 1804 struct igbvf_adapter *adapter = (struct igbvf_adapter *) data; 1805 1806 /* Do the rest outside of interrupt context */ 1807 schedule_work(&adapter->watchdog_task); 1808} 1809 1810static void igbvf_watchdog_task(struct work_struct *work) 1811{ 1812 struct igbvf_adapter *adapter = container_of(work, 1813 struct igbvf_adapter, 1814 watchdog_task); 1815 struct net_device *netdev = adapter->netdev; 1816 struct e1000_mac_info *mac = &adapter->hw.mac; 1817 struct igbvf_ring *tx_ring = adapter->tx_ring; 1818 struct e1000_hw *hw = &adapter->hw; 1819 u32 link; 1820 int tx_pending = 0; 1821 1822 link = igbvf_has_link(adapter); 1823 1824 if (link) { 1825 if (!netif_carrier_ok(netdev)) { 1826 mac->ops.get_link_up_info(&adapter->hw, 1827 &adapter->link_speed, 1828 &adapter->link_duplex); 1829 igbvf_print_link_info(adapter); 1830 1831 netif_carrier_on(netdev); 1832 netif_wake_queue(netdev); 1833 } 1834 } else { 1835 if (netif_carrier_ok(netdev)) { 1836 adapter->link_speed = 0; 1837 adapter->link_duplex = 0; 1838 dev_info(&adapter->pdev->dev, "Link is Down\n"); 1839 netif_carrier_off(netdev); 1840 netif_stop_queue(netdev); 1841 } 1842 } 1843 1844 if (netif_carrier_ok(netdev)) { 1845 igbvf_update_stats(adapter); 1846 } else { 1847 tx_pending = (igbvf_desc_unused(tx_ring) + 1 < 1848 tx_ring->count); 1849 if (tx_pending) { 1850 /* 1851 * We've lost link, so the controller stops DMA, 1852 * but we've got queued Tx work that's never going 1853 * to get done, so reset controller to flush Tx. 1854 * (Do the reset outside of interrupt context). 1855 */ 1856 adapter->tx_timeout_count++; 1857 schedule_work(&adapter->reset_task); 1858 } 1859 } 1860 1861 /* Cause software interrupt to ensure Rx ring is cleaned */ 1862 ew32(EICS, adapter->rx_ring->eims_value); 1863 1864 /* Reset the timer */ 1865 if (!test_bit(__IGBVF_DOWN, &adapter->state)) 1866 mod_timer(&adapter->watchdog_timer, 1867 round_jiffies(jiffies + (2 * HZ))); 1868} 1869 1870#define IGBVF_TX_FLAGS_CSUM 0x00000001 1871#define IGBVF_TX_FLAGS_VLAN 0x00000002 1872#define IGBVF_TX_FLAGS_TSO 0x00000004 1873#define IGBVF_TX_FLAGS_IPV4 0x00000008 1874#define IGBVF_TX_FLAGS_VLAN_MASK 0xffff0000 1875#define IGBVF_TX_FLAGS_VLAN_SHIFT 16 1876 1877static int igbvf_tso(struct igbvf_adapter *adapter, 1878 struct igbvf_ring *tx_ring, 1879 struct sk_buff *skb, u32 tx_flags, u8 *hdr_len) 1880{ 1881 struct e1000_adv_tx_context_desc *context_desc; 1882 unsigned int i; 1883 int err; 1884 struct igbvf_buffer *buffer_info; 1885 u32 info = 0, tu_cmd = 0; 1886 u32 mss_l4len_idx, l4len; 1887 *hdr_len = 0; 1888 1889 if (skb_header_cloned(skb)) { 1890 err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC); 1891 if (err) { 1892 dev_err(&adapter->pdev->dev, 1893 "igbvf_tso returning an error\n"); 1894 return err; 1895 } 1896 } 1897 1898 l4len = tcp_hdrlen(skb); 1899 *hdr_len += l4len; 1900 1901 if (skb->protocol == htons(ETH_P_IP)) { 1902 struct iphdr *iph = ip_hdr(skb); 1903 iph->tot_len = 0; 1904 iph->check = 0; 1905 tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr, 1906 iph->daddr, 0, 1907 IPPROTO_TCP, 1908 0); 1909 } else if (skb_is_gso_v6(skb)) { 1910 ipv6_hdr(skb)->payload_len = 0; 1911 tcp_hdr(skb)->check = ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr, 1912 &ipv6_hdr(skb)->daddr, 1913 0, IPPROTO_TCP, 0); 1914 } 1915 1916 i = tx_ring->next_to_use; 1917 1918 buffer_info = &tx_ring->buffer_info[i]; 1919 context_desc = IGBVF_TX_CTXTDESC_ADV(*tx_ring, i); 1920 /* VLAN MACLEN IPLEN */ 1921 if (tx_flags & IGBVF_TX_FLAGS_VLAN) 1922 info |= (tx_flags & IGBVF_TX_FLAGS_VLAN_MASK); 1923 info |= (skb_network_offset(skb) << E1000_ADVTXD_MACLEN_SHIFT); 1924 *hdr_len += skb_network_offset(skb); 1925 info |= (skb_transport_header(skb) - skb_network_header(skb)); 1926 *hdr_len += (skb_transport_header(skb) - skb_network_header(skb)); 1927 context_desc->vlan_macip_lens = cpu_to_le32(info); 1928 1929 /* ADV DTYP TUCMD MKRLOC/ISCSIHEDLEN */ 1930 tu_cmd |= (E1000_TXD_CMD_DEXT | E1000_ADVTXD_DTYP_CTXT); 1931 1932 if (skb->protocol == htons(ETH_P_IP)) 1933 tu_cmd |= E1000_ADVTXD_TUCMD_IPV4; 1934 tu_cmd |= E1000_ADVTXD_TUCMD_L4T_TCP; 1935 1936 context_desc->type_tucmd_mlhl = cpu_to_le32(tu_cmd); 1937 1938 /* MSS L4LEN IDX */ 1939 mss_l4len_idx = (skb_shinfo(skb)->gso_size << E1000_ADVTXD_MSS_SHIFT); 1940 mss_l4len_idx |= (l4len << E1000_ADVTXD_L4LEN_SHIFT); 1941 1942 context_desc->mss_l4len_idx = cpu_to_le32(mss_l4len_idx); 1943 context_desc->seqnum_seed = 0; 1944 1945 buffer_info->time_stamp = jiffies; 1946 buffer_info->next_to_watch = i; 1947 buffer_info->dma = 0; 1948 i++; 1949 if (i == tx_ring->count) 1950 i = 0; 1951 1952 tx_ring->next_to_use = i; 1953 1954 return true; 1955} 1956 1957static inline bool igbvf_tx_csum(struct igbvf_adapter *adapter, 1958 struct igbvf_ring *tx_ring, 1959 struct sk_buff *skb, u32 tx_flags) 1960{ 1961 struct e1000_adv_tx_context_desc *context_desc; 1962 unsigned int i; 1963 struct igbvf_buffer *buffer_info; 1964 u32 info = 0, tu_cmd = 0; 1965 1966 if ((skb->ip_summed == CHECKSUM_PARTIAL) || 1967 (tx_flags & IGBVF_TX_FLAGS_VLAN)) { 1968 i = tx_ring->next_to_use; 1969 buffer_info = &tx_ring->buffer_info[i]; 1970 context_desc = IGBVF_TX_CTXTDESC_ADV(*tx_ring, i); 1971 1972 if (tx_flags & IGBVF_TX_FLAGS_VLAN) 1973 info |= (tx_flags & IGBVF_TX_FLAGS_VLAN_MASK); 1974 1975 info |= (skb_network_offset(skb) << E1000_ADVTXD_MACLEN_SHIFT); 1976 if (skb->ip_summed == CHECKSUM_PARTIAL) 1977 info |= (skb_transport_header(skb) - 1978 skb_network_header(skb)); 1979 1980 1981 context_desc->vlan_macip_lens = cpu_to_le32(info); 1982 1983 tu_cmd |= (E1000_TXD_CMD_DEXT | E1000_ADVTXD_DTYP_CTXT); 1984 1985 if (skb->ip_summed == CHECKSUM_PARTIAL) { 1986 switch (skb->protocol) { 1987 case __constant_htons(ETH_P_IP): 1988 tu_cmd |= E1000_ADVTXD_TUCMD_IPV4; 1989 if (ip_hdr(skb)->protocol == IPPROTO_TCP) 1990 tu_cmd |= E1000_ADVTXD_TUCMD_L4T_TCP; 1991 break; 1992 case __constant_htons(ETH_P_IPV6): 1993 if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP) 1994 tu_cmd |= E1000_ADVTXD_TUCMD_L4T_TCP; 1995 break; 1996 default: 1997 break; 1998 } 1999 } 2000 2001 context_desc->type_tucmd_mlhl = cpu_to_le32(tu_cmd); 2002 context_desc->seqnum_seed = 0; 2003 context_desc->mss_l4len_idx = 0; 2004 2005 buffer_info->time_stamp = jiffies; 2006 buffer_info->next_to_watch = i; 2007 buffer_info->dma = 0; 2008 i++; 2009 if (i == tx_ring->count) 2010 i = 0; 2011 tx_ring->next_to_use = i; 2012 2013 return true; 2014 } 2015 2016 return false; 2017} 2018 2019static int igbvf_maybe_stop_tx(struct net_device *netdev, int size) 2020{ 2021 struct igbvf_adapter *adapter = netdev_priv(netdev); 2022 2023 /* there is enough descriptors then we don't need to worry */ 2024 if (igbvf_desc_unused(adapter->tx_ring) >= size) 2025 return 0; 2026 2027 netif_stop_queue(netdev); 2028 2029 smp_mb(); 2030 2031 /* We need to check again just in case room has been made available */ 2032 if (igbvf_desc_unused(adapter->tx_ring) < size) 2033 return -EBUSY; 2034 2035 netif_wake_queue(netdev); 2036 2037 ++adapter->restart_queue; 2038 return 0; 2039} 2040 2041#define IGBVF_MAX_TXD_PWR 16 2042#define IGBVF_MAX_DATA_PER_TXD (1 << IGBVF_MAX_TXD_PWR) 2043 2044static inline int igbvf_tx_map_adv(struct igbvf_adapter *adapter, 2045 struct igbvf_ring *tx_ring, 2046 struct sk_buff *skb, 2047 unsigned int first) 2048{ 2049 struct igbvf_buffer *buffer_info; 2050 struct pci_dev *pdev = adapter->pdev; 2051 unsigned int len = skb_headlen(skb); 2052 unsigned int count = 0, i; 2053 unsigned int f; 2054 2055 i = tx_ring->next_to_use; 2056 2057 buffer_info = &tx_ring->buffer_info[i]; 2058 BUG_ON(len >= IGBVF_MAX_DATA_PER_TXD); 2059 buffer_info->length = len; 2060 /* set time_stamp *before* dma to help avoid a possible race */ 2061 buffer_info->time_stamp = jiffies; 2062 buffer_info->next_to_watch = i; 2063 buffer_info->mapped_as_page = false; 2064 buffer_info->dma = dma_map_single(&pdev->dev, skb->data, len, 2065 DMA_TO_DEVICE); 2066 if (dma_mapping_error(&pdev->dev, buffer_info->dma)) 2067 goto dma_error; 2068 2069 2070 for (f = 0; f < skb_shinfo(skb)->nr_frags; f++) { 2071 const struct skb_frag_struct *frag; 2072 2073 count++; 2074 i++; 2075 if (i == tx_ring->count) 2076 i = 0; 2077 2078 frag = &skb_shinfo(skb)->frags[f]; 2079 len = skb_frag_size(frag); 2080 2081 buffer_info = &tx_ring->buffer_info[i]; 2082 BUG_ON(len >= IGBVF_MAX_DATA_PER_TXD); 2083 buffer_info->length = len; 2084 buffer_info->time_stamp = jiffies; 2085 buffer_info->next_to_watch = i; 2086 buffer_info->mapped_as_page = true; 2087 buffer_info->dma = skb_frag_dma_map(&pdev->dev, frag, 0, len, 2088 DMA_TO_DEVICE); 2089 if (dma_mapping_error(&pdev->dev, buffer_info->dma)) 2090 goto dma_error; 2091 } 2092 2093 tx_ring->buffer_info[i].skb = skb; 2094 tx_ring->buffer_info[first].next_to_watch = i; 2095 2096 return ++count; 2097 2098dma_error: 2099 dev_err(&pdev->dev, "TX DMA map failed\n"); 2100 2101 /* clear timestamp and dma mappings for failed buffer_info mapping */ 2102 buffer_info->dma = 0; 2103 buffer_info->time_stamp = 0; 2104 buffer_info->length = 0; 2105 buffer_info->next_to_watch = 0; 2106 buffer_info->mapped_as_page = false; 2107 if (count) 2108 count--; 2109 2110 /* clear timestamp and dma mappings for remaining portion of packet */ 2111 while (count--) { 2112 if (i==0) 2113 i += tx_ring->count; 2114 i--; 2115 buffer_info = &tx_ring->buffer_info[i]; 2116 igbvf_put_txbuf(adapter, buffer_info); 2117 } 2118 2119 return 0; 2120} 2121 2122static inline void igbvf_tx_queue_adv(struct igbvf_adapter *adapter, 2123 struct igbvf_ring *tx_ring, 2124 int tx_flags, int count, u32 paylen, 2125 u8 hdr_len) 2126{ 2127 union e1000_adv_tx_desc *tx_desc = NULL; 2128 struct igbvf_buffer *buffer_info; 2129 u32 olinfo_status = 0, cmd_type_len; 2130 unsigned int i; 2131 2132 cmd_type_len = (E1000_ADVTXD_DTYP_DATA | E1000_ADVTXD_DCMD_IFCS | 2133 E1000_ADVTXD_DCMD_DEXT); 2134 2135 if (tx_flags & IGBVF_TX_FLAGS_VLAN) 2136 cmd_type_len |= E1000_ADVTXD_DCMD_VLE; 2137 2138 if (tx_flags & IGBVF_TX_FLAGS_TSO) { 2139 cmd_type_len |= E1000_ADVTXD_DCMD_TSE; 2140 2141 /* insert tcp checksum */ 2142 olinfo_status |= E1000_TXD_POPTS_TXSM << 8; 2143 2144 /* insert ip checksum */ 2145 if (tx_flags & IGBVF_TX_FLAGS_IPV4) 2146 olinfo_status |= E1000_TXD_POPTS_IXSM << 8; 2147 2148 } else if (tx_flags & IGBVF_TX_FLAGS_CSUM) { 2149 olinfo_status |= E1000_TXD_POPTS_TXSM << 8; 2150 } 2151 2152 olinfo_status |= ((paylen - hdr_len) << E1000_ADVTXD_PAYLEN_SHIFT); 2153 2154 i = tx_ring->next_to_use; 2155 while (count--) { 2156 buffer_info = &tx_ring->buffer_info[i]; 2157 tx_desc = IGBVF_TX_DESC_ADV(*tx_ring, i); 2158 tx_desc->read.buffer_addr = cpu_to_le64(buffer_info->dma); 2159 tx_desc->read.cmd_type_len = 2160 cpu_to_le32(cmd_type_len | buffer_info->length); 2161 tx_desc->read.olinfo_status = cpu_to_le32(olinfo_status); 2162 i++; 2163 if (i == tx_ring->count) 2164 i = 0; 2165 } 2166 2167 tx_desc->read.cmd_type_len |= cpu_to_le32(adapter->txd_cmd); 2168 /* Force memory writes to complete before letting h/w 2169 * know there are new descriptors to fetch. (Only 2170 * applicable for weak-ordered memory model archs, 2171 * such as IA-64). */ 2172 wmb(); 2173 2174 tx_ring->next_to_use = i; 2175 writel(i, adapter->hw.hw_addr + tx_ring->tail); 2176 /* we need this if more than one processor can write to our tail 2177 * at a time, it syncronizes IO on IA64/Altix systems */ 2178 mmiowb(); 2179} 2180 2181static netdev_tx_t igbvf_xmit_frame_ring_adv(struct sk_buff *skb, 2182 struct net_device *netdev, 2183 struct igbvf_ring *tx_ring) 2184{ 2185 struct igbvf_adapter *adapter = netdev_priv(netdev); 2186 unsigned int first, tx_flags = 0; 2187 u8 hdr_len = 0; 2188 int count = 0; 2189 int tso = 0; 2190 2191 if (test_bit(__IGBVF_DOWN, &adapter->state)) { 2192 dev_kfree_skb_any(skb); 2193 return NETDEV_TX_OK; 2194 } 2195 2196 if (skb->len <= 0) { 2197 dev_kfree_skb_any(skb); 2198 return NETDEV_TX_OK; 2199 } 2200 2201 /* 2202 * need: count + 4 desc gap to keep tail from touching 2203 * + 2 desc gap to keep tail from touching head, 2204 * + 1 desc for skb->data, 2205 * + 1 desc for context descriptor, 2206 * head, otherwise try next time 2207 */ 2208 if (igbvf_maybe_stop_tx(netdev, skb_shinfo(skb)->nr_frags + 4)) { 2209 /* this is a hard error */ 2210 return NETDEV_TX_BUSY; 2211 } 2212 2213 if (vlan_tx_tag_present(skb)) { 2214 tx_flags |= IGBVF_TX_FLAGS_VLAN; 2215 tx_flags |= (vlan_tx_tag_get(skb) << IGBVF_TX_FLAGS_VLAN_SHIFT); 2216 } 2217 2218 if (skb->protocol == htons(ETH_P_IP)) 2219 tx_flags |= IGBVF_TX_FLAGS_IPV4; 2220 2221 first = tx_ring->next_to_use; 2222 2223 tso = skb_is_gso(skb) ? 2224 igbvf_tso(adapter, tx_ring, skb, tx_flags, &hdr_len) : 0; 2225 if (unlikely(tso < 0)) { 2226 dev_kfree_skb_any(skb); 2227 return NETDEV_TX_OK; 2228 } 2229 2230 if (tso) 2231 tx_flags |= IGBVF_TX_FLAGS_TSO; 2232 else if (igbvf_tx_csum(adapter, tx_ring, skb, tx_flags) && 2233 (skb->ip_summed == CHECKSUM_PARTIAL)) 2234 tx_flags |= IGBVF_TX_FLAGS_CSUM; 2235 2236 /* 2237 * count reflects descriptors mapped, if 0 then mapping error 2238 * has occurred and we need to rewind the descriptor queue 2239 */ 2240 count = igbvf_tx_map_adv(adapter, tx_ring, skb, first); 2241 2242 if (count) { 2243 igbvf_tx_queue_adv(adapter, tx_ring, tx_flags, count, 2244 skb->len, hdr_len); 2245 /* Make sure there is space in the ring for the next send. */ 2246 igbvf_maybe_stop_tx(netdev, MAX_SKB_FRAGS + 4); 2247 } else { 2248 dev_kfree_skb_any(skb); 2249 tx_ring->buffer_info[first].time_stamp = 0; 2250 tx_ring->next_to_use = first; 2251 } 2252 2253 return NETDEV_TX_OK; 2254} 2255 2256static netdev_tx_t igbvf_xmit_frame(struct sk_buff *skb, 2257 struct net_device *netdev) 2258{ 2259 struct igbvf_adapter *adapter = netdev_priv(netdev); 2260 struct igbvf_ring *tx_ring; 2261 2262 if (test_bit(__IGBVF_DOWN, &adapter->state)) { 2263 dev_kfree_skb_any(skb); 2264 return NETDEV_TX_OK; 2265 } 2266 2267 tx_ring = &adapter->tx_ring[0]; 2268 2269 return igbvf_xmit_frame_ring_adv(skb, netdev, tx_ring); 2270} 2271 2272/** 2273 * igbvf_tx_timeout - Respond to a Tx Hang 2274 * @netdev: network interface device structure 2275 **/ 2276static void igbvf_tx_timeout(struct net_device *netdev) 2277{ 2278 struct igbvf_adapter *adapter = netdev_priv(netdev); 2279 2280 /* Do the reset outside of interrupt context */ 2281 adapter->tx_timeout_count++; 2282 schedule_work(&adapter->reset_task); 2283} 2284 2285static void igbvf_reset_task(struct work_struct *work) 2286{ 2287 struct igbvf_adapter *adapter; 2288 adapter = container_of(work, struct igbvf_adapter, reset_task); 2289 2290 igbvf_reinit_locked(adapter); 2291} 2292 2293/** 2294 * igbvf_get_stats - Get System Network Statistics 2295 * @netdev: network interface device structure 2296 * 2297 * Returns the address of the device statistics structure. 2298 * The statistics are actually updated from the timer callback. 2299 **/ 2300static struct net_device_stats *igbvf_get_stats(struct net_device *netdev) 2301{ 2302 struct igbvf_adapter *adapter = netdev_priv(netdev); 2303 2304 /* only return the current stats */ 2305 return &adapter->net_stats; 2306} 2307 2308/** 2309 * igbvf_change_mtu - Change the Maximum Transfer Unit 2310 * @netdev: network interface device structure 2311 * @new_mtu: new value for maximum frame size 2312 * 2313 * Returns 0 on success, negative on failure 2314 **/ 2315static int igbvf_change_mtu(struct net_device *netdev, int new_mtu) 2316{ 2317 struct igbvf_adapter *adapter = netdev_priv(netdev); 2318 int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN; 2319 2320 if ((new_mtu < 68) || (max_frame > MAX_JUMBO_FRAME_SIZE)) { 2321 dev_err(&adapter->pdev->dev, "Invalid MTU setting\n"); 2322 return -EINVAL; 2323 } 2324 2325#define MAX_STD_JUMBO_FRAME_SIZE 9234 2326 if (max_frame > MAX_STD_JUMBO_FRAME_SIZE) { 2327 dev_err(&adapter->pdev->dev, "MTU > 9216 not supported.\n"); 2328 return -EINVAL; 2329 } 2330 2331 while (test_and_set_bit(__IGBVF_RESETTING, &adapter->state)) 2332 msleep(1); 2333 /* igbvf_down has a dependency on max_frame_size */ 2334 adapter->max_frame_size = max_frame; 2335 if (netif_running(netdev)) 2336 igbvf_down(adapter); 2337 2338 /* 2339 * NOTE: netdev_alloc_skb reserves 16 bytes, and typically NET_IP_ALIGN 2340 * means we reserve 2 more, this pushes us to allocate from the next 2341 * larger slab size. 2342 * i.e. RXBUFFER_2048 --> size-4096 slab 2343 * However with the new *_jumbo_rx* routines, jumbo receives will use 2344 * fragmented skbs 2345 */ 2346 2347 if (max_frame <= 1024) 2348 adapter->rx_buffer_len = 1024; 2349 else if (max_frame <= 2048) 2350 adapter->rx_buffer_len = 2048; 2351 else 2352#if (PAGE_SIZE / 2) > 16384 2353 adapter->rx_buffer_len = 16384; 2354#else 2355 adapter->rx_buffer_len = PAGE_SIZE / 2; 2356#endif 2357 2358 2359 /* adjust allocation if LPE protects us, and we aren't using SBP */ 2360 if ((max_frame == ETH_FRAME_LEN + ETH_FCS_LEN) || 2361 (max_frame == ETH_FRAME_LEN + VLAN_HLEN + ETH_FCS_LEN)) 2362 adapter->rx_buffer_len = ETH_FRAME_LEN + VLAN_HLEN + 2363 ETH_FCS_LEN; 2364 2365 dev_info(&adapter->pdev->dev, "changing MTU from %d to %d\n", 2366 netdev->mtu, new_mtu); 2367 netdev->mtu = new_mtu; 2368 2369 if (netif_running(netdev)) 2370 igbvf_up(adapter); 2371 else 2372 igbvf_reset(adapter); 2373 2374 clear_bit(__IGBVF_RESETTING, &adapter->state); 2375 2376 return 0; 2377} 2378 2379static int igbvf_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd) 2380{ 2381 switch (cmd) { 2382 default: 2383 return -EOPNOTSUPP; 2384 } 2385} 2386 2387static int igbvf_suspend(struct pci_dev *pdev, pm_message_t state) 2388{ 2389 struct net_device *netdev = pci_get_drvdata(pdev); 2390 struct igbvf_adapter *adapter = netdev_priv(netdev); 2391#ifdef CONFIG_PM 2392 int retval = 0; 2393#endif 2394 2395 netif_device_detach(netdev); 2396 2397 if (netif_running(netdev)) { 2398 WARN_ON(test_bit(__IGBVF_RESETTING, &adapter->state)); 2399 igbvf_down(adapter); 2400 igbvf_free_irq(adapter); 2401 } 2402 2403#ifdef CONFIG_PM 2404 retval = pci_save_state(pdev); 2405 if (retval) 2406 return retval; 2407#endif 2408 2409 pci_disable_device(pdev); 2410 2411 return 0; 2412} 2413 2414#ifdef CONFIG_PM 2415static int igbvf_resume(struct pci_dev *pdev) 2416{ 2417 struct net_device *netdev = pci_get_drvdata(pdev); 2418 struct igbvf_adapter *adapter = netdev_priv(netdev); 2419 u32 err; 2420 2421 pci_restore_state(pdev); 2422 err = pci_enable_device_mem(pdev); 2423 if (err) { 2424 dev_err(&pdev->dev, "Cannot enable PCI device from suspend\n"); 2425 return err; 2426 } 2427 2428 pci_set_master(pdev); 2429 2430 if (netif_running(netdev)) { 2431 err = igbvf_request_irq(adapter); 2432 if (err) 2433 return err; 2434 } 2435 2436 igbvf_reset(adapter); 2437 2438 if (netif_running(netdev)) 2439 igbvf_up(adapter); 2440 2441 netif_device_attach(netdev); 2442 2443 return 0; 2444} 2445#endif 2446 2447static void igbvf_shutdown(struct pci_dev *pdev) 2448{ 2449 igbvf_suspend(pdev, PMSG_SUSPEND); 2450} 2451 2452#ifdef CONFIG_NET_POLL_CONTROLLER 2453/* 2454 * Polling 'interrupt' - used by things like netconsole to send skbs 2455 * without having to re-enable interrupts. It's not called while 2456 * the interrupt routine is executing. 2457 */ 2458static void igbvf_netpoll(struct net_device *netdev) 2459{ 2460 struct igbvf_adapter *adapter = netdev_priv(netdev); 2461 2462 disable_irq(adapter->pdev->irq); 2463 2464 igbvf_clean_tx_irq(adapter->tx_ring); 2465 2466 enable_irq(adapter->pdev->irq); 2467} 2468#endif 2469 2470/** 2471 * igbvf_io_error_detected - called when PCI error is detected 2472 * @pdev: Pointer to PCI device 2473 * @state: The current pci connection state 2474 * 2475 * This function is called after a PCI bus error affecting 2476 * this device has been detected. 2477 */ 2478static pci_ers_result_t igbvf_io_error_detected(struct pci_dev *pdev, 2479 pci_channel_state_t state) 2480{ 2481 struct net_device *netdev = pci_get_drvdata(pdev); 2482 struct igbvf_adapter *adapter = netdev_priv(netdev); 2483 2484 netif_device_detach(netdev); 2485 2486 if (state == pci_channel_io_perm_failure) 2487 return PCI_ERS_RESULT_DISCONNECT; 2488 2489 if (netif_running(netdev)) 2490 igbvf_down(adapter); 2491 pci_disable_device(pdev); 2492 2493 /* Request a slot slot reset. */ 2494 return PCI_ERS_RESULT_NEED_RESET; 2495} 2496 2497/** 2498 * igbvf_io_slot_reset - called after the pci bus has been reset. 2499 * @pdev: Pointer to PCI device 2500 * 2501 * Restart the card from scratch, as if from a cold-boot. Implementation 2502 * resembles the first-half of the igbvf_resume routine. 2503 */ 2504static pci_ers_result_t igbvf_io_slot_reset(struct pci_dev *pdev) 2505{ 2506 struct net_device *netdev = pci_get_drvdata(pdev); 2507 struct igbvf_adapter *adapter = netdev_priv(netdev); 2508 2509 if (pci_enable_device_mem(pdev)) { 2510 dev_err(&pdev->dev, 2511 "Cannot re-enable PCI device after reset.\n"); 2512 return PCI_ERS_RESULT_DISCONNECT; 2513 } 2514 pci_set_master(pdev); 2515 2516 igbvf_reset(adapter); 2517 2518 return PCI_ERS_RESULT_RECOVERED; 2519} 2520 2521/** 2522 * igbvf_io_resume - called when traffic can start flowing again. 2523 * @pdev: Pointer to PCI device 2524 * 2525 * This callback is called when the error recovery driver tells us that 2526 * its OK to resume normal operation. Implementation resembles the 2527 * second-half of the igbvf_resume routine. 2528 */ 2529static void igbvf_io_resume(struct pci_dev *pdev) 2530{ 2531 struct net_device *netdev = pci_get_drvdata(pdev); 2532 struct igbvf_adapter *adapter = netdev_priv(netdev); 2533 2534 if (netif_running(netdev)) { 2535 if (igbvf_up(adapter)) { 2536 dev_err(&pdev->dev, 2537 "can't bring device back up after reset\n"); 2538 return; 2539 } 2540 } 2541 2542 netif_device_attach(netdev); 2543} 2544 2545static void igbvf_print_device_info(struct igbvf_adapter *adapter) 2546{ 2547 struct e1000_hw *hw = &adapter->hw; 2548 struct net_device *netdev = adapter->netdev; 2549 struct pci_dev *pdev = adapter->pdev; 2550 2551 if (hw->mac.type == e1000_vfadapt_i350) 2552 dev_info(&pdev->dev, "Intel(R) I350 Virtual Function\n"); 2553 else 2554 dev_info(&pdev->dev, "Intel(R) 82576 Virtual Function\n"); 2555 dev_info(&pdev->dev, "Address: %pM\n", netdev->dev_addr); 2556} 2557 2558static int igbvf_set_features(struct net_device *netdev, 2559 netdev_features_t features) 2560{ 2561 struct igbvf_adapter *adapter = netdev_priv(netdev); 2562 2563 if (features & NETIF_F_RXCSUM) 2564 adapter->flags &= ~IGBVF_FLAG_RX_CSUM_DISABLED; 2565 else 2566 adapter->flags |= IGBVF_FLAG_RX_CSUM_DISABLED; 2567 2568 return 0; 2569} 2570 2571static const struct net_device_ops igbvf_netdev_ops = { 2572 .ndo_open = igbvf_open, 2573 .ndo_stop = igbvf_close, 2574 .ndo_start_xmit = igbvf_xmit_frame, 2575 .ndo_get_stats = igbvf_get_stats, 2576 .ndo_set_rx_mode = igbvf_set_multi, 2577 .ndo_set_mac_address = igbvf_set_mac, 2578 .ndo_change_mtu = igbvf_change_mtu, 2579 .ndo_do_ioctl = igbvf_ioctl, 2580 .ndo_tx_timeout = igbvf_tx_timeout, 2581 .ndo_vlan_rx_add_vid = igbvf_vlan_rx_add_vid, 2582 .ndo_vlan_rx_kill_vid = igbvf_vlan_rx_kill_vid, 2583#ifdef CONFIG_NET_POLL_CONTROLLER 2584 .ndo_poll_controller = igbvf_netpoll, 2585#endif 2586 .ndo_set_features = igbvf_set_features, 2587}; 2588 2589/** 2590 * igbvf_probe - Device Initialization Routine 2591 * @pdev: PCI device information struct 2592 * @ent: entry in igbvf_pci_tbl 2593 * 2594 * Returns 0 on success, negative on failure 2595 * 2596 * igbvf_probe initializes an adapter identified by a pci_dev structure. 2597 * The OS initialization, configuring of the adapter private structure, 2598 * and a hardware reset occur. 2599 **/ 2600static int __devinit igbvf_probe(struct pci_dev *pdev, 2601 const struct pci_device_id *ent) 2602{ 2603 struct net_device *netdev; 2604 struct igbvf_adapter *adapter; 2605 struct e1000_hw *hw; 2606 const struct igbvf_info *ei = igbvf_info_tbl[ent->driver_data]; 2607 2608 static int cards_found; 2609 int err, pci_using_dac; 2610 2611 err = pci_enable_device_mem(pdev); 2612 if (err) 2613 return err; 2614 2615 pci_using_dac = 0; 2616 err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)); 2617 if (!err) { 2618 err = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64)); 2619 if (!err) 2620 pci_using_dac = 1; 2621 } else { 2622 err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32)); 2623 if (err) { 2624 err = dma_set_coherent_mask(&pdev->dev, 2625 DMA_BIT_MASK(32)); 2626 if (err) { 2627 dev_err(&pdev->dev, "No usable DMA " 2628 "configuration, aborting\n"); 2629 goto err_dma; 2630 } 2631 } 2632 } 2633 2634 err = pci_request_regions(pdev, igbvf_driver_name); 2635 if (err) 2636 goto err_pci_reg; 2637 2638 pci_set_master(pdev); 2639 2640 err = -ENOMEM; 2641 netdev = alloc_etherdev(sizeof(struct igbvf_adapter)); 2642 if (!netdev) 2643 goto err_alloc_etherdev; 2644 2645 SET_NETDEV_DEV(netdev, &pdev->dev); 2646 2647 pci_set_drvdata(pdev, netdev); 2648 adapter = netdev_priv(netdev); 2649 hw = &adapter->hw; 2650 adapter->netdev = netdev; 2651 adapter->pdev = pdev; 2652 adapter->ei = ei; 2653 adapter->pba = ei->pba; 2654 adapter->flags = ei->flags; 2655 adapter->hw.back = adapter; 2656 adapter->hw.mac.type = ei->mac; 2657 adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE); 2658 2659 /* PCI config space info */ 2660 2661 hw->vendor_id = pdev->vendor; 2662 hw->device_id = pdev->device; 2663 hw->subsystem_vendor_id = pdev->subsystem_vendor; 2664 hw->subsystem_device_id = pdev->subsystem_device; 2665 hw->revision_id = pdev->revision; 2666 2667 err = -EIO; 2668 adapter->hw.hw_addr = ioremap(pci_resource_start(pdev, 0), 2669 pci_resource_len(pdev, 0)); 2670 2671 if (!adapter->hw.hw_addr) 2672 goto err_ioremap; 2673 2674 if (ei->get_variants) { 2675 err = ei->get_variants(adapter); 2676 if (err) 2677 goto err_ioremap; 2678 } 2679 2680 /* setup adapter struct */ 2681 err = igbvf_sw_init(adapter); 2682 if (err) 2683 goto err_sw_init; 2684 2685 /* construct the net_device struct */ 2686 netdev->netdev_ops = &igbvf_netdev_ops; 2687 2688 igbvf_set_ethtool_ops(netdev); 2689 netdev->watchdog_timeo = 5 * HZ; 2690 strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1); 2691 2692 adapter->bd_number = cards_found++; 2693 2694 netdev->hw_features = NETIF_F_SG | 2695 NETIF_F_IP_CSUM | 2696 NETIF_F_IPV6_CSUM | 2697 NETIF_F_TSO | 2698 NETIF_F_TSO6 | 2699 NETIF_F_RXCSUM; 2700 2701 netdev->features = netdev->hw_features | 2702 NETIF_F_HW_VLAN_TX | 2703 NETIF_F_HW_VLAN_RX | 2704 NETIF_F_HW_VLAN_FILTER; 2705 2706 if (pci_using_dac) 2707 netdev->features |= NETIF_F_HIGHDMA; 2708 2709 netdev->vlan_features |= NETIF_F_TSO; 2710 netdev->vlan_features |= NETIF_F_TSO6; 2711 netdev->vlan_features |= NETIF_F_IP_CSUM; 2712 netdev->vlan_features |= NETIF_F_IPV6_CSUM; 2713 netdev->vlan_features |= NETIF_F_SG; 2714 2715 /*reset the controller to put the device in a known good state */ 2716 err = hw->mac.ops.reset_hw(hw); 2717 if (err) { 2718 dev_info(&pdev->dev, 2719 "PF still in reset state, assigning new address." 2720 " Is the PF interface up?\n"); 2721 eth_hw_addr_random(netdev); 2722 memcpy(adapter->hw.mac.addr, netdev->dev_addr, 2723 netdev->addr_len); 2724 } else { 2725 err = hw->mac.ops.read_mac_addr(hw); 2726 if (err) { 2727 dev_err(&pdev->dev, "Error reading MAC address\n"); 2728 goto err_hw_init; 2729 } 2730 memcpy(netdev->dev_addr, adapter->hw.mac.addr, 2731 netdev->addr_len); 2732 } 2733 2734 if (!is_valid_ether_addr(netdev->dev_addr)) { 2735 dev_err(&pdev->dev, "Invalid MAC Address: %pM\n", 2736 netdev->dev_addr); 2737 err = -EIO; 2738 goto err_hw_init; 2739 } 2740 2741 memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len); 2742 2743 setup_timer(&adapter->watchdog_timer, &igbvf_watchdog, 2744 (unsigned long) adapter); 2745 2746 INIT_WORK(&adapter->reset_task, igbvf_reset_task); 2747 INIT_WORK(&adapter->watchdog_task, igbvf_watchdog_task); 2748 2749 /* ring size defaults */ 2750 adapter->rx_ring->count = 1024; 2751 adapter->tx_ring->count = 1024; 2752 2753 /* reset the hardware with the new settings */ 2754 igbvf_reset(adapter); 2755 2756 strcpy(netdev->name, "eth%d"); 2757 err = register_netdev(netdev); 2758 if (err) 2759 goto err_hw_init; 2760 2761 /* tell the stack to leave us alone until igbvf_open() is called */ 2762 netif_carrier_off(netdev); 2763 netif_stop_queue(netdev); 2764 2765 igbvf_print_device_info(adapter); 2766 2767 igbvf_initialize_last_counter_stats(adapter); 2768 2769 return 0; 2770 2771err_hw_init: 2772 kfree(adapter->tx_ring); 2773 kfree(adapter->rx_ring); 2774err_sw_init: 2775 igbvf_reset_interrupt_capability(adapter); 2776 iounmap(adapter->hw.hw_addr); 2777err_ioremap: 2778 free_netdev(netdev); 2779err_alloc_etherdev: 2780 pci_release_regions(pdev); 2781err_pci_reg: 2782err_dma: 2783 pci_disable_device(pdev); 2784 return err; 2785} 2786 2787/** 2788 * igbvf_remove - Device Removal Routine 2789 * @pdev: PCI device information struct 2790 * 2791 * igbvf_remove is called by the PCI subsystem to alert the driver 2792 * that it should release a PCI device. The could be caused by a 2793 * Hot-Plug event, or because the driver is going to be removed from 2794 * memory. 2795 **/ 2796static void __devexit igbvf_remove(struct pci_dev *pdev) 2797{ 2798 struct net_device *netdev = pci_get_drvdata(pdev); 2799 struct igbvf_adapter *adapter = netdev_priv(netdev); 2800 struct e1000_hw *hw = &adapter->hw; 2801 2802 /* 2803 * The watchdog timer may be rescheduled, so explicitly 2804 * disable it from being rescheduled. 2805 */ 2806 set_bit(__IGBVF_DOWN, &adapter->state); 2807 del_timer_sync(&adapter->watchdog_timer); 2808 2809 cancel_work_sync(&adapter->reset_task); 2810 cancel_work_sync(&adapter->watchdog_task); 2811 2812 unregister_netdev(netdev); 2813 2814 igbvf_reset_interrupt_capability(adapter); 2815 2816 /* 2817 * it is important to delete the napi struct prior to freeing the 2818 * rx ring so that you do not end up with null pointer refs 2819 */ 2820 netif_napi_del(&adapter->rx_ring->napi); 2821 kfree(adapter->tx_ring); 2822 kfree(adapter->rx_ring); 2823 2824 iounmap(hw->hw_addr); 2825 if (hw->flash_address) 2826 iounmap(hw->flash_address); 2827 pci_release_regions(pdev); 2828 2829 free_netdev(netdev); 2830 2831 pci_disable_device(pdev); 2832} 2833 2834/* PCI Error Recovery (ERS) */ 2835static struct pci_error_handlers igbvf_err_handler = { 2836 .error_detected = igbvf_io_error_detected, 2837 .slot_reset = igbvf_io_slot_reset, 2838 .resume = igbvf_io_resume, 2839}; 2840 2841static DEFINE_PCI_DEVICE_TABLE(igbvf_pci_tbl) = { 2842 { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_VF), board_vf }, 2843 { PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_VF), board_i350_vf }, 2844 { } /* terminate list */ 2845}; 2846MODULE_DEVICE_TABLE(pci, igbvf_pci_tbl); 2847 2848/* PCI Device API Driver */ 2849static struct pci_driver igbvf_driver = { 2850 .name = igbvf_driver_name, 2851 .id_table = igbvf_pci_tbl, 2852 .probe = igbvf_probe, 2853 .remove = __devexit_p(igbvf_remove), 2854#ifdef CONFIG_PM 2855 /* Power Management Hooks */ 2856 .suspend = igbvf_suspend, 2857 .resume = igbvf_resume, 2858#endif 2859 .shutdown = igbvf_shutdown, 2860 .err_handler = &igbvf_err_handler 2861}; 2862 2863/** 2864 * igbvf_init_module - Driver Registration Routine 2865 * 2866 * igbvf_init_module is the first routine called when the driver is 2867 * loaded. All it does is register with the PCI subsystem. 2868 **/ 2869static int __init igbvf_init_module(void) 2870{ 2871 int ret; 2872 pr_info("%s - version %s\n", igbvf_driver_string, igbvf_driver_version); 2873 pr_info("%s\n", igbvf_copyright); 2874 2875 ret = pci_register_driver(&igbvf_driver); 2876 2877 return ret; 2878} 2879module_init(igbvf_init_module); 2880 2881/** 2882 * igbvf_exit_module - Driver Exit Cleanup Routine 2883 * 2884 * igbvf_exit_module is called just before the driver is removed 2885 * from memory. 2886 **/ 2887static void __exit igbvf_exit_module(void) 2888{ 2889 pci_unregister_driver(&igbvf_driver); 2890} 2891module_exit(igbvf_exit_module); 2892 2893 2894MODULE_AUTHOR("Intel Corporation, <e1000-devel@lists.sourceforge.net>"); 2895MODULE_DESCRIPTION("Intel(R) Gigabit Virtual Function Network Driver"); 2896MODULE_LICENSE("GPL"); 2897MODULE_VERSION(DRV_VERSION); 2898 2899/* netdev.c */ 2900