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