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