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