]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blame - drivers/net/enic/enic_main.c
projects / mirror_ubuntu-focal-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
enic: Use a lighter reset operation for enic devices
[mirror_ubuntu-focal-kernel.git] / drivers / net / enic / enic_main.c
CommitLineData
01f2e4ea
SF		 1/*
2 * Copyright 2008 Cisco Systems, Inc. All rights reserved.
3 * Copyright 2007 Nuova Systems, Inc. All rights reserved.
4 *
5 * This program is free software; you may redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; version 2 of the License.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
10 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
11 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
12 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
13 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
14 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
15 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
16 * SOFTWARE.
17 *
18 */
19
20#include <linux/module.h>
21#include <linux/kernel.h>
22#include <linux/string.h>
23#include <linux/errno.h>
24#include <linux/types.h>
25#include <linux/init.h>
26#include <linux/workqueue.h>
27#include <linux/pci.h>
28#include <linux/netdevice.h>
29#include <linux/etherdevice.h>
30#include <linux/if_ether.h>
31#include <linux/if_vlan.h>
f8bd9091 32#include <linux/if_link.h>
01f2e4ea
SF		 33#include <linux/ethtool.h>
34#include <linux/in.h>
35#include <linux/ip.h>
36#include <linux/ipv6.h>
37#include <linux/tcp.h>
b7c6bfb7 38#include <net/ip6_checksum.h>
01f2e4ea
SF		 39
40#include "cq_enet_desc.h"
41#include "vnic_dev.h"
42#include "vnic_intr.h"
43#include "vnic_stats.h"
f8bd9091 44#include "vnic_vic.h"
01f2e4ea
SF		 45#include "enic_res.h"
46#include "enic.h"
47
48#define ENIC_NOTIFY_TIMER_PERIOD (2 * HZ)
ea0d7d91
SF		 49#define WQ_ENET_MAX_DESC_LEN (1 << WQ_ENET_LEN_BITS)
50#define MAX_TSO (1 << 16)
51#define ENIC_DESC_MAX_SPLITS (MAX_TSO / WQ_ENET_MAX_DESC_LEN + 1)
52
53#define PCI_DEVICE_ID_CISCO_VIC_ENET 0x0043 /* ethernet vnic */
f8bd9091 54#define PCI_DEVICE_ID_CISCO_VIC_ENET_DYN 0x0044 /* enet dynamic vnic */
01f2e4ea
SF		 55
56/* Supported devices */
a3aa1884 57static DEFINE_PCI_DEVICE_TABLE(enic_id_table) = {
ea0d7d91 58 { PCI_VDEVICE(CISCO, PCI_DEVICE_ID_CISCO_VIC_ENET) },
f8bd9091 59 { PCI_VDEVICE(CISCO, PCI_DEVICE_ID_CISCO_VIC_ENET_DYN) },
01f2e4ea
SF		 60 { 0, } /* end of table */
61};
62
63MODULE_DESCRIPTION(DRV_DESCRIPTION);
64MODULE_AUTHOR("Scott Feldman <scofeldm@cisco.com>");
65MODULE_LICENSE("GPL");
66MODULE_VERSION(DRV_VERSION);
67MODULE_DEVICE_TABLE(pci, enic_id_table);
68
69struct enic_stat {
70 char name[ETH_GSTRING_LEN];
71 unsigned int offset;
72};
73
74#define ENIC_TX_STAT(stat) \
75 { .name = #stat, .offset = offsetof(struct vnic_tx_stats, stat) / 8 }
76#define ENIC_RX_STAT(stat) \
77 { .name = #stat, .offset = offsetof(struct vnic_rx_stats, stat) / 8 }
78
79static const struct enic_stat enic_tx_stats[] = {
80 ENIC_TX_STAT(tx_frames_ok),
81 ENIC_TX_STAT(tx_unicast_frames_ok),
82 ENIC_TX_STAT(tx_multicast_frames_ok),
83 ENIC_TX_STAT(tx_broadcast_frames_ok),
84 ENIC_TX_STAT(tx_bytes_ok),
85 ENIC_TX_STAT(tx_unicast_bytes_ok),
86 ENIC_TX_STAT(tx_multicast_bytes_ok),
87 ENIC_TX_STAT(tx_broadcast_bytes_ok),
88 ENIC_TX_STAT(tx_drops),
89 ENIC_TX_STAT(tx_errors),
90 ENIC_TX_STAT(tx_tso),
91};
92
93static const struct enic_stat enic_rx_stats[] = {
94 ENIC_RX_STAT(rx_frames_ok),
95 ENIC_RX_STAT(rx_frames_total),
96 ENIC_RX_STAT(rx_unicast_frames_ok),
97 ENIC_RX_STAT(rx_multicast_frames_ok),
98 ENIC_RX_STAT(rx_broadcast_frames_ok),
99 ENIC_RX_STAT(rx_bytes_ok),
100 ENIC_RX_STAT(rx_unicast_bytes_ok),
101 ENIC_RX_STAT(rx_multicast_bytes_ok),
102 ENIC_RX_STAT(rx_broadcast_bytes_ok),
103 ENIC_RX_STAT(rx_drop),
104 ENIC_RX_STAT(rx_no_bufs),
105 ENIC_RX_STAT(rx_errors),
106 ENIC_RX_STAT(rx_rss),
107 ENIC_RX_STAT(rx_crc_errors),
108 ENIC_RX_STAT(rx_frames_64),
109 ENIC_RX_STAT(rx_frames_127),
110 ENIC_RX_STAT(rx_frames_255),
111 ENIC_RX_STAT(rx_frames_511),
112 ENIC_RX_STAT(rx_frames_1023),
113 ENIC_RX_STAT(rx_frames_1518),
114 ENIC_RX_STAT(rx_frames_to_max),
115};
116
117static const unsigned int enic_n_tx_stats = ARRAY_SIZE(enic_tx_stats);
118static const unsigned int enic_n_rx_stats = ARRAY_SIZE(enic_rx_stats);
119
f8bd9091
SF		 120static int enic_is_dynamic(struct enic *enic)
121{
122 return enic->pdev->device == PCI_DEVICE_ID_CISCO_VIC_ENET_DYN;
123}
124
01f2e4ea
SF		 125static int enic_get_settings(struct net_device *netdev,
126 struct ethtool_cmd *ecmd)
127{
128 struct enic *enic = netdev_priv(netdev);
129
130 ecmd->supported = (SUPPORTED_10000baseT_Full | SUPPORTED_FIBRE);
131 ecmd->advertising = (ADVERTISED_10000baseT_Full | ADVERTISED_FIBRE);
132 ecmd->port = PORT_FIBRE;
133 ecmd->transceiver = XCVR_EXTERNAL;
134
135 if (netif_carrier_ok(netdev)) {
136 ecmd->speed = vnic_dev_port_speed(enic->vdev);
137 ecmd->duplex = DUPLEX_FULL;
138 } else {
139 ecmd->speed = -1;
140 ecmd->duplex = -1;
141 }
142
143 ecmd->autoneg = AUTONEG_DISABLE;
144
145 return 0;
146}
147
148static void enic_get_drvinfo(struct net_device *netdev,
149 struct ethtool_drvinfo *drvinfo)
150{
151 struct enic *enic = netdev_priv(netdev);
152 struct vnic_devcmd_fw_info *fw_info;
153
154 spin_lock(&enic->devcmd_lock);
155 vnic_dev_fw_info(enic->vdev, &fw_info);
156 spin_unlock(&enic->devcmd_lock);
157
158 strncpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
159 strncpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
160 strncpy(drvinfo->fw_version, fw_info->fw_version,
161 sizeof(drvinfo->fw_version));
162 strncpy(drvinfo->bus_info, pci_name(enic->pdev),
163 sizeof(drvinfo->bus_info));
164}
165
166static void enic_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
167{
168 unsigned int i;
169
170 switch (stringset) {
171 case ETH_SS_STATS:
172 for (i = 0; i < enic_n_tx_stats; i++) {
173 memcpy(data, enic_tx_stats[i].name, ETH_GSTRING_LEN);
174 data += ETH_GSTRING_LEN;
175 }
176 for (i = 0; i < enic_n_rx_stats; i++) {
177 memcpy(data, enic_rx_stats[i].name, ETH_GSTRING_LEN);
178 data += ETH_GSTRING_LEN;
179 }
180 break;
181 }
182}
183
25f0a061 184static int enic_get_sset_count(struct net_device *netdev, int sset)
01f2e4ea 185{
25f0a061
SF		 186 switch (sset) {
187 case ETH_SS_STATS:
188 return enic_n_tx_stats + enic_n_rx_stats;
189 default:
190 return -EOPNOTSUPP;
191 }
01f2e4ea
SF		 192}
193
194static void enic_get_ethtool_stats(struct net_device *netdev,
195 struct ethtool_stats *stats, u64 *data)
196{
197 struct enic *enic = netdev_priv(netdev);
198 struct vnic_stats *vstats;
199 unsigned int i;
200
201 spin_lock(&enic->devcmd_lock);
202 vnic_dev_stats_dump(enic->vdev, &vstats);
203 spin_unlock(&enic->devcmd_lock);
204
205 for (i = 0; i < enic_n_tx_stats; i++)
206 *(data++) = ((u64 *)&vstats->tx)[enic_tx_stats[i].offset];
207 for (i = 0; i < enic_n_rx_stats; i++)
208 *(data++) = ((u64 *)&vstats->rx)[enic_rx_stats[i].offset];
209}
210
211static u32 enic_get_rx_csum(struct net_device *netdev)
212{
213 struct enic *enic = netdev_priv(netdev);
214 return enic->csum_rx_enabled;
215}
216
217static int enic_set_rx_csum(struct net_device *netdev, u32 data)
218{
219 struct enic *enic = netdev_priv(netdev);
220
25f0a061
SF		 221 if (data && !ENIC_SETTING(enic, RXCSUM))
222 return -EINVAL;
223
224 enic->csum_rx_enabled = !!data;
01f2e4ea
SF		 225
226 return 0;
227}
228
229static int enic_set_tx_csum(struct net_device *netdev, u32 data)
230{
231 struct enic *enic = netdev_priv(netdev);
232
25f0a061
SF		 233 if (data && !ENIC_SETTING(enic, TXCSUM))
234 return -EINVAL;
235
236 if (data)
01f2e4ea
SF		 237 netdev->features |= NETIF_F_HW_CSUM;
238 else
239 netdev->features &= ~NETIF_F_HW_CSUM;
240
241 return 0;
242}
243
244static int enic_set_tso(struct net_device *netdev, u32 data)
245{
246 struct enic *enic = netdev_priv(netdev);
247
25f0a061
SF		 248 if (data && !ENIC_SETTING(enic, TSO))
249 return -EINVAL;
250
251 if (data)
01f2e4ea
SF		 252 netdev->features |=
253 NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN;
254 else
255 netdev->features &=
256 ~(NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN);
257
258 return 0;
259}
260
261static u32 enic_get_msglevel(struct net_device *netdev)
262{
263 struct enic *enic = netdev_priv(netdev);
264 return enic->msg_enable;
265}
266
267static void enic_set_msglevel(struct net_device *netdev, u32 value)
268{
269 struct enic *enic = netdev_priv(netdev);
270 enic->msg_enable = value;
271}
272
7c844599
SF		 273static int enic_get_coalesce(struct net_device *netdev,
274 struct ethtool_coalesce *ecmd)
275{
276 struct enic *enic = netdev_priv(netdev);
277
278 ecmd->tx_coalesce_usecs = enic->tx_coalesce_usecs;
279 ecmd->rx_coalesce_usecs = enic->rx_coalesce_usecs;
280
281 return 0;
282}
283
284static int enic_set_coalesce(struct net_device *netdev,
285 struct ethtool_coalesce *ecmd)
286{
287 struct enic *enic = netdev_priv(netdev);
288 u32 tx_coalesce_usecs;
289 u32 rx_coalesce_usecs;
290
291 tx_coalesce_usecs = min_t(u32,
292 INTR_COALESCE_HW_TO_USEC(VNIC_INTR_TIMER_MAX),
293 ecmd->tx_coalesce_usecs);
294 rx_coalesce_usecs = min_t(u32,
295 INTR_COALESCE_HW_TO_USEC(VNIC_INTR_TIMER_MAX),
296 ecmd->rx_coalesce_usecs);
297
298 switch (vnic_dev_get_intr_mode(enic->vdev)) {
299 case VNIC_DEV_INTR_MODE_INTX:
300 if (tx_coalesce_usecs != rx_coalesce_usecs)
301 return -EINVAL;
302
303 vnic_intr_coalescing_timer_set(&enic->intr[ENIC_INTX_WQ_RQ],
304 INTR_COALESCE_USEC_TO_HW(tx_coalesce_usecs));
305 break;
306 case VNIC_DEV_INTR_MODE_MSI:
307 if (tx_coalesce_usecs != rx_coalesce_usecs)
308 return -EINVAL;
309
310 vnic_intr_coalescing_timer_set(&enic->intr[0],
311 INTR_COALESCE_USEC_TO_HW(tx_coalesce_usecs));
312 break;
313 case VNIC_DEV_INTR_MODE_MSIX:
314 vnic_intr_coalescing_timer_set(&enic->intr[ENIC_MSIX_WQ],
315 INTR_COALESCE_USEC_TO_HW(tx_coalesce_usecs));
316 vnic_intr_coalescing_timer_set(&enic->intr[ENIC_MSIX_RQ],
317 INTR_COALESCE_USEC_TO_HW(rx_coalesce_usecs));
318 break;
319 default:
320 break;
321 }
322
323 enic->tx_coalesce_usecs = tx_coalesce_usecs;
324 enic->rx_coalesce_usecs = rx_coalesce_usecs;
325
326 return 0;
327}
328
0fc0b732 329static const struct ethtool_ops enic_ethtool_ops = {
01f2e4ea
SF		 330 .get_settings = enic_get_settings,
331 .get_drvinfo = enic_get_drvinfo,
332 .get_msglevel = enic_get_msglevel,
333 .set_msglevel = enic_set_msglevel,
334 .get_link = ethtool_op_get_link,
335 .get_strings = enic_get_strings,
25f0a061 336 .get_sset_count = enic_get_sset_count,
01f2e4ea
SF		 337 .get_ethtool_stats = enic_get_ethtool_stats,
338 .get_rx_csum = enic_get_rx_csum,
339 .set_rx_csum = enic_set_rx_csum,
340 .get_tx_csum = ethtool_op_get_tx_csum,
341 .set_tx_csum = enic_set_tx_csum,
342 .get_sg = ethtool_op_get_sg,
343 .set_sg = ethtool_op_set_sg,
344 .get_tso = ethtool_op_get_tso,
345 .set_tso = enic_set_tso,
7c844599
SF		 346 .get_coalesce = enic_get_coalesce,
347 .set_coalesce = enic_set_coalesce,
86ca9db7
SF		 348 .get_flags = ethtool_op_get_flags,
349 .set_flags = ethtool_op_set_flags,
01f2e4ea
SF		 350};
351
352static void enic_free_wq_buf(struct vnic_wq *wq, struct vnic_wq_buf *buf)
353{
354 struct enic *enic = vnic_dev_priv(wq->vdev);
355
356 if (buf->sop)
357 pci_unmap_single(enic->pdev, buf->dma_addr,
358 buf->len, PCI_DMA_TODEVICE);
359 else
360 pci_unmap_page(enic->pdev, buf->dma_addr,
361 buf->len, PCI_DMA_TODEVICE);
362
363 if (buf->os_buf)
364 dev_kfree_skb_any(buf->os_buf);
365}
366
367static void enic_wq_free_buf(struct vnic_wq *wq,
368 struct cq_desc *cq_desc, struct vnic_wq_buf *buf, void *opaque)
369{
370 enic_free_wq_buf(wq, buf);
371}
372
373static int enic_wq_service(struct vnic_dev *vdev, struct cq_desc *cq_desc,
374 u8 type, u16 q_number, u16 completed_index, void *opaque)
375{
376 struct enic *enic = vnic_dev_priv(vdev);
377
378 spin_lock(&enic->wq_lock[q_number]);
379
380 vnic_wq_service(&enic->wq[q_number], cq_desc,
381 completed_index, enic_wq_free_buf,
382 opaque);
383
384 if (netif_queue_stopped(enic->netdev) &&
ea0d7d91
SF		 385 vnic_wq_desc_avail(&enic->wq[q_number]) >=
386 (MAX_SKB_FRAGS + ENIC_DESC_MAX_SPLITS))
01f2e4ea
SF		 387 netif_wake_queue(enic->netdev);
388
389 spin_unlock(&enic->wq_lock[q_number]);
390
391 return 0;
392}
393
394static void enic_log_q_error(struct enic *enic)
395{
396 unsigned int i;
397 u32 error_status;
398
399 for (i = 0; i < enic->wq_count; i++) {
400 error_status = vnic_wq_error_status(&enic->wq[i]);
401 if (error_status)
402 printk(KERN_ERR PFX "%s: WQ[%d] error_status %d\n",
403 enic->netdev->name, i, error_status);
404 }
405
406 for (i = 0; i < enic->rq_count; i++) {
407 error_status = vnic_rq_error_status(&enic->rq[i]);
408 if (error_status)
409 printk(KERN_ERR PFX "%s: RQ[%d] error_status %d\n",
410 enic->netdev->name, i, error_status);
411 }
412}
413
414static void enic_link_check(struct enic *enic)
415{
416 int link_status = vnic_dev_link_status(enic->vdev);
417 int carrier_ok = netif_carrier_ok(enic->netdev);
418
419 if (link_status && !carrier_ok) {
420 printk(KERN_INFO PFX "%s: Link UP\n", enic->netdev->name);
421 netif_carrier_on(enic->netdev);
422 } else if (!link_status && carrier_ok) {
423 printk(KERN_INFO PFX "%s: Link DOWN\n", enic->netdev->name);
424 netif_carrier_off(enic->netdev);
425 }
426}
427
428static void enic_mtu_check(struct enic *enic)
429{
430 u32 mtu = vnic_dev_mtu(enic->vdev);
431
491598a4 432 if (mtu && mtu != enic->port_mtu) {
7c844599 433 enic->port_mtu = mtu;
01f2e4ea
SF		 434 if (mtu < enic->netdev->mtu)
435 printk(KERN_WARNING PFX
436 "%s: interface MTU (%d) set higher "
437 "than switch port MTU (%d)\n",
438 enic->netdev->name, enic->netdev->mtu, mtu);
01f2e4ea
SF		 439 }
440}
441
442static void enic_msglvl_check(struct enic *enic)
443{
444 u32 msg_enable = vnic_dev_msg_lvl(enic->vdev);
445
446 if (msg_enable != enic->msg_enable) {
447 printk(KERN_INFO PFX "%s: msg lvl changed from 0x%x to 0x%x\n",
448 enic->netdev->name, enic->msg_enable, msg_enable);
449 enic->msg_enable = msg_enable;
450 }
451}
452
453static void enic_notify_check(struct enic *enic)
454{
455 enic_msglvl_check(enic);
456 enic_mtu_check(enic);
457 enic_link_check(enic);
458}
459
460#define ENIC_TEST_INTR(pba, i) (pba & (1 << i))
461
462static irqreturn_t enic_isr_legacy(int irq, void *data)
463{
464 struct net_device *netdev = data;
465 struct enic *enic = netdev_priv(netdev);
466 u32 pba;
467
468 vnic_intr_mask(&enic->intr[ENIC_INTX_WQ_RQ]);
469
470 pba = vnic_intr_legacy_pba(enic->legacy_pba);
471 if (!pba) {
472 vnic_intr_unmask(&enic->intr[ENIC_INTX_WQ_RQ]);
473 return IRQ_NONE; /* not our interrupt */
474 }
475
ed8af6b2
SF		 476 if (ENIC_TEST_INTR(pba, ENIC_INTX_NOTIFY)) {
477 vnic_intr_return_all_credits(&enic->intr[ENIC_INTX_NOTIFY]);
01f2e4ea 478 enic_notify_check(enic);
ed8af6b2 479 }
01f2e4ea
SF		 480
481 if (ENIC_TEST_INTR(pba, ENIC_INTX_ERR)) {
ed8af6b2 482 vnic_intr_return_all_credits(&enic->intr[ENIC_INTX_ERR]);
01f2e4ea
SF		 483 enic_log_q_error(enic);
484 /* schedule recovery from WQ/RQ error */
485 schedule_work(&enic->reset);
486 return IRQ_HANDLED;
487 }
488
489 if (ENIC_TEST_INTR(pba, ENIC_INTX_WQ_RQ)) {
288379f0
BH		 490 if (napi_schedule_prep(&enic->napi))
491 __napi_schedule(&enic->napi);
01f2e4ea
SF		 492 } else {
493 vnic_intr_unmask(&enic->intr[ENIC_INTX_WQ_RQ]);
494 }
495
496 return IRQ_HANDLED;
497}
498
499static irqreturn_t enic_isr_msi(int irq, void *data)
500{
501 struct enic *enic = data;
502
503 /* With MSI, there is no sharing of interrupts, so this is
504 * our interrupt and there is no need to ack it. The device
505 * is not providing per-vector masking, so the OS will not
506 * write to PCI config space to mask/unmask the interrupt.
507 * We're using mask_on_assertion for MSI, so the device
508 * automatically masks the interrupt when the interrupt is
509 * generated. Later, when exiting polling, the interrupt
510 * will be unmasked (see enic_poll).
511 *
512 * Also, the device uses the same PCIe Traffic Class (TC)
513 * for Memory Write data and MSI, so there are no ordering
514 * issues; the MSI will always arrive at the Root Complex
515 * _after_ corresponding Memory Writes (i.e. descriptor
516 * writes).
517 */
518
288379f0 519 napi_schedule(&enic->napi);
01f2e4ea
SF		 520
521 return IRQ_HANDLED;
522}
523
524static irqreturn_t enic_isr_msix_rq(int irq, void *data)
525{
526 struct enic *enic = data;
527
528 /* schedule NAPI polling for RQ cleanup */
288379f0 529 napi_schedule(&enic->napi);
01f2e4ea
SF		 530
531 return IRQ_HANDLED;
532}
533
534static irqreturn_t enic_isr_msix_wq(int irq, void *data)
535{
536 struct enic *enic = data;
537 unsigned int wq_work_to_do = -1; /* no limit */
538 unsigned int wq_work_done;
539
540 wq_work_done = vnic_cq_service(&enic->cq[ENIC_CQ_WQ],
541 wq_work_to_do, enic_wq_service, NULL);
542
543 vnic_intr_return_credits(&enic->intr[ENIC_MSIX_WQ],
544 wq_work_done,
545 1 /* unmask intr */,
546 1 /* reset intr timer */);
547
548 return IRQ_HANDLED;
549}
550
551static irqreturn_t enic_isr_msix_err(int irq, void *data)
552{
553 struct enic *enic = data;
554
ed8af6b2
SF		 555 vnic_intr_return_all_credits(&enic->intr[ENIC_MSIX_ERR]);
556
01f2e4ea
SF		 557 enic_log_q_error(enic);
558
559 /* schedule recovery from WQ/RQ error */
560 schedule_work(&enic->reset);
561
562 return IRQ_HANDLED;
563}
564
565static irqreturn_t enic_isr_msix_notify(int irq, void *data)
566{
567 struct enic *enic = data;
568
ed8af6b2 569 vnic_intr_return_all_credits(&enic->intr[ENIC_MSIX_NOTIFY]);
01f2e4ea 570 enic_notify_check(enic);
01f2e4ea
SF		 571
572 return IRQ_HANDLED;
573}
574
575static inline void enic_queue_wq_skb_cont(struct enic *enic,
576 struct vnic_wq *wq, struct sk_buff *skb,
577 unsigned int len_left)
578{
579 skb_frag_t *frag;
580
581 /* Queue additional data fragments */
582 for (frag = skb_shinfo(skb)->frags; len_left; frag++) {
583 len_left -= frag->size;
584 enic_queue_wq_desc_cont(wq, skb,
585 pci_map_page(enic->pdev, frag->page,
586 frag->page_offset, frag->size,
587 PCI_DMA_TODEVICE),
588 frag->size,
589 (len_left == 0)); /* EOP? */
590 }
591}
592
593static inline void enic_queue_wq_skb_vlan(struct enic *enic,
594 struct vnic_wq *wq, struct sk_buff *skb,
595 int vlan_tag_insert, unsigned int vlan_tag)
596{
597 unsigned int head_len = skb_headlen(skb);
598 unsigned int len_left = skb->len - head_len;
599 int eop = (len_left == 0);
600
ea0d7d91
SF		 601 /* Queue the main skb fragment. The fragments are no larger
602 * than max MTU(9000)+ETH_HDR_LEN(14) bytes, which is less
603 * than WQ_ENET_MAX_DESC_LEN length. So only one descriptor
604 * per fragment is queued.
605 */
01f2e4ea
SF		 606 enic_queue_wq_desc(wq, skb,
607 pci_map_single(enic->pdev, skb->data,
608 head_len, PCI_DMA_TODEVICE),
609 head_len,
610 vlan_tag_insert, vlan_tag,
611 eop);
612
613 if (!eop)
614 enic_queue_wq_skb_cont(enic, wq, skb, len_left);
615}
616
617static inline void enic_queue_wq_skb_csum_l4(struct enic *enic,
618 struct vnic_wq *wq, struct sk_buff *skb,
619 int vlan_tag_insert, unsigned int vlan_tag)
620{
621 unsigned int head_len = skb_headlen(skb);
622 unsigned int len_left = skb->len - head_len;
623 unsigned int hdr_len = skb_transport_offset(skb);
624 unsigned int csum_offset = hdr_len + skb->csum_offset;
625 int eop = (len_left == 0);
626
ea0d7d91
SF		 627 /* Queue the main skb fragment. The fragments are no larger
628 * than max MTU(9000)+ETH_HDR_LEN(14) bytes, which is less
629 * than WQ_ENET_MAX_DESC_LEN length. So only one descriptor
630 * per fragment is queued.
631 */
01f2e4ea
SF		 632 enic_queue_wq_desc_csum_l4(wq, skb,
633 pci_map_single(enic->pdev, skb->data,
634 head_len, PCI_DMA_TODEVICE),
635 head_len,
636 csum_offset,
637 hdr_len,
638 vlan_tag_insert, vlan_tag,
639 eop);
640
641 if (!eop)
642 enic_queue_wq_skb_cont(enic, wq, skb, len_left);
643}
644
645static inline void enic_queue_wq_skb_tso(struct enic *enic,
646 struct vnic_wq *wq, struct sk_buff *skb, unsigned int mss,
647 int vlan_tag_insert, unsigned int vlan_tag)
648{
ea0d7d91
SF		 649 unsigned int frag_len_left = skb_headlen(skb);
650 unsigned int len_left = skb->len - frag_len_left;
01f2e4ea
SF		 651 unsigned int hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
652 int eop = (len_left == 0);
ea0d7d91
SF		 653 unsigned int len;
654 dma_addr_t dma_addr;
655 unsigned int offset = 0;
656 skb_frag_t *frag;
01f2e4ea
SF		 657
658 /* Preload TCP csum field with IP pseudo hdr calculated
659 * with IP length set to zero. HW will later add in length
660 * to each TCP segment resulting from the TSO.
661 */
662
09640e63 663 if (skb->protocol == cpu_to_be16(ETH_P_IP)) {
01f2e4ea
SF		 664 ip_hdr(skb)->check = 0;
665 tcp_hdr(skb)->check = ~csum_tcpudp_magic(ip_hdr(skb)->saddr,
666 ip_hdr(skb)->daddr, 0, IPPROTO_TCP, 0);
09640e63 667 } else if (skb->protocol == cpu_to_be16(ETH_P_IPV6)) {
01f2e4ea
SF		 668 tcp_hdr(skb)->check = ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
669 &ipv6_hdr(skb)->daddr, 0, IPPROTO_TCP, 0);
670 }
671
ea0d7d91
SF		 672 /* Queue WQ_ENET_MAX_DESC_LEN length descriptors
673 * for the main skb fragment
674 */
675 while (frag_len_left) {
676 len = min(frag_len_left, (unsigned int)WQ_ENET_MAX_DESC_LEN);
677 dma_addr = pci_map_single(enic->pdev, skb->data + offset,
678 len, PCI_DMA_TODEVICE);
679 enic_queue_wq_desc_tso(wq, skb,
680 dma_addr,
681 len,
682 mss, hdr_len,
683 vlan_tag_insert, vlan_tag,
684 eop && (len == frag_len_left));
685 frag_len_left -= len;
686 offset += len;
687 }
01f2e4ea 688
ea0d7d91
SF		 689 if (eop)
690 return;
691
692 /* Queue WQ_ENET_MAX_DESC_LEN length descriptors
693 * for additional data fragments
694 */
695 for (frag = skb_shinfo(skb)->frags; len_left; frag++) {
696 len_left -= frag->size;
697 frag_len_left = frag->size;
698 offset = frag->page_offset;
699
700 while (frag_len_left) {
701 len = min(frag_len_left,
702 (unsigned int)WQ_ENET_MAX_DESC_LEN);
703 dma_addr = pci_map_page(enic->pdev, frag->page,
704 offset, len,
705 PCI_DMA_TODEVICE);
706 enic_queue_wq_desc_cont(wq, skb,
707 dma_addr,
708 len,
709 (len_left == 0) &&
710 (len == frag_len_left)); /* EOP? */
711 frag_len_left -= len;
712 offset += len;
713 }
714 }
01f2e4ea
SF		 715}
716
717static inline void enic_queue_wq_skb(struct enic *enic,
718 struct vnic_wq *wq, struct sk_buff *skb)
719{
720 unsigned int mss = skb_shinfo(skb)->gso_size;
721 unsigned int vlan_tag = 0;
722 int vlan_tag_insert = 0;
723
724 if (enic->vlan_group && vlan_tx_tag_present(skb)) {
725 /* VLAN tag from trunking driver */
726 vlan_tag_insert = 1;
727 vlan_tag = vlan_tx_tag_get(skb);
728 }
729
730 if (mss)
731 enic_queue_wq_skb_tso(enic, wq, skb, mss,
732 vlan_tag_insert, vlan_tag);
733 else if (skb->ip_summed == CHECKSUM_PARTIAL)
734 enic_queue_wq_skb_csum_l4(enic, wq, skb,
735 vlan_tag_insert, vlan_tag);
736 else
737 enic_queue_wq_skb_vlan(enic, wq, skb,
738 vlan_tag_insert, vlan_tag);
739}
740
ed8af6b2 741/* netif_tx_lock held, process context with BHs disabled, or BH */
61357325 742static netdev_tx_t enic_hard_start_xmit(struct sk_buff *skb,
d87fd25d 743 struct net_device *netdev)
01f2e4ea
SF		 744{
745 struct enic *enic = netdev_priv(netdev);
746 struct vnic_wq *wq = &enic->wq[0];
747 unsigned long flags;
748
749 if (skb->len <= 0) {
750 dev_kfree_skb(skb);
751 return NETDEV_TX_OK;
752 }
753
754 /* Non-TSO sends must fit within ENIC_NON_TSO_MAX_DESC descs,
755 * which is very likely. In the off chance it's going to take
756 * more than * ENIC_NON_TSO_MAX_DESC, linearize the skb.
757 */
758
759 if (skb_shinfo(skb)->gso_size == 0 &&
760 skb_shinfo(skb)->nr_frags + 1 > ENIC_NON_TSO_MAX_DESC &&
761 skb_linearize(skb)) {
762 dev_kfree_skb(skb);
763 return NETDEV_TX_OK;
764 }
765
766 spin_lock_irqsave(&enic->wq_lock[0], flags);
767
ea0d7d91
SF		 768 if (vnic_wq_desc_avail(wq) <
769 skb_shinfo(skb)->nr_frags + ENIC_DESC_MAX_SPLITS) {
01f2e4ea
SF		 770 netif_stop_queue(netdev);
771 /* This is a hard error, log it */
772 printk(KERN_ERR PFX "%s: BUG! Tx ring full when "
773 "queue awake!\n", netdev->name);
774 spin_unlock_irqrestore(&enic->wq_lock[0], flags);
775 return NETDEV_TX_BUSY;
776 }
777
778 enic_queue_wq_skb(enic, wq, skb);
779
ea0d7d91 780 if (vnic_wq_desc_avail(wq) < MAX_SKB_FRAGS + ENIC_DESC_MAX_SPLITS)
01f2e4ea
SF		 781 netif_stop_queue(netdev);
782
01f2e4ea
SF		 783 spin_unlock_irqrestore(&enic->wq_lock[0], flags);
784
785 return NETDEV_TX_OK;
786}
787
788/* dev_base_lock rwlock held, nominally process context */
789static struct net_device_stats *enic_get_stats(struct net_device *netdev)
790{
791 struct enic *enic = netdev_priv(netdev);
25f0a061 792 struct net_device_stats *net_stats = &netdev->stats;
01f2e4ea
SF		 793 struct vnic_stats *stats;
794
795 spin_lock(&enic->devcmd_lock);
796 vnic_dev_stats_dump(enic->vdev, &stats);
797 spin_unlock(&enic->devcmd_lock);
798
25f0a061
SF		 799 net_stats->tx_packets = stats->tx.tx_frames_ok;
800 net_stats->tx_bytes = stats->tx.tx_bytes_ok;
801 net_stats->tx_errors = stats->tx.tx_errors;
802 net_stats->tx_dropped = stats->tx.tx_drops;
01f2e4ea 803
25f0a061
SF		 804 net_stats->rx_packets = stats->rx.rx_frames_ok;
805 net_stats->rx_bytes = stats->rx.rx_bytes_ok;
806 net_stats->rx_errors = stats->rx.rx_errors;
807 net_stats->multicast = stats->rx.rx_multicast_frames_ok;
350991e1 808 net_stats->rx_over_errors = enic->rq_truncated_pkts;
bd9fb1a4 809 net_stats->rx_crc_errors = enic->rq_bad_fcs;
350991e1 810 net_stats->rx_dropped = stats->rx.rx_no_bufs + stats->rx.rx_drop;
01f2e4ea 811
25f0a061 812 return net_stats;
01f2e4ea
SF		 813}
814
99ef5639 815static void enic_reset_multicast_list(struct enic *enic)
01f2e4ea
SF		 816{
817 enic->mc_count = 0;
99ef5639 818 enic->flags = 0;
01f2e4ea
SF		 819}
820
821static int enic_set_mac_addr(struct net_device *netdev, char *addr)
822{
f8bd9091
SF		 823 struct enic *enic = netdev_priv(netdev);
824
825 if (enic_is_dynamic(enic)) {
826 if (!is_valid_ether_addr(addr) && !is_zero_ether_addr(addr))
827 return -EADDRNOTAVAIL;
828 } else {
829 if (!is_valid_ether_addr(addr))
830 return -EADDRNOTAVAIL;
831 }
01f2e4ea
SF		 832
833 memcpy(netdev->dev_addr, addr, netdev->addr_len);
834
835 return 0;
836}
837
f8bd9091
SF		 838static int enic_dev_add_station_addr(struct enic *enic)
839{
840 int err = 0;
841
842 if (is_valid_ether_addr(enic->netdev->dev_addr)) {
843 spin_lock(&enic->devcmd_lock);
844 err = vnic_dev_add_addr(enic->vdev, enic->netdev->dev_addr);
845 spin_unlock(&enic->devcmd_lock);
846 }
847
848 return err;
849}
850
851static int enic_dev_del_station_addr(struct enic *enic)
852{
853 int err = 0;
854
855 if (is_valid_ether_addr(enic->netdev->dev_addr)) {
856 spin_lock(&enic->devcmd_lock);
857 err = vnic_dev_del_addr(enic->vdev, enic->netdev->dev_addr);
858 spin_unlock(&enic->devcmd_lock);
859 }
860
861 return err;
862}
863
864static int enic_set_mac_address_dynamic(struct net_device *netdev, void *p)
865{
866 struct enic *enic = netdev_priv(netdev);
867 struct sockaddr *saddr = p;
868 char *addr = saddr->sa_data;
869 int err;
870
871 if (netif_running(enic->netdev)) {
872 err = enic_dev_del_station_addr(enic);
873 if (err)
874 return err;
875 }
876
877 err = enic_set_mac_addr(netdev, addr);
878 if (err)
879 return err;
880
881 if (netif_running(enic->netdev)) {
882 err = enic_dev_add_station_addr(enic);
883 if (err)
884 return err;
885 }
886
887 return err;
888}
889
890static int enic_set_mac_address(struct net_device *netdev, void *p)
891{
892 return -EOPNOTSUPP;
893}
894
01f2e4ea
SF		 895/* netif_tx_lock held, BHs disabled */
896static void enic_set_multicast_list(struct net_device *netdev)
897{
898 struct enic *enic = netdev_priv(netdev);
22bedad3 899 struct netdev_hw_addr *ha;
01f2e4ea
SF		 900 int directed = 1;
901 int multicast = (netdev->flags & IFF_MULTICAST) ? 1 : 0;
902 int broadcast = (netdev->flags & IFF_BROADCAST) ? 1 : 0;
903 int promisc = (netdev->flags & IFF_PROMISC) ? 1 : 0;
4cd24eaf 904 unsigned int mc_count = netdev_mc_count(netdev);
01f2e4ea 905 int allmulti = (netdev->flags & IFF_ALLMULTI) ||
641cb85e 906 mc_count > ENIC_MULTICAST_PERFECT_FILTERS;
9959a185 907 unsigned int flags = netdev->flags | (allmulti ? IFF_ALLMULTI : 0);
01f2e4ea 908 u8 mc_addr[ENIC_MULTICAST_PERFECT_FILTERS][ETH_ALEN];
01f2e4ea
SF		 909 unsigned int i, j;
910
911 if (mc_count > ENIC_MULTICAST_PERFECT_FILTERS)
912 mc_count = ENIC_MULTICAST_PERFECT_FILTERS;
913
914 spin_lock(&enic->devcmd_lock);
915
9959a185
SF		 916 if (enic->flags != flags) {
917 enic->flags = flags;
918 vnic_dev_packet_filter(enic->vdev, directed,
919 multicast, broadcast, promisc, allmulti);
920 }
01f2e4ea
SF		 921
922 /* Is there an easier way? Trying to minimize to
923 * calls to add/del multicast addrs. We keep the
924 * addrs from the last call in enic->mc_addr and
925 * look for changes to add/del.
926 */
927
48e2f183 928 i = 0;
22bedad3 929 netdev_for_each_mc_addr(ha, netdev) {
48e2f183
JP		 930 if (i == mc_count)
931 break;
22bedad3 932 memcpy(mc_addr[i++], ha->addr, ETH_ALEN);
01f2e4ea
SF		 933 }
934
935 for (i = 0; i < enic->mc_count; i++) {
936 for (j = 0; j < mc_count; j++)
937 if (compare_ether_addr(enic->mc_addr[i],
938 mc_addr[j]) == 0)
939 break;
940 if (j == mc_count)
941 enic_del_multicast_addr(enic, enic->mc_addr[i]);
942 }
943
944 for (i = 0; i < mc_count; i++) {
945 for (j = 0; j < enic->mc_count; j++)
946 if (compare_ether_addr(mc_addr[i],
947 enic->mc_addr[j]) == 0)
948 break;
949 if (j == enic->mc_count)
950 enic_add_multicast_addr(enic, mc_addr[i]);
951 }
952
953 /* Save the list to compare against next time
954 */
955
956 for (i = 0; i < mc_count; i++)
957 memcpy(enic->mc_addr[i], mc_addr[i], ETH_ALEN);
958
959 enic->mc_count = mc_count;
960
961 spin_unlock(&enic->devcmd_lock);
962}
963
964/* rtnl lock is held */
965static void enic_vlan_rx_register(struct net_device *netdev,
966 struct vlan_group *vlan_group)
967{
968 struct enic *enic = netdev_priv(netdev);
969 enic->vlan_group = vlan_group;
970}
971
972/* rtnl lock is held */
973static void enic_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
974{
975 struct enic *enic = netdev_priv(netdev);
976
977 spin_lock(&enic->devcmd_lock);
978 enic_add_vlan(enic, vid);
979 spin_unlock(&enic->devcmd_lock);
980}
981
982/* rtnl lock is held */
983static void enic_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
984{
985 struct enic *enic = netdev_priv(netdev);
986
987 spin_lock(&enic->devcmd_lock);
988 enic_del_vlan(enic, vid);
989 spin_unlock(&enic->devcmd_lock);
990}
991
992/* netif_tx_lock held, BHs disabled */
993static void enic_tx_timeout(struct net_device *netdev)
994{
995 struct enic *enic = netdev_priv(netdev);
996 schedule_work(&enic->reset);
997}
998
f8bd9091
SF		 999static int enic_vnic_dev_deinit(struct enic *enic)
1000{
1001 int err;
1002
1003 spin_lock(&enic->devcmd_lock);
1004 err = vnic_dev_deinit(enic->vdev);
1005 spin_unlock(&enic->devcmd_lock);
1006
1007 return err;
1008}
1009
1010static int enic_dev_init_prov(struct enic *enic, struct vic_provinfo *vp)
1011{
1012 int err;
1013
1014 spin_lock(&enic->devcmd_lock);
1015 err = vnic_dev_init_prov(enic->vdev,
1016 (u8 *)vp, vic_provinfo_size(vp));
1017 spin_unlock(&enic->devcmd_lock);
1018
1019 return err;
1020}
1021
1022static int enic_dev_init_done(struct enic *enic, int *done, int *error)
1023{
1024 int err;
1025
1026 spin_lock(&enic->devcmd_lock);
1027 err = vnic_dev_init_done(enic->vdev, done, error);
1028 spin_unlock(&enic->devcmd_lock);
1029
1030 return err;
1031}
1032
08f382eb 1033static int enic_set_port_profile(struct enic *enic, u8 *mac)
f8bd9091
SF		 1034{
1035 struct vic_provinfo *vp;
1036 u8 oui[3] = VIC_PROVINFO_CISCO_OUI;
6fc7f573 1037 u8 *uuid;
f8bd9091 1038 char uuid_str[38];
6fc7f573
SF		 1039 static char *uuid_fmt = "%02X%02X%02X%02X-%02X%02X-%02X%02X-"
1040 "%02X%02X-%02X%02X%02X%02X%0X%02X";
f8bd9091
SF		 1041 int err;
1042
08f382eb
SF		 1043 err = enic_vnic_dev_deinit(enic);
1044 if (err)
1045 return err;
f8bd9091 1046
08f382eb 1047 switch (enic->pp.request) {
f8bd9091 1048
08f382eb 1049 case PORT_REQUEST_ASSOCIATE:
f8bd9091 1050
08f382eb
SF		 1051 if (!(enic->pp.set & ENIC_SET_NAME) || !strlen(enic->pp.name))
1052 return -EINVAL;
f8bd9091 1053
08f382eb
SF		 1054 if (!is_valid_ether_addr(mac))
1055 return -EADDRNOTAVAIL;
f8bd9091 1056
08f382eb
SF		 1057 vp = vic_provinfo_alloc(GFP_KERNEL, oui,
1058 VIC_PROVINFO_LINUX_TYPE);
1059 if (!vp)
1060 return -ENOMEM;
f8bd9091 1061
f8bd9091 1062 vic_provinfo_add_tlv(vp,
08f382eb
SF		 1063 VIC_LINUX_PROV_TLV_PORT_PROFILE_NAME_STR,
1064 strlen(enic->pp.name) + 1, enic->pp.name);
f8bd9091 1065
08f382eb
SF		 1066 vic_provinfo_add_tlv(vp,
1067 VIC_LINUX_PROV_TLV_CLIENT_MAC_ADDR,
1068 ETH_ALEN, mac);
1069
1070 if (enic->pp.set & ENIC_SET_INSTANCE) {
1071 uuid = enic->pp.instance_uuid;
1072 sprintf(uuid_str, uuid_fmt,
1073 uuid[0], uuid[1], uuid[2], uuid[3],
1074 uuid[4], uuid[5], uuid[6], uuid[7],
1075 uuid[8], uuid[9], uuid[10], uuid[11],
1076 uuid[12], uuid[13], uuid[14], uuid[15]);
1077 vic_provinfo_add_tlv(vp,
1078 VIC_LINUX_PROV_TLV_CLIENT_UUID_STR,
1079 sizeof(uuid_str), uuid_str);
1080 }
f8bd9091 1081
08f382eb
SF		 1082 if (enic->pp.set & ENIC_SET_HOST) {
1083 uuid = enic->pp.host_uuid;
1084 sprintf(uuid_str, uuid_fmt,
1085 uuid[0], uuid[1], uuid[2], uuid[3],
1086 uuid[4], uuid[5], uuid[6], uuid[7],
1087 uuid[8], uuid[9], uuid[10], uuid[11],
1088 uuid[12], uuid[13], uuid[14], uuid[15]);
1089 vic_provinfo_add_tlv(vp,
1090 VIC_LINUX_PROV_TLV_HOST_UUID_STR,
1091 sizeof(uuid_str), uuid_str);
1092 }
f8bd9091 1093
08f382eb
SF		 1094 err = enic_dev_init_prov(enic, vp);
1095 vic_provinfo_free(vp);
1096 if (err)
1097 return err;
1098 break;
f8bd9091 1099
08f382eb
SF		 1100 case PORT_REQUEST_DISASSOCIATE:
1101 break;
f8bd9091 1102
08f382eb
SF		 1103 default:
1104 return -EINVAL;
1105 }
f8bd9091 1106
08f382eb
SF		 1107 enic->pp.set |= ENIC_SET_APPLIED;
1108 return 0;
f8bd9091
SF		 1109}
1110
1111static int enic_set_vf_port(struct net_device *netdev, int vf,
1112 struct nlattr *port[])
1113{
1114 struct enic *enic = netdev_priv(netdev);
08f382eb
SF		 1115
1116 memset(&enic->pp, 0, sizeof(enic->pp));
1117
1118 if (port[IFLA_PORT_REQUEST]) {
1119 enic->pp.set |= ENIC_SET_REQUEST;
1120 enic->pp.request = nla_get_u8(port[IFLA_PORT_REQUEST]);
1121 }
1122
1123 if (port[IFLA_PORT_PROFILE]) {
1124 enic->pp.set |= ENIC_SET_NAME;
1125 memcpy(enic->pp.name, nla_data(port[IFLA_PORT_PROFILE]),
1126 PORT_PROFILE_MAX);
1127 }
1128
1129 if (port[IFLA_PORT_INSTANCE_UUID]) {
1130 enic->pp.set |= ENIC_SET_INSTANCE;
1131 memcpy(enic->pp.instance_uuid,
1132 nla_data(port[IFLA_PORT_INSTANCE_UUID]), PORT_UUID_MAX);
1133 }
1134
1135 if (port[IFLA_PORT_HOST_UUID]) {
1136 enic->pp.set |= ENIC_SET_HOST;
1137 memcpy(enic->pp.host_uuid,
1138 nla_data(port[IFLA_PORT_HOST_UUID]), PORT_UUID_MAX);
1139 }
f8bd9091
SF		 1140
1141 /* don't support VFs, yet */
1142 if (vf != PORT_SELF_VF)
1143 return -EOPNOTSUPP;
1144
08f382eb
SF		 1145 if (!(enic->pp.set & ENIC_SET_REQUEST))
1146 return -EOPNOTSUPP;
f8bd9091 1147
08f382eb 1148 if (enic->pp.request == PORT_REQUEST_ASSOCIATE) {
f8bd9091 1149
418c437d
SF		 1150 /* If the interface mac addr hasn't been assigned,
1151 * assign a random mac addr before setting port-
1152 * profile.
1153 */
1154
1155 if (is_zero_ether_addr(netdev->dev_addr))
1156 random_ether_addr(netdev->dev_addr);
f8bd9091
SF		 1157 }
1158
08f382eb 1159 return enic_set_port_profile(enic, netdev->dev_addr);
f8bd9091
SF		 1160}
1161
1162static int enic_get_vf_port(struct net_device *netdev, int vf,
1163 struct sk_buff *skb)
1164{
1165 struct enic *enic = netdev_priv(netdev);
1166 int err, error, done;
1167 u16 response = PORT_PROFILE_RESPONSE_SUCCESS;
1168
08f382eb
SF		 1169 if (!(enic->pp.set & ENIC_SET_APPLIED))
1170 return -ENODATA;
f8bd9091
SF		 1171
1172 err = enic_dev_init_done(enic, &done, &error);
f8bd9091 1173 if (err)
08f382eb 1174 error = err;
f8bd9091
SF		 1175
1176 switch (error) {
1177 case ERR_SUCCESS:
1178 if (!done)
1179 response = PORT_PROFILE_RESPONSE_INPROGRESS;
1180 break;
1181 case ERR_EINVAL:
1182 response = PORT_PROFILE_RESPONSE_INVALID;
1183 break;
1184 case ERR_EBADSTATE:
1185 response = PORT_PROFILE_RESPONSE_BADSTATE;
1186 break;
1187 case ERR_ENOMEM:
1188 response = PORT_PROFILE_RESPONSE_INSUFFICIENT_RESOURCES;
1189 break;
1190 default:
1191 response = PORT_PROFILE_RESPONSE_ERROR;
1192 break;
1193 }
1194
1195 NLA_PUT_U16(skb, IFLA_PORT_REQUEST, enic->pp.request);
1196 NLA_PUT_U16(skb, IFLA_PORT_RESPONSE, response);
08f382eb
SF		 1197 if (enic->pp.set & ENIC_SET_NAME)
1198 NLA_PUT(skb, IFLA_PORT_PROFILE, PORT_PROFILE_MAX,
1199 enic->pp.name);
1200 if (enic->pp.set & ENIC_SET_INSTANCE)
1201 NLA_PUT(skb, IFLA_PORT_INSTANCE_UUID, PORT_UUID_MAX,
1202 enic->pp.instance_uuid);
1203 if (enic->pp.set & ENIC_SET_HOST)
1204 NLA_PUT(skb, IFLA_PORT_HOST_UUID, PORT_UUID_MAX,
1205 enic->pp.host_uuid);
f8bd9091
SF		 1206
1207 return 0;
1208
1209nla_put_failure:
1210 return -EMSGSIZE;
1211}
1212
01f2e4ea
SF		 1213static void enic_free_rq_buf(struct vnic_rq *rq, struct vnic_rq_buf *buf)
1214{
1215 struct enic *enic = vnic_dev_priv(rq->vdev);
1216
1217 if (!buf->os_buf)
1218 return;
1219
1220 pci_unmap_single(enic->pdev, buf->dma_addr,
1221 buf->len, PCI_DMA_FROMDEVICE);
1222 dev_kfree_skb_any(buf->os_buf);
1223}
1224
01f2e4ea
SF		 1225static int enic_rq_alloc_buf(struct vnic_rq *rq)
1226{
1227 struct enic *enic = vnic_dev_priv(rq->vdev);
d19e22dc 1228 struct net_device *netdev = enic->netdev;
01f2e4ea 1229 struct sk_buff *skb;
d19e22dc 1230 unsigned int len = netdev->mtu + ETH_HLEN;
01f2e4ea
SF		 1231 unsigned int os_buf_index = 0;
1232 dma_addr_t dma_addr;
1233
89d71a66 1234 skb = netdev_alloc_skb_ip_align(netdev, len);
01f2e4ea
SF		 1235 if (!skb)
1236 return -ENOMEM;
1237
1238 dma_addr = pci_map_single(enic->pdev, skb->data,
1239 len, PCI_DMA_FROMDEVICE);
1240
1241 enic_queue_rq_desc(rq, skb, os_buf_index,
1242 dma_addr, len);
1243
1244 return 0;
1245}
1246
4badc385
SF		 1247static int enic_rq_alloc_buf_a1(struct vnic_rq *rq)
1248{
1249 struct rq_enet_desc *desc = vnic_rq_next_desc(rq);
1250
1251 if (vnic_rq_posting_soon(rq)) {
1252
1253 /* SW workaround for A0 HW erratum: if we're just about
1254 * to write posted_index, insert a dummy desc
1255 * of type resvd
1256 */
1257
1258 rq_enet_desc_enc(desc, 0, RQ_ENET_TYPE_RESV2, 0);
1259 vnic_rq_post(rq, 0, 0, 0, 0);
1260 } else {
1261 return enic_rq_alloc_buf(rq);
1262 }
1263
1264 return 0;
1265}
1266
1267static int enic_set_rq_alloc_buf(struct enic *enic)
1268{
1269 enum vnic_dev_hw_version hw_ver;
1270 int err;
1271
1272 err = vnic_dev_hw_version(enic->vdev, &hw_ver);
1273 if (err)
1274 return err;
1275
1276 switch (hw_ver) {
1277 case VNIC_DEV_HW_VER_A1:
1278 enic->rq_alloc_buf = enic_rq_alloc_buf_a1;
1279 break;
1280 case VNIC_DEV_HW_VER_A2:
1281 case VNIC_DEV_HW_VER_UNKNOWN:
1282 enic->rq_alloc_buf = enic_rq_alloc_buf;
1283 break;
1284 default:
1285 return -ENODEV;
1286 }
1287
1288 return 0;
1289}
1290
01f2e4ea
SF		 1291static void enic_rq_indicate_buf(struct vnic_rq *rq,
1292 struct cq_desc *cq_desc, struct vnic_rq_buf *buf,
1293 int skipped, void *opaque)
1294{
1295 struct enic *enic = vnic_dev_priv(rq->vdev);
86ca9db7 1296 struct net_device *netdev = enic->netdev;
01f2e4ea
SF		 1297 struct sk_buff *skb;
1298
1299 u8 type, color, eop, sop, ingress_port, vlan_stripped;
1300 u8 fcoe, fcoe_sof, fcoe_fc_crc_ok, fcoe_enc_error, fcoe_eof;
1301 u8 tcp_udp_csum_ok, udp, tcp, ipv4_csum_ok;
1302 u8 ipv6, ipv4, ipv4_fragment, fcs_ok, rss_type, csum_not_calc;
1303 u8 packet_error;
f8cac14a 1304 u16 q_number, completed_index, bytes_written, vlan_tci, checksum;
01f2e4ea
SF		 1305 u32 rss_hash;
1306
1307 if (skipped)
1308 return;
1309
1310 skb = buf->os_buf;
1311 prefetch(skb->data - NET_IP_ALIGN);
1312 pci_unmap_single(enic->pdev, buf->dma_addr,
1313 buf->len, PCI_DMA_FROMDEVICE);
1314
1315 cq_enet_rq_desc_dec((struct cq_enet_rq_desc *)cq_desc,
1316 &type, &color, &q_number, &completed_index,
1317 &ingress_port, &fcoe, &eop, &sop, &rss_type,
1318 &csum_not_calc, &rss_hash, &bytes_written,
f8cac14a 1319 &packet_error, &vlan_stripped, &vlan_tci, &checksum,
01f2e4ea
SF		 1320 &fcoe_sof, &fcoe_fc_crc_ok, &fcoe_enc_error,
1321 &fcoe_eof, &tcp_udp_csum_ok, &udp, &tcp,
1322 &ipv4_csum_ok, &ipv6, &ipv4, &ipv4_fragment,
1323 &fcs_ok);
1324
1325 if (packet_error) {
1326
350991e1
SF		 1327 if (!fcs_ok) {
1328 if (bytes_written > 0)
1329 enic->rq_bad_fcs++;
1330 else if (bytes_written == 0)
1331 enic->rq_truncated_pkts++;
1332 }
01f2e4ea
SF		 1333
1334 dev_kfree_skb_any(skb);
1335
1336 return;
1337 }
1338
1339 if (eop && bytes_written > 0) {
1340
1341 /* Good receive
1342 */
1343
1344 skb_put(skb, bytes_written);
86ca9db7 1345 skb->protocol = eth_type_trans(skb, netdev);
01f2e4ea
SF		 1346
1347 if (enic->csum_rx_enabled && !csum_not_calc) {
1348 skb->csum = htons(checksum);
1349 skb->ip_summed = CHECKSUM_COMPLETE;
1350 }
1351
86ca9db7 1352 skb->dev = netdev;
01f2e4ea 1353
f8cac14a
VK		 1354 if (enic->vlan_group && vlan_stripped &&
1355 (vlan_tci & CQ_ENET_RQ_DESC_VLAN_TCI_VLAN_MASK)) {
01f2e4ea 1356
88132f55
VK		 1357 if (netdev->features & NETIF_F_GRO)
1358 vlan_gro_receive(&enic->napi, enic->vlan_group,
f8cac14a 1359 vlan_tci, skb);
01f2e4ea
SF		 1360 else
1361 vlan_hwaccel_receive_skb(skb,
f8cac14a 1362 enic->vlan_group, vlan_tci);
01f2e4ea
SF		 1363
1364 } else {
1365
88132f55
VK		 1366 if (netdev->features & NETIF_F_GRO)
1367 napi_gro_receive(&enic->napi, skb);
01f2e4ea
SF		 1368 else
1369 netif_receive_skb(skb);
1370
1371 }
1372
1373 } else {
1374
1375 /* Buffer overflow
1376 */
1377
1378 dev_kfree_skb_any(skb);
1379 }
1380}
1381
1382static int enic_rq_service(struct vnic_dev *vdev, struct cq_desc *cq_desc,
1383 u8 type, u16 q_number, u16 completed_index, void *opaque)
1384{
1385 struct enic *enic = vnic_dev_priv(vdev);
1386
1387 vnic_rq_service(&enic->rq[q_number], cq_desc,
1388 completed_index, VNIC_RQ_RETURN_DESC,
1389 enic_rq_indicate_buf, opaque);
1390
1391 return 0;
1392}
1393
01f2e4ea
SF		 1394static int enic_poll(struct napi_struct *napi, int budget)
1395{
1396 struct enic *enic = container_of(napi, struct enic, napi);
01f2e4ea
SF		 1397 unsigned int rq_work_to_do = budget;
1398 unsigned int wq_work_to_do = -1; /* no limit */
1399 unsigned int work_done, rq_work_done, wq_work_done;
2d6ddced 1400 int err;
01f2e4ea
SF		 1401
1402 /* Service RQ (first) and WQ
1403 */
1404
1405 rq_work_done = vnic_cq_service(&enic->cq[ENIC_CQ_RQ],
1406 rq_work_to_do, enic_rq_service, NULL);
1407
1408 wq_work_done = vnic_cq_service(&enic->cq[ENIC_CQ_WQ],
1409 wq_work_to_do, enic_wq_service, NULL);
1410
1411 /* Accumulate intr event credits for this polling
1412 * cycle. An intr event is the completion of a
1413 * a WQ or RQ packet.
1414 */
1415
1416 work_done = rq_work_done + wq_work_done;
1417
1418 if (work_done > 0)
1419 vnic_intr_return_credits(&enic->intr[ENIC_INTX_WQ_RQ],
1420 work_done,
1421 0 /* don't unmask intr */,
1422 0 /* don't reset intr timer */);
1423
2d6ddced 1424 err = vnic_rq_fill(&enic->rq[0], enic->rq_alloc_buf);
01f2e4ea 1425
2d6ddced
SF		 1426 /* Buffer allocation failed. Stay in polling
1427 * mode so we can try to fill the ring again.
1428 */
01f2e4ea 1429
2d6ddced
SF		 1430 if (err)
1431 rq_work_done = rq_work_to_do;
01f2e4ea 1432
2d6ddced 1433 if (rq_work_done < rq_work_to_do) {
01f2e4ea 1434
2d6ddced 1435 /* Some work done, but not enough to stay in polling,
88132f55 1436 * exit polling
01f2e4ea
SF		 1437 */
1438
288379f0 1439 napi_complete(napi);
ed8af6b2 1440 vnic_intr_unmask(&enic->intr[ENIC_INTX_WQ_RQ]);
01f2e4ea
SF		 1441 }
1442
1443 return rq_work_done;
1444}
1445
1446static int enic_poll_msix(struct napi_struct *napi, int budget)
1447{
1448 struct enic *enic = container_of(napi, struct enic, napi);
01f2e4ea
SF		 1449 unsigned int work_to_do = budget;
1450 unsigned int work_done;
2d6ddced 1451 int err;
01f2e4ea
SF		 1452
1453 /* Service RQ
1454 */
1455
1456 work_done = vnic_cq_service(&enic->cq[ENIC_CQ_RQ],
1457 work_to_do, enic_rq_service, NULL);
1458
2d6ddced
SF		 1459 /* Return intr event credits for this polling
1460 * cycle. An intr event is the completion of a
1461 * RQ packet.
1462 */
01f2e4ea 1463
2d6ddced 1464 if (work_done > 0)
01f2e4ea
SF		 1465 vnic_intr_return_credits(&enic->intr[ENIC_MSIX_RQ],
1466 work_done,
1467 0 /* don't unmask intr */,
1468 0 /* don't reset intr timer */);
01f2e4ea 1469
2d6ddced
SF		 1470 err = vnic_rq_fill(&enic->rq[0], enic->rq_alloc_buf);
1471
1472 /* Buffer allocation failed. Stay in polling mode
1473 * so we can try to fill the ring again.
1474 */
1475
1476 if (err)
1477 work_done = work_to_do;
1478
1479 if (work_done < work_to_do) {
1480
1481 /* Some work done, but not enough to stay in polling,
88132f55 1482 * exit polling
01f2e4ea
SF		 1483 */
1484
288379f0 1485 napi_complete(napi);
01f2e4ea
SF		 1486 vnic_intr_unmask(&enic->intr[ENIC_MSIX_RQ]);
1487 }
1488
1489 return work_done;
1490}
1491
1492static void enic_notify_timer(unsigned long data)
1493{
1494 struct enic *enic = (struct enic *)data;
1495
1496 enic_notify_check(enic);
1497
25f0a061
SF		 1498 mod_timer(&enic->notify_timer,
1499 round_jiffies(jiffies + ENIC_NOTIFY_TIMER_PERIOD));
01f2e4ea
SF		 1500}
1501
1502static void enic_free_intr(struct enic *enic)
1503{
1504 struct net_device *netdev = enic->netdev;
1505 unsigned int i;
1506
1507 switch (vnic_dev_get_intr_mode(enic->vdev)) {
1508 case VNIC_DEV_INTR_MODE_INTX:
01f2e4ea
SF		 1509 free_irq(enic->pdev->irq, netdev);
1510 break;
8f4d248c
SF		 1511 case VNIC_DEV_INTR_MODE_MSI:
1512 free_irq(enic->pdev->irq, enic);
1513 break;
01f2e4ea
SF		 1514 case VNIC_DEV_INTR_MODE_MSIX:
1515 for (i = 0; i < ARRAY_SIZE(enic->msix); i++)
1516 if (enic->msix[i].requested)
1517 free_irq(enic->msix_entry[i].vector,
1518 enic->msix[i].devid);
1519 break;
1520 default:
1521 break;
1522 }
1523}
1524
1525static int enic_request_intr(struct enic *enic)
1526{
1527 struct net_device *netdev = enic->netdev;
1528 unsigned int i;
1529 int err = 0;
1530
1531 switch (vnic_dev_get_intr_mode(enic->vdev)) {
1532
1533 case VNIC_DEV_INTR_MODE_INTX:
1534
1535 err = request_irq(enic->pdev->irq, enic_isr_legacy,
1536 IRQF_SHARED, netdev->name, netdev);
1537 break;
1538
1539 case VNIC_DEV_INTR_MODE_MSI:
1540
1541 err = request_irq(enic->pdev->irq, enic_isr_msi,
1542 0, netdev->name, enic);
1543 break;
1544
1545 case VNIC_DEV_INTR_MODE_MSIX:
1546
1547 sprintf(enic->msix[ENIC_MSIX_RQ].devname,
8f4d248c 1548 "%.11s-rx-0", netdev->name);
01f2e4ea
SF		 1549 enic->msix[ENIC_MSIX_RQ].isr = enic_isr_msix_rq;
1550 enic->msix[ENIC_MSIX_RQ].devid = enic;
1551
1552 sprintf(enic->msix[ENIC_MSIX_WQ].devname,
8f4d248c 1553 "%.11s-tx-0", netdev->name);
01f2e4ea
SF		 1554 enic->msix[ENIC_MSIX_WQ].isr = enic_isr_msix_wq;
1555 enic->msix[ENIC_MSIX_WQ].devid = enic;
1556
1557 sprintf(enic->msix[ENIC_MSIX_ERR].devname,
1558 "%.11s-err", netdev->name);
1559 enic->msix[ENIC_MSIX_ERR].isr = enic_isr_msix_err;
1560 enic->msix[ENIC_MSIX_ERR].devid = enic;
1561
1562 sprintf(enic->msix[ENIC_MSIX_NOTIFY].devname,
1563 "%.11s-notify", netdev->name);
1564 enic->msix[ENIC_MSIX_NOTIFY].isr = enic_isr_msix_notify;
1565 enic->msix[ENIC_MSIX_NOTIFY].devid = enic;
1566
1567 for (i = 0; i < ARRAY_SIZE(enic->msix); i++) {
1568 err = request_irq(enic->msix_entry[i].vector,
1569 enic->msix[i].isr, 0,
1570 enic->msix[i].devname,
1571 enic->msix[i].devid);
1572 if (err) {
1573 enic_free_intr(enic);
1574 break;
1575 }
1576 enic->msix[i].requested = 1;
1577 }
1578
1579 break;
1580
1581 default:
1582 break;
1583 }
1584
1585 return err;
1586}
1587
b3d18d19
SF		 1588static void enic_synchronize_irqs(struct enic *enic)
1589{
1590 unsigned int i;
1591
1592 switch (vnic_dev_get_intr_mode(enic->vdev)) {
1593 case VNIC_DEV_INTR_MODE_INTX:
1594 case VNIC_DEV_INTR_MODE_MSI:
1595 synchronize_irq(enic->pdev->irq);
1596 break;
1597 case VNIC_DEV_INTR_MODE_MSIX:
1598 for (i = 0; i < enic->intr_count; i++)
1599 synchronize_irq(enic->msix_entry[i].vector);
1600 break;
1601 default:
1602 break;
1603 }
1604}
1605
01f2e4ea
SF		 1606static int enic_notify_set(struct enic *enic)
1607{
1608 int err;
1609
56ac88b3 1610 spin_lock(&enic->devcmd_lock);
01f2e4ea
SF		 1611 switch (vnic_dev_get_intr_mode(enic->vdev)) {
1612 case VNIC_DEV_INTR_MODE_INTX:
1613 err = vnic_dev_notify_set(enic->vdev, ENIC_INTX_NOTIFY);
1614 break;
1615 case VNIC_DEV_INTR_MODE_MSIX:
1616 err = vnic_dev_notify_set(enic->vdev, ENIC_MSIX_NOTIFY);
1617 break;
1618 default:
1619 err = vnic_dev_notify_set(enic->vdev, -1 /* no intr */);
1620 break;
1621 }
56ac88b3 1622 spin_unlock(&enic->devcmd_lock);
01f2e4ea
SF		 1623
1624 return err;
1625}
1626
1627static void enic_notify_timer_start(struct enic *enic)
1628{
1629 switch (vnic_dev_get_intr_mode(enic->vdev)) {
1630 case VNIC_DEV_INTR_MODE_MSI:
1631 mod_timer(&enic->notify_timer, jiffies);
1632 break;
1633 default:
1634 /* Using intr for notification for INTx/MSI-X */
1635 break;
1636 };
1637}
1638
1639/* rtnl lock is held, process context */
1640static int enic_open(struct net_device *netdev)
1641{
1642 struct enic *enic = netdev_priv(netdev);
1643 unsigned int i;
1644 int err;
1645
4b75a442
SF		 1646 err = enic_request_intr(enic);
1647 if (err) {
1648 printk(KERN_ERR PFX "%s: Unable to request irq.\n",
1649 netdev->name);
1650 return err;
1651 }
1652
1653 err = enic_notify_set(enic);
1654 if (err) {
1655 printk(KERN_ERR PFX
1656 "%s: Failed to alloc notify buffer, aborting.\n",
1657 netdev->name);
1658 goto err_out_free_intr;
1659 }
1660
01f2e4ea 1661 for (i = 0; i < enic->rq_count; i++) {
2d6ddced
SF		 1662 vnic_rq_fill(&enic->rq[i], enic->rq_alloc_buf);
1663 /* Need at least one buffer on ring to get going */
1664 if (vnic_rq_desc_used(&enic->rq[i]) == 0) {
01f2e4ea
SF		 1665 printk(KERN_ERR PFX
1666 "%s: Unable to alloc receive buffers.\n",
1667 netdev->name);
2d6ddced 1668 err = -ENOMEM;
4b75a442 1669 goto err_out_notify_unset;
01f2e4ea
SF		 1670 }
1671 }
1672
1673 for (i = 0; i < enic->wq_count; i++)
1674 vnic_wq_enable(&enic->wq[i]);
1675 for (i = 0; i < enic->rq_count; i++)
1676 vnic_rq_enable(&enic->rq[i]);
1677
f8bd9091 1678 enic_dev_add_station_addr(enic);
01f2e4ea
SF		 1679 enic_set_multicast_list(netdev);
1680
1681 netif_wake_queue(netdev);
1682 napi_enable(&enic->napi);
56ac88b3 1683 spin_lock(&enic->devcmd_lock);
01f2e4ea 1684 vnic_dev_enable(enic->vdev);
56ac88b3 1685 spin_unlock(&enic->devcmd_lock);
01f2e4ea
SF		 1686
1687 for (i = 0; i < enic->intr_count; i++)
1688 vnic_intr_unmask(&enic->intr[i]);
1689
1690 enic_notify_timer_start(enic);
1691
1692 return 0;
4b75a442
SF		 1693
1694err_out_notify_unset:
56ac88b3 1695 spin_lock(&enic->devcmd_lock);
4b75a442 1696 vnic_dev_notify_unset(enic->vdev);
56ac88b3 1697 spin_unlock(&enic->devcmd_lock);
4b75a442
SF		 1698err_out_free_intr:
1699 enic_free_intr(enic);
1700
1701 return err;
01f2e4ea
SF		 1702}
1703
1704/* rtnl lock is held, process context */
1705static int enic_stop(struct net_device *netdev)
1706{
1707 struct enic *enic = netdev_priv(netdev);
1708 unsigned int i;
1709 int err;
1710
b3d18d19
SF		 1711 for (i = 0; i < enic->intr_count; i++)
1712 vnic_intr_mask(&enic->intr[i]);
1713
1714 enic_synchronize_irqs(enic);
1715
01f2e4ea
SF		 1716 del_timer_sync(&enic->notify_timer);
1717
56ac88b3 1718 spin_lock(&enic->devcmd_lock);
01f2e4ea 1719 vnic_dev_disable(enic->vdev);
56ac88b3 1720 spin_unlock(&enic->devcmd_lock);
01f2e4ea 1721 napi_disable(&enic->napi);
b3d18d19
SF		 1722 netif_carrier_off(netdev);
1723 netif_tx_disable(netdev);
01f2e4ea 1724
f8bd9091
SF		 1725 enic_dev_del_station_addr(enic);
1726
01f2e4ea
SF		 1727 for (i = 0; i < enic->wq_count; i++) {
1728 err = vnic_wq_disable(&enic->wq[i]);
1729 if (err)
1730 return err;
1731 }
1732 for (i = 0; i < enic->rq_count; i++) {
1733 err = vnic_rq_disable(&enic->rq[i]);
1734 if (err)
1735 return err;
1736 }
1737
56ac88b3 1738 spin_lock(&enic->devcmd_lock);
4b75a442 1739 vnic_dev_notify_unset(enic->vdev);
56ac88b3 1740 spin_unlock(&enic->devcmd_lock);
4b75a442
SF		 1741 enic_free_intr(enic);
1742
01f2e4ea
SF		 1743 for (i = 0; i < enic->wq_count; i++)
1744 vnic_wq_clean(&enic->wq[i], enic_free_wq_buf);
1745 for (i = 0; i < enic->rq_count; i++)
1746 vnic_rq_clean(&enic->rq[i], enic_free_rq_buf);
1747 for (i = 0; i < enic->cq_count; i++)
1748 vnic_cq_clean(&enic->cq[i]);
1749 for (i = 0; i < enic->intr_count; i++)
1750 vnic_intr_clean(&enic->intr[i]);
1751
1752 return 0;
1753}
1754
1755static int enic_change_mtu(struct net_device *netdev, int new_mtu)
1756{
1757 struct enic *enic = netdev_priv(netdev);
1758 int running = netif_running(netdev);
1759
25f0a061
SF		 1760 if (new_mtu < ENIC_MIN_MTU || new_mtu > ENIC_MAX_MTU)
1761 return -EINVAL;
1762
01f2e4ea
SF		 1763 if (running)
1764 enic_stop(netdev);
1765
01f2e4ea
SF		 1766 netdev->mtu = new_mtu;
1767
1768 if (netdev->mtu > enic->port_mtu)
1769 printk(KERN_WARNING PFX
1770 "%s: interface MTU (%d) set higher "
1771 "than port MTU (%d)\n",
1772 netdev->name, netdev->mtu, enic->port_mtu);
1773
1774 if (running)
1775 enic_open(netdev);
1776
1777 return 0;
1778}
1779
1780#ifdef CONFIG_NET_POLL_CONTROLLER
1781static void enic_poll_controller(struct net_device *netdev)
1782{
1783 struct enic *enic = netdev_priv(netdev);
1784 struct vnic_dev *vdev = enic->vdev;
1785
1786 switch (vnic_dev_get_intr_mode(vdev)) {
1787 case VNIC_DEV_INTR_MODE_MSIX:
1788 enic_isr_msix_rq(enic->pdev->irq, enic);
1789 enic_isr_msix_wq(enic->pdev->irq, enic);
1790 break;
1791 case VNIC_DEV_INTR_MODE_MSI:
1792 enic_isr_msi(enic->pdev->irq, enic);
1793 break;
1794 case VNIC_DEV_INTR_MODE_INTX:
1795 enic_isr_legacy(enic->pdev->irq, netdev);
1796 break;
1797 default:
1798 break;
1799 }
1800}
1801#endif
1802
1803static int enic_dev_wait(struct vnic_dev *vdev,
1804 int (*start)(struct vnic_dev *, int),
1805 int (*finished)(struct vnic_dev *, int *),
1806 int arg)
1807{
1808 unsigned long time;
1809 int done;
1810 int err;
1811
1812 BUG_ON(in_interrupt());
1813
1814 err = start(vdev, arg);
1815 if (err)
1816 return err;
1817
1818 /* Wait for func to complete...2 seconds max
1819 */
1820
1821 time = jiffies + (HZ * 2);
1822 do {
1823
1824 err = finished(vdev, &done);
1825 if (err)
1826 return err;
1827
1828 if (done)
1829 return 0;
1830
1831 schedule_timeout_uninterruptible(HZ / 10);
1832
1833 } while (time_after(time, jiffies));
1834
1835 return -ETIMEDOUT;
1836}
1837
1838static int enic_dev_open(struct enic *enic)
1839{
1840 int err;
1841
1842 err = enic_dev_wait(enic->vdev, vnic_dev_open,
1843 vnic_dev_open_done, 0);
1844 if (err)
1845 printk(KERN_ERR PFX
1846 "vNIC device open failed, err %d.\n", err);
1847
1848 return err;
1849}
1850
99ef5639 1851static int enic_dev_hang_reset(struct enic *enic)
01f2e4ea
SF		 1852{
1853 int err;
1854
99ef5639
VK		 1855 err = enic_dev_wait(enic->vdev, vnic_dev_hang_reset,
1856 vnic_dev_hang_reset_done, 0);
01f2e4ea
SF		 1857 if (err)
1858 printk(KERN_ERR PFX
99ef5639 1859 "vNIC hang reset failed, err %d.\n", err);
01f2e4ea
SF		 1860
1861 return err;
1862}
1863
68f71708
SF		 1864static int enic_set_niccfg(struct enic *enic)
1865{
1866 const u8 rss_default_cpu = 0;
1867 const u8 rss_hash_type = 0;
1868 const u8 rss_hash_bits = 0;
1869 const u8 rss_base_cpu = 0;
1870 const u8 rss_enable = 0;
1871 const u8 tso_ipid_split_en = 0;
1872 const u8 ig_vlan_strip_en = 1;
1873
1874 /* Enable VLAN tag stripping. RSS not enabled (yet).
6ba9cdc0 1875 */
68f71708
SF		 1876
1877 return enic_set_nic_cfg(enic,
1878 rss_default_cpu, rss_hash_type,
1879 rss_hash_bits, rss_base_cpu,
1880 rss_enable, tso_ipid_split_en,
1881 ig_vlan_strip_en);
1882}
1883
f8cac14a
VK		 1884int enic_dev_set_ig_vlan_rewrite_mode(struct enic *enic)
1885{
1886 int err;
1887
1888 spin_lock(&enic->devcmd_lock);
1889 err = vnic_dev_set_ig_vlan_rewrite_mode(enic->vdev,
1890 IG_VLAN_REWRITE_MODE_PRIORITY_TAG_DEFAULT_VLAN);
1891 spin_unlock(&enic->devcmd_lock);
1892
1893 return err;
1894}
1895
01f2e4ea
SF		 1896static void enic_reset(struct work_struct *work)
1897{
1898 struct enic *enic = container_of(work, struct enic, reset);
1899
1900 if (!netif_running(enic->netdev))
1901 return;
1902
1903 rtnl_lock();
1904
1905 spin_lock(&enic->devcmd_lock);
1906 vnic_dev_hang_notify(enic->vdev);
1907 spin_unlock(&enic->devcmd_lock);
1908
1909 enic_stop(enic->netdev);
99ef5639
VK		 1910 enic_dev_hang_reset(enic);
1911 enic_reset_multicast_list(enic);
01f2e4ea 1912 enic_init_vnic_resources(enic);
68f71708 1913 enic_set_niccfg(enic);
f8cac14a 1914 enic_dev_set_ig_vlan_rewrite_mode(enic);
01f2e4ea
SF		 1915 enic_open(enic->netdev);
1916
1917 rtnl_unlock();
1918}
1919
1920static int enic_set_intr_mode(struct enic *enic)
1921{
6ba9cdc0
SF		 1922 unsigned int n = 1;
1923 unsigned int m = 1;
01f2e4ea
SF		 1924 unsigned int i;
1925
1926 /* Set interrupt mode (INTx, MSI, MSI-X) depending
1927 * system capabilities.
1928 *
1929 * Try MSI-X first
1930 *
1931 * We need n RQs, m WQs, n+m CQs, and n+m+2 INTRs
1932 * (the second to last INTR is used for WQ/RQ errors)
1933 * (the last INTR is used for notifications)
1934 */
1935
1936 BUG_ON(ARRAY_SIZE(enic->msix_entry) < n + m + 2);
1937 for (i = 0; i < n + m + 2; i++)
1938 enic->msix_entry[i].entry = i;
1939
1940 if (enic->config.intr_mode < 1 &&
1941 enic->rq_count >= n &&
1942 enic->wq_count >= m &&
1943 enic->cq_count >= n + m &&
1944 enic->intr_count >= n + m + 2 &&
1945 !pci_enable_msix(enic->pdev, enic->msix_entry, n + m + 2)) {
1946
1947 enic->rq_count = n;
1948 enic->wq_count = m;
1949 enic->cq_count = n + m;
1950 enic->intr_count = n + m + 2;
1951
1952 vnic_dev_set_intr_mode(enic->vdev, VNIC_DEV_INTR_MODE_MSIX);
1953
1954 return 0;
1955 }
1956
1957 /* Next try MSI
1958 *
1959 * We need 1 RQ, 1 WQ, 2 CQs, and 1 INTR
1960 */
1961
1962 if (enic->config.intr_mode < 2 &&
1963 enic->rq_count >= 1 &&
1964 enic->wq_count >= 1 &&
1965 enic->cq_count >= 2 &&
1966 enic->intr_count >= 1 &&
1967 !pci_enable_msi(enic->pdev)) {
1968
1969 enic->rq_count = 1;
1970 enic->wq_count = 1;
1971 enic->cq_count = 2;
1972 enic->intr_count = 1;
1973
1974 vnic_dev_set_intr_mode(enic->vdev, VNIC_DEV_INTR_MODE_MSI);
1975
1976 return 0;
1977 }
1978
1979 /* Next try INTx
1980 *
1981 * We need 1 RQ, 1 WQ, 2 CQs, and 3 INTRs
1982 * (the first INTR is used for WQ/RQ)
1983 * (the second INTR is used for WQ/RQ errors)
1984 * (the last INTR is used for notifications)
1985 */
1986
1987 if (enic->config.intr_mode < 3 &&
1988 enic->rq_count >= 1 &&
1989 enic->wq_count >= 1 &&
1990 enic->cq_count >= 2 &&
1991 enic->intr_count >= 3) {
1992
1993 enic->rq_count = 1;
1994 enic->wq_count = 1;
1995 enic->cq_count = 2;
1996 enic->intr_count = 3;
1997
1998 vnic_dev_set_intr_mode(enic->vdev, VNIC_DEV_INTR_MODE_INTX);
1999
2000 return 0;
2001 }
2002
2003 vnic_dev_set_intr_mode(enic->vdev, VNIC_DEV_INTR_MODE_UNKNOWN);
2004
2005 return -EINVAL;
2006}
2007
2008static void enic_clear_intr_mode(struct enic *enic)
2009{
2010 switch (vnic_dev_get_intr_mode(enic->vdev)) {
2011 case VNIC_DEV_INTR_MODE_MSIX:
2012 pci_disable_msix(enic->pdev);
2013 break;
2014 case VNIC_DEV_INTR_MODE_MSI:
2015 pci_disable_msi(enic->pdev);
2016 break;
2017 default:
2018 break;
2019 }
2020
2021 vnic_dev_set_intr_mode(enic->vdev, VNIC_DEV_INTR_MODE_UNKNOWN);
2022}
2023
f8bd9091
SF		 2024static const struct net_device_ops enic_netdev_dynamic_ops = {
2025 .ndo_open = enic_open,
2026 .ndo_stop = enic_stop,
2027 .ndo_start_xmit = enic_hard_start_xmit,
2028 .ndo_get_stats = enic_get_stats,
2029 .ndo_validate_addr = eth_validate_addr,
2030 .ndo_set_multicast_list = enic_set_multicast_list,
2031 .ndo_set_mac_address = enic_set_mac_address_dynamic,
2032 .ndo_change_mtu = enic_change_mtu,
2033 .ndo_vlan_rx_register = enic_vlan_rx_register,
2034 .ndo_vlan_rx_add_vid = enic_vlan_rx_add_vid,
2035 .ndo_vlan_rx_kill_vid = enic_vlan_rx_kill_vid,
2036 .ndo_tx_timeout = enic_tx_timeout,
2037 .ndo_set_vf_port = enic_set_vf_port,
2038 .ndo_get_vf_port = enic_get_vf_port,
2039#ifdef CONFIG_NET_POLL_CONTROLLER
2040 .ndo_poll_controller = enic_poll_controller,
2041#endif
2042};
2043
afe29f7a
SH		 2044static const struct net_device_ops enic_netdev_ops = {
2045 .ndo_open = enic_open,
2046 .ndo_stop = enic_stop,
00829823 2047 .ndo_start_xmit = enic_hard_start_xmit,
afe29f7a
SH		 2048 .ndo_get_stats = enic_get_stats,
2049 .ndo_validate_addr = eth_validate_addr,
2050 .ndo_set_multicast_list = enic_set_multicast_list,
f8bd9091 2051 .ndo_set_mac_address = enic_set_mac_address,
afe29f7a
SH		 2052 .ndo_change_mtu = enic_change_mtu,
2053 .ndo_vlan_rx_register = enic_vlan_rx_register,
2054 .ndo_vlan_rx_add_vid = enic_vlan_rx_add_vid,
2055 .ndo_vlan_rx_kill_vid = enic_vlan_rx_kill_vid,
2056 .ndo_tx_timeout = enic_tx_timeout,
2057#ifdef CONFIG_NET_POLL_CONTROLLER
2058 .ndo_poll_controller = enic_poll_controller,
2059#endif
2060};
2061
6fdfa970
SF		 2062void enic_dev_deinit(struct enic *enic)
2063{
2064 netif_napi_del(&enic->napi);
2065 enic_free_vnic_resources(enic);
2066 enic_clear_intr_mode(enic);
2067}
2068
2069int enic_dev_init(struct enic *enic)
2070{
2071 struct net_device *netdev = enic->netdev;
2072 int err;
2073
2074 /* Get vNIC configuration
2075 */
2076
2077 err = enic_get_vnic_config(enic);
2078 if (err) {
2079 printk(KERN_ERR PFX
2080 "Get vNIC configuration failed, aborting.\n");
2081 return err;
2082 }
2083
2084 /* Get available resource counts
2085 */
2086
2087 enic_get_res_counts(enic);
2088
2089 /* Set interrupt mode based on resource counts and system
2090 * capabilities
2091 */
2092
2093 err = enic_set_intr_mode(enic);
2094 if (err) {
2095 printk(KERN_ERR PFX
d87fd25d
SF		 2096 "Failed to set intr mode based on resource "
2097 "counts and system capabilities, aborting.\n");
6fdfa970
SF		 2098 return err;
2099 }
2100
2101 /* Allocate and configure vNIC resources
2102 */
2103
2104 err = enic_alloc_vnic_resources(enic);
2105 if (err) {
2106 printk(KERN_ERR PFX
2107 "Failed to alloc vNIC resources, aborting.\n");
2108 goto err_out_free_vnic_resources;
2109 }
2110
2111 enic_init_vnic_resources(enic);
2112
2113 err = enic_set_rq_alloc_buf(enic);
2114 if (err) {
2115 printk(KERN_ERR PFX
2116 "Failed to set RQ buffer allocator, aborting.\n");
2117 goto err_out_free_vnic_resources;
2118 }
2119
2120 err = enic_set_niccfg(enic);
2121 if (err) {
2122 printk(KERN_ERR PFX
2123 "Failed to config nic, aborting.\n");
2124 goto err_out_free_vnic_resources;
2125 }
2126
f8cac14a
VK		 2127 err = enic_dev_set_ig_vlan_rewrite_mode(enic);
2128 if (err) {
2129 printk(KERN_ERR PFX
2130 "Failed to set ingress vlan rewrite mode, aborting.\n");
2131 goto err_out_free_vnic_resources;
2132 }
2133
6fdfa970
SF		 2134 switch (vnic_dev_get_intr_mode(enic->vdev)) {
2135 default:
2136 netif_napi_add(netdev, &enic->napi, enic_poll, 64);
2137 break;
2138 case VNIC_DEV_INTR_MODE_MSIX:
2139 netif_napi_add(netdev, &enic->napi, enic_poll_msix, 64);
2140 break;
2141 }
2142
2143 return 0;
2144
2145err_out_free_vnic_resources:
2146 enic_clear_intr_mode(enic);
2147 enic_free_vnic_resources(enic);
2148
2149 return err;
2150}
2151
27e6c7d3
SF		 2152static void enic_iounmap(struct enic *enic)
2153{
2154 unsigned int i;
2155
2156 for (i = 0; i < ARRAY_SIZE(enic->bar); i++)
2157 if (enic->bar[i].vaddr)
2158 iounmap(enic->bar[i].vaddr);
2159}
2160
01f2e4ea
SF		 2161static int __devinit enic_probe(struct pci_dev *pdev,
2162 const struct pci_device_id *ent)
2163{
2164 struct net_device *netdev;
2165 struct enic *enic;
2166 int using_dac = 0;
2167 unsigned int i;
2168 int err;
2169
01f2e4ea
SF		 2170 /* Allocate net device structure and initialize. Private
2171 * instance data is initialized to zero.
2172 */
2173
2174 netdev = alloc_etherdev(sizeof(struct enic));
2175 if (!netdev) {
2176 printk(KERN_ERR PFX "Etherdev alloc failed, aborting.\n");
2177 return -ENOMEM;
2178 }
2179
01f2e4ea
SF		 2180 pci_set_drvdata(pdev, netdev);
2181
2182 SET_NETDEV_DEV(netdev, &pdev->dev);
2183
2184 enic = netdev_priv(netdev);
2185 enic->netdev = netdev;
2186 enic->pdev = pdev;
2187
2188 /* Setup PCI resources
2189 */
2190
2191 err = pci_enable_device(pdev);
2192 if (err) {
2193 printk(KERN_ERR PFX
4b75a442 2194 "Cannot enable PCI device, aborting.\n");
01f2e4ea
SF		 2195 goto err_out_free_netdev;
2196 }
2197
2198 err = pci_request_regions(pdev, DRV_NAME);
2199 if (err) {
2200 printk(KERN_ERR PFX
4b75a442 2201 "Cannot request PCI regions, aborting.\n");
01f2e4ea
SF		 2202 goto err_out_disable_device;
2203 }
2204
2205 pci_set_master(pdev);
2206
2207 /* Query PCI controller on system for DMA addressing
2208 * limitation for the device. Try 40-bit first, and
2209 * fail to 32-bit.
2210 */
2211
50cf156a 2212 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(40));
01f2e4ea 2213 if (err) {
284901a9 2214 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
01f2e4ea
SF		 2215 if (err) {
2216 printk(KERN_ERR PFX
4b75a442 2217 "No usable DMA configuration, aborting.\n");
01f2e4ea
SF		 2218 goto err_out_release_regions;
2219 }
284901a9 2220 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
01f2e4ea
SF		 2221 if (err) {
2222 printk(KERN_ERR PFX
4b75a442
SF		 2223 "Unable to obtain 32-bit DMA "
2224 "for consistent allocations, aborting.\n");
01f2e4ea
SF		 2225 goto err_out_release_regions;
2226 }
2227 } else {
50cf156a 2228 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(40));
01f2e4ea
SF		 2229 if (err) {
2230 printk(KERN_ERR PFX
4b75a442
SF		 2231 "Unable to obtain 40-bit DMA "
2232 "for consistent allocations, aborting.\n");
01f2e4ea
SF		 2233 goto err_out_release_regions;
2234 }
2235 using_dac = 1;
2236 }
2237
27e6c7d3 2238 /* Map vNIC resources from BAR0-5
01f2e4ea
SF		 2239 */
2240
27e6c7d3
SF		 2241 for (i = 0; i < ARRAY_SIZE(enic->bar); i++) {
2242 if (!(pci_resource_flags(pdev, i) & IORESOURCE_MEM))
2243 continue;
2244 enic->bar[i].len = pci_resource_len(pdev, i);
2245 enic->bar[i].vaddr = pci_iomap(pdev, i, enic->bar[i].len);
2246 if (!enic->bar[i].vaddr) {
2247 printk(KERN_ERR PFX
2248 "Cannot memory-map BAR %d, aborting.\n", i);
2249 err = -ENODEV;
2250 goto err_out_iounmap;
2251 }
2252 enic->bar[i].bus_addr = pci_resource_start(pdev, i);
01f2e4ea
SF		 2253 }
2254
2255 /* Register vNIC device
2256 */
2257
27e6c7d3
SF		 2258 enic->vdev = vnic_dev_register(NULL, enic, pdev, enic->bar,
2259 ARRAY_SIZE(enic->bar));
01f2e4ea
SF		 2260 if (!enic->vdev) {
2261 printk(KERN_ERR PFX
4b75a442 2262 "vNIC registration failed, aborting.\n");
01f2e4ea
SF		 2263 err = -ENODEV;
2264 goto err_out_iounmap;
2265 }
2266
2267 /* Issue device open to get device in known state
2268 */
2269
2270 err = enic_dev_open(enic);
2271 if (err) {
2272 printk(KERN_ERR PFX
4b75a442 2273 "vNIC dev open failed, aborting.\n");
01f2e4ea
SF		 2274 goto err_out_vnic_unregister;
2275 }
2276
2277 /* Issue device init to initialize the vnic-to-switch link.
2278 * We'll start with carrier off and wait for link UP
2279 * notification later to turn on carrier. We don't need
2280 * to wait here for the vnic-to-switch link initialization
2281 * to complete; link UP notification is the indication that
2282 * the process is complete.
2283 */
2284
2285 netif_carrier_off(netdev);
2286
f8bd9091
SF		 2287 if (!enic_is_dynamic(enic)) {
2288 err = vnic_dev_init(enic->vdev, 0);
2289 if (err) {
2290 printk(KERN_ERR PFX
2291 "vNIC dev init failed, aborting.\n");
2292 goto err_out_dev_close;
2293 }
01f2e4ea
SF		 2294 }
2295
6fdfa970 2296 err = enic_dev_init(enic);
01f2e4ea
SF		 2297 if (err) {
2298 printk(KERN_ERR PFX
6fdfa970 2299 "Device initialization failed, aborting.\n");
01f2e4ea
SF		 2300 goto err_out_dev_close;
2301 }
2302
01f2e4ea
SF		 2303 /* Setup notification timer, HW reset task, and locks
2304 */
2305
2306 init_timer(&enic->notify_timer);
2307 enic->notify_timer.function = enic_notify_timer;
2308 enic->notify_timer.data = (unsigned long)enic;
2309
2310 INIT_WORK(&enic->reset, enic_reset);
2311
2312 for (i = 0; i < enic->wq_count; i++)
2313 spin_lock_init(&enic->wq_lock[i]);
2314
2315 spin_lock_init(&enic->devcmd_lock);
2316
2317 /* Register net device
2318 */
2319
2320 enic->port_mtu = enic->config.mtu;
2321 (void)enic_change_mtu(netdev, enic->port_mtu);
2322
2323 err = enic_set_mac_addr(netdev, enic->mac_addr);
2324 if (err) {
2325 printk(KERN_ERR PFX
4b75a442 2326 "Invalid MAC address, aborting.\n");
6fdfa970 2327 goto err_out_dev_deinit;
01f2e4ea
SF		 2328 }
2329
7c844599
SF		 2330 enic->tx_coalesce_usecs = enic->config.intr_timer_usec;
2331 enic->rx_coalesce_usecs = enic->tx_coalesce_usecs;
2332
f8bd9091
SF		 2333 if (enic_is_dynamic(enic))
2334 netdev->netdev_ops = &enic_netdev_dynamic_ops;
2335 else
2336 netdev->netdev_ops = &enic_netdev_ops;
2337
01f2e4ea
SF		 2338 netdev->watchdog_timeo = 2 * HZ;
2339 netdev->ethtool_ops = &enic_ethtool_ops;
01f2e4ea 2340
73c1ea9b 2341 netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
01f2e4ea
SF		 2342 if (ENIC_SETTING(enic, TXCSUM))
2343 netdev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
2344 if (ENIC_SETTING(enic, TSO))
2345 netdev->features |= NETIF_F_TSO |
2346 NETIF_F_TSO6 | NETIF_F_TSO_ECN;
86ca9db7 2347 if (ENIC_SETTING(enic, LRO))
88132f55 2348 netdev->features |= NETIF_F_GRO;
01f2e4ea
SF		 2349 if (using_dac)
2350 netdev->features |= NETIF_F_HIGHDMA;
2351
01f2e4ea
SF		 2352 enic->csum_rx_enabled = ENIC_SETTING(enic, RXCSUM);
2353
01f2e4ea
SF		 2354 err = register_netdev(netdev);
2355 if (err) {
2356 printk(KERN_ERR PFX
4b75a442 2357 "Cannot register net device, aborting.\n");
6fdfa970 2358 goto err_out_dev_deinit;
01f2e4ea
SF		 2359 }
2360
2361 return 0;
2362
6fdfa970
SF		 2363err_out_dev_deinit:
2364 enic_dev_deinit(enic);
01f2e4ea
SF		 2365err_out_dev_close:
2366 vnic_dev_close(enic->vdev);
2367err_out_vnic_unregister:
01f2e4ea
SF		 2368 vnic_dev_unregister(enic->vdev);
2369err_out_iounmap:
2370 enic_iounmap(enic);
2371err_out_release_regions:
2372 pci_release_regions(pdev);
2373err_out_disable_device:
2374 pci_disable_device(pdev);
2375err_out_free_netdev:
2376 pci_set_drvdata(pdev, NULL);
2377 free_netdev(netdev);
2378
2379 return err;
2380}
2381
2382static void __devexit enic_remove(struct pci_dev *pdev)
2383{
2384 struct net_device *netdev = pci_get_drvdata(pdev);
2385
2386 if (netdev) {
2387 struct enic *enic = netdev_priv(netdev);
2388
2389 flush_scheduled_work();
2390 unregister_netdev(netdev);
6fdfa970 2391 enic_dev_deinit(enic);
01f2e4ea 2392 vnic_dev_close(enic->vdev);
01f2e4ea
SF		 2393 vnic_dev_unregister(enic->vdev);
2394 enic_iounmap(enic);
2395 pci_release_regions(pdev);
2396 pci_disable_device(pdev);
2397 pci_set_drvdata(pdev, NULL);
2398 free_netdev(netdev);
2399 }
2400}
2401
2402static struct pci_driver enic_driver = {
2403 .name = DRV_NAME,
2404 .id_table = enic_id_table,
2405 .probe = enic_probe,
2406 .remove = __devexit_p(enic_remove),
2407};
2408
2409static int __init enic_init_module(void)
2410{
2411 printk(KERN_INFO PFX "%s, ver %s\n", DRV_DESCRIPTION, DRV_VERSION);
2412
2413 return pci_register_driver(&enic_driver);
2414}
2415
2416static void __exit enic_cleanup_module(void)
2417{
2418 pci_unregister_driver(&enic_driver);
2419}
2420
2421module_init(enic_init_module);
2422module_exit(enic_cleanup_module);
Ubuntu Focal Linux kernel mirror