2 * Copyright 2008 Cisco Systems, Inc. All rights reserved.
3 * Copyright 2007 Nuova Systems, Inc. All rights reserved.
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.
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
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>
32 #include <linux/ethtool.h>
35 #include <linux/ipv6.h>
36 #include <linux/tcp.h>
38 #include "cq_enet_desc.h"
40 #include "vnic_intr.h"
41 #include "vnic_stats.h"
45 #define ENIC_NOTIFY_TIMER_PERIOD (2 * HZ)
47 /* Supported devices */
48 static struct pci_device_id enic_id_table
[] = {
49 { PCI_VDEVICE(CISCO
, 0x0043) },
50 { 0, } /* end of table */
53 MODULE_DESCRIPTION(DRV_DESCRIPTION
);
54 MODULE_AUTHOR("Scott Feldman <scofeldm@cisco.com>");
55 MODULE_LICENSE("GPL");
56 MODULE_VERSION(DRV_VERSION
);
57 MODULE_DEVICE_TABLE(pci
, enic_id_table
);
60 char name
[ETH_GSTRING_LEN
];
64 #define ENIC_TX_STAT(stat) \
65 { .name = #stat, .offset = offsetof(struct vnic_tx_stats, stat) / 8 }
66 #define ENIC_RX_STAT(stat) \
67 { .name = #stat, .offset = offsetof(struct vnic_rx_stats, stat) / 8 }
69 static const struct enic_stat enic_tx_stats
[] = {
70 ENIC_TX_STAT(tx_frames_ok
),
71 ENIC_TX_STAT(tx_unicast_frames_ok
),
72 ENIC_TX_STAT(tx_multicast_frames_ok
),
73 ENIC_TX_STAT(tx_broadcast_frames_ok
),
74 ENIC_TX_STAT(tx_bytes_ok
),
75 ENIC_TX_STAT(tx_unicast_bytes_ok
),
76 ENIC_TX_STAT(tx_multicast_bytes_ok
),
77 ENIC_TX_STAT(tx_broadcast_bytes_ok
),
78 ENIC_TX_STAT(tx_drops
),
79 ENIC_TX_STAT(tx_errors
),
83 static const struct enic_stat enic_rx_stats
[] = {
84 ENIC_RX_STAT(rx_frames_ok
),
85 ENIC_RX_STAT(rx_frames_total
),
86 ENIC_RX_STAT(rx_unicast_frames_ok
),
87 ENIC_RX_STAT(rx_multicast_frames_ok
),
88 ENIC_RX_STAT(rx_broadcast_frames_ok
),
89 ENIC_RX_STAT(rx_bytes_ok
),
90 ENIC_RX_STAT(rx_unicast_bytes_ok
),
91 ENIC_RX_STAT(rx_multicast_bytes_ok
),
92 ENIC_RX_STAT(rx_broadcast_bytes_ok
),
93 ENIC_RX_STAT(rx_drop
),
94 ENIC_RX_STAT(rx_no_bufs
),
95 ENIC_RX_STAT(rx_errors
),
97 ENIC_RX_STAT(rx_crc_errors
),
98 ENIC_RX_STAT(rx_frames_64
),
99 ENIC_RX_STAT(rx_frames_127
),
100 ENIC_RX_STAT(rx_frames_255
),
101 ENIC_RX_STAT(rx_frames_511
),
102 ENIC_RX_STAT(rx_frames_1023
),
103 ENIC_RX_STAT(rx_frames_1518
),
104 ENIC_RX_STAT(rx_frames_to_max
),
107 static const unsigned int enic_n_tx_stats
= ARRAY_SIZE(enic_tx_stats
);
108 static const unsigned int enic_n_rx_stats
= ARRAY_SIZE(enic_rx_stats
);
110 static int enic_get_settings(struct net_device
*netdev
,
111 struct ethtool_cmd
*ecmd
)
113 struct enic
*enic
= netdev_priv(netdev
);
115 ecmd
->supported
= (SUPPORTED_10000baseT_Full
| SUPPORTED_FIBRE
);
116 ecmd
->advertising
= (ADVERTISED_10000baseT_Full
| ADVERTISED_FIBRE
);
117 ecmd
->port
= PORT_FIBRE
;
118 ecmd
->transceiver
= XCVR_EXTERNAL
;
120 if (netif_carrier_ok(netdev
)) {
121 ecmd
->speed
= vnic_dev_port_speed(enic
->vdev
);
122 ecmd
->duplex
= DUPLEX_FULL
;
128 ecmd
->autoneg
= AUTONEG_DISABLE
;
133 static void enic_get_drvinfo(struct net_device
*netdev
,
134 struct ethtool_drvinfo
*drvinfo
)
136 struct enic
*enic
= netdev_priv(netdev
);
137 struct vnic_devcmd_fw_info
*fw_info
;
139 spin_lock(&enic
->devcmd_lock
);
140 vnic_dev_fw_info(enic
->vdev
, &fw_info
);
141 spin_unlock(&enic
->devcmd_lock
);
143 strncpy(drvinfo
->driver
, DRV_NAME
, sizeof(drvinfo
->driver
));
144 strncpy(drvinfo
->version
, DRV_VERSION
, sizeof(drvinfo
->version
));
145 strncpy(drvinfo
->fw_version
, fw_info
->fw_version
,
146 sizeof(drvinfo
->fw_version
));
147 strncpy(drvinfo
->bus_info
, pci_name(enic
->pdev
),
148 sizeof(drvinfo
->bus_info
));
151 static void enic_get_strings(struct net_device
*netdev
, u32 stringset
, u8
*data
)
157 for (i
= 0; i
< enic_n_tx_stats
; i
++) {
158 memcpy(data
, enic_tx_stats
[i
].name
, ETH_GSTRING_LEN
);
159 data
+= ETH_GSTRING_LEN
;
161 for (i
= 0; i
< enic_n_rx_stats
; i
++) {
162 memcpy(data
, enic_rx_stats
[i
].name
, ETH_GSTRING_LEN
);
163 data
+= ETH_GSTRING_LEN
;
169 static int enic_get_sset_count(struct net_device
*netdev
, int sset
)
173 return enic_n_tx_stats
+ enic_n_rx_stats
;
179 static void enic_get_ethtool_stats(struct net_device
*netdev
,
180 struct ethtool_stats
*stats
, u64
*data
)
182 struct enic
*enic
= netdev_priv(netdev
);
183 struct vnic_stats
*vstats
;
186 spin_lock(&enic
->devcmd_lock
);
187 vnic_dev_stats_dump(enic
->vdev
, &vstats
);
188 spin_unlock(&enic
->devcmd_lock
);
190 for (i
= 0; i
< enic_n_tx_stats
; i
++)
191 *(data
++) = ((u64
*)&vstats
->tx
)[enic_tx_stats
[i
].offset
];
192 for (i
= 0; i
< enic_n_rx_stats
; i
++)
193 *(data
++) = ((u64
*)&vstats
->rx
)[enic_rx_stats
[i
].offset
];
196 static u32
enic_get_rx_csum(struct net_device
*netdev
)
198 struct enic
*enic
= netdev_priv(netdev
);
199 return enic
->csum_rx_enabled
;
202 static int enic_set_rx_csum(struct net_device
*netdev
, u32 data
)
204 struct enic
*enic
= netdev_priv(netdev
);
206 if (data
&& !ENIC_SETTING(enic
, RXCSUM
))
209 enic
->csum_rx_enabled
= !!data
;
214 static int enic_set_tx_csum(struct net_device
*netdev
, u32 data
)
216 struct enic
*enic
= netdev_priv(netdev
);
218 if (data
&& !ENIC_SETTING(enic
, TXCSUM
))
222 netdev
->features
|= NETIF_F_HW_CSUM
;
224 netdev
->features
&= ~NETIF_F_HW_CSUM
;
229 static int enic_set_tso(struct net_device
*netdev
, u32 data
)
231 struct enic
*enic
= netdev_priv(netdev
);
233 if (data
&& !ENIC_SETTING(enic
, TSO
))
238 NETIF_F_TSO
| NETIF_F_TSO6
| NETIF_F_TSO_ECN
;
241 ~(NETIF_F_TSO
| NETIF_F_TSO6
| NETIF_F_TSO_ECN
);
246 static u32
enic_get_msglevel(struct net_device
*netdev
)
248 struct enic
*enic
= netdev_priv(netdev
);
249 return enic
->msg_enable
;
252 static void enic_set_msglevel(struct net_device
*netdev
, u32 value
)
254 struct enic
*enic
= netdev_priv(netdev
);
255 enic
->msg_enable
= value
;
258 static struct ethtool_ops enic_ethtool_ops
= {
259 .get_settings
= enic_get_settings
,
260 .get_drvinfo
= enic_get_drvinfo
,
261 .get_msglevel
= enic_get_msglevel
,
262 .set_msglevel
= enic_set_msglevel
,
263 .get_link
= ethtool_op_get_link
,
264 .get_strings
= enic_get_strings
,
265 .get_sset_count
= enic_get_sset_count
,
266 .get_ethtool_stats
= enic_get_ethtool_stats
,
267 .get_rx_csum
= enic_get_rx_csum
,
268 .set_rx_csum
= enic_set_rx_csum
,
269 .get_tx_csum
= ethtool_op_get_tx_csum
,
270 .set_tx_csum
= enic_set_tx_csum
,
271 .get_sg
= ethtool_op_get_sg
,
272 .set_sg
= ethtool_op_set_sg
,
273 .get_tso
= ethtool_op_get_tso
,
274 .set_tso
= enic_set_tso
,
277 static void enic_free_wq_buf(struct vnic_wq
*wq
, struct vnic_wq_buf
*buf
)
279 struct enic
*enic
= vnic_dev_priv(wq
->vdev
);
282 pci_unmap_single(enic
->pdev
, buf
->dma_addr
,
283 buf
->len
, PCI_DMA_TODEVICE
);
285 pci_unmap_page(enic
->pdev
, buf
->dma_addr
,
286 buf
->len
, PCI_DMA_TODEVICE
);
289 dev_kfree_skb_any(buf
->os_buf
);
292 static void enic_wq_free_buf(struct vnic_wq
*wq
,
293 struct cq_desc
*cq_desc
, struct vnic_wq_buf
*buf
, void *opaque
)
295 enic_free_wq_buf(wq
, buf
);
298 static int enic_wq_service(struct vnic_dev
*vdev
, struct cq_desc
*cq_desc
,
299 u8 type
, u16 q_number
, u16 completed_index
, void *opaque
)
301 struct enic
*enic
= vnic_dev_priv(vdev
);
303 spin_lock(&enic
->wq_lock
[q_number
]);
305 vnic_wq_service(&enic
->wq
[q_number
], cq_desc
,
306 completed_index
, enic_wq_free_buf
,
309 if (netif_queue_stopped(enic
->netdev
) &&
310 vnic_wq_desc_avail(&enic
->wq
[q_number
]) >= MAX_SKB_FRAGS
+ 1)
311 netif_wake_queue(enic
->netdev
);
313 spin_unlock(&enic
->wq_lock
[q_number
]);
318 static void enic_log_q_error(struct enic
*enic
)
323 for (i
= 0; i
< enic
->wq_count
; i
++) {
324 error_status
= vnic_wq_error_status(&enic
->wq
[i
]);
326 printk(KERN_ERR PFX
"%s: WQ[%d] error_status %d\n",
327 enic
->netdev
->name
, i
, error_status
);
330 for (i
= 0; i
< enic
->rq_count
; i
++) {
331 error_status
= vnic_rq_error_status(&enic
->rq
[i
]);
333 printk(KERN_ERR PFX
"%s: RQ[%d] error_status %d\n",
334 enic
->netdev
->name
, i
, error_status
);
338 static void enic_link_check(struct enic
*enic
)
340 int link_status
= vnic_dev_link_status(enic
->vdev
);
341 int carrier_ok
= netif_carrier_ok(enic
->netdev
);
343 if (link_status
&& !carrier_ok
) {
344 printk(KERN_INFO PFX
"%s: Link UP\n", enic
->netdev
->name
);
345 netif_carrier_on(enic
->netdev
);
346 } else if (!link_status
&& carrier_ok
) {
347 printk(KERN_INFO PFX
"%s: Link DOWN\n", enic
->netdev
->name
);
348 netif_carrier_off(enic
->netdev
);
352 static void enic_mtu_check(struct enic
*enic
)
354 u32 mtu
= vnic_dev_mtu(enic
->vdev
);
356 if (mtu
!= enic
->port_mtu
) {
357 if (mtu
< enic
->netdev
->mtu
)
358 printk(KERN_WARNING PFX
359 "%s: interface MTU (%d) set higher "
360 "than switch port MTU (%d)\n",
361 enic
->netdev
->name
, enic
->netdev
->mtu
, mtu
);
362 enic
->port_mtu
= mtu
;
366 static void enic_msglvl_check(struct enic
*enic
)
368 u32 msg_enable
= vnic_dev_msg_lvl(enic
->vdev
);
370 if (msg_enable
!= enic
->msg_enable
) {
371 printk(KERN_INFO PFX
"%s: msg lvl changed from 0x%x to 0x%x\n",
372 enic
->netdev
->name
, enic
->msg_enable
, msg_enable
);
373 enic
->msg_enable
= msg_enable
;
377 static void enic_notify_check(struct enic
*enic
)
379 enic_msglvl_check(enic
);
380 enic_mtu_check(enic
);
381 enic_link_check(enic
);
384 #define ENIC_TEST_INTR(pba, i) (pba & (1 << i))
386 static irqreturn_t
enic_isr_legacy(int irq
, void *data
)
388 struct net_device
*netdev
= data
;
389 struct enic
*enic
= netdev_priv(netdev
);
392 vnic_intr_mask(&enic
->intr
[ENIC_INTX_WQ_RQ
]);
394 pba
= vnic_intr_legacy_pba(enic
->legacy_pba
);
396 vnic_intr_unmask(&enic
->intr
[ENIC_INTX_WQ_RQ
]);
397 return IRQ_NONE
; /* not our interrupt */
400 if (ENIC_TEST_INTR(pba
, ENIC_INTX_NOTIFY
))
401 enic_notify_check(enic
);
403 if (ENIC_TEST_INTR(pba
, ENIC_INTX_ERR
)) {
404 enic_log_q_error(enic
);
405 /* schedule recovery from WQ/RQ error */
406 schedule_work(&enic
->reset
);
410 if (ENIC_TEST_INTR(pba
, ENIC_INTX_WQ_RQ
)) {
411 if (netif_rx_schedule_prep(netdev
, &enic
->napi
))
412 __netif_rx_schedule(netdev
, &enic
->napi
);
414 vnic_intr_unmask(&enic
->intr
[ENIC_INTX_WQ_RQ
]);
420 static irqreturn_t
enic_isr_msi(int irq
, void *data
)
422 struct enic
*enic
= data
;
424 /* With MSI, there is no sharing of interrupts, so this is
425 * our interrupt and there is no need to ack it. The device
426 * is not providing per-vector masking, so the OS will not
427 * write to PCI config space to mask/unmask the interrupt.
428 * We're using mask_on_assertion for MSI, so the device
429 * automatically masks the interrupt when the interrupt is
430 * generated. Later, when exiting polling, the interrupt
431 * will be unmasked (see enic_poll).
433 * Also, the device uses the same PCIe Traffic Class (TC)
434 * for Memory Write data and MSI, so there are no ordering
435 * issues; the MSI will always arrive at the Root Complex
436 * _after_ corresponding Memory Writes (i.e. descriptor
440 netif_rx_schedule(enic
->netdev
, &enic
->napi
);
445 static irqreturn_t
enic_isr_msix_rq(int irq
, void *data
)
447 struct enic
*enic
= data
;
449 /* schedule NAPI polling for RQ cleanup */
450 netif_rx_schedule(enic
->netdev
, &enic
->napi
);
455 static irqreturn_t
enic_isr_msix_wq(int irq
, void *data
)
457 struct enic
*enic
= data
;
458 unsigned int wq_work_to_do
= -1; /* no limit */
459 unsigned int wq_work_done
;
461 wq_work_done
= vnic_cq_service(&enic
->cq
[ENIC_CQ_WQ
],
462 wq_work_to_do
, enic_wq_service
, NULL
);
464 vnic_intr_return_credits(&enic
->intr
[ENIC_MSIX_WQ
],
467 1 /* reset intr timer */);
472 static irqreturn_t
enic_isr_msix_err(int irq
, void *data
)
474 struct enic
*enic
= data
;
476 enic_log_q_error(enic
);
478 /* schedule recovery from WQ/RQ error */
479 schedule_work(&enic
->reset
);
484 static irqreturn_t
enic_isr_msix_notify(int irq
, void *data
)
486 struct enic
*enic
= data
;
488 enic_notify_check(enic
);
489 vnic_intr_unmask(&enic
->intr
[ENIC_MSIX_NOTIFY
]);
494 static inline void enic_queue_wq_skb_cont(struct enic
*enic
,
495 struct vnic_wq
*wq
, struct sk_buff
*skb
,
496 unsigned int len_left
)
500 /* Queue additional data fragments */
501 for (frag
= skb_shinfo(skb
)->frags
; len_left
; frag
++) {
502 len_left
-= frag
->size
;
503 enic_queue_wq_desc_cont(wq
, skb
,
504 pci_map_page(enic
->pdev
, frag
->page
,
505 frag
->page_offset
, frag
->size
,
508 (len_left
== 0)); /* EOP? */
512 static inline void enic_queue_wq_skb_vlan(struct enic
*enic
,
513 struct vnic_wq
*wq
, struct sk_buff
*skb
,
514 int vlan_tag_insert
, unsigned int vlan_tag
)
516 unsigned int head_len
= skb_headlen(skb
);
517 unsigned int len_left
= skb
->len
- head_len
;
518 int eop
= (len_left
== 0);
520 /* Queue the main skb fragment */
521 enic_queue_wq_desc(wq
, skb
,
522 pci_map_single(enic
->pdev
, skb
->data
,
523 head_len
, PCI_DMA_TODEVICE
),
525 vlan_tag_insert
, vlan_tag
,
529 enic_queue_wq_skb_cont(enic
, wq
, skb
, len_left
);
532 static inline void enic_queue_wq_skb_csum_l4(struct enic
*enic
,
533 struct vnic_wq
*wq
, struct sk_buff
*skb
,
534 int vlan_tag_insert
, unsigned int vlan_tag
)
536 unsigned int head_len
= skb_headlen(skb
);
537 unsigned int len_left
= skb
->len
- head_len
;
538 unsigned int hdr_len
= skb_transport_offset(skb
);
539 unsigned int csum_offset
= hdr_len
+ skb
->csum_offset
;
540 int eop
= (len_left
== 0);
542 /* Queue the main skb fragment */
543 enic_queue_wq_desc_csum_l4(wq
, skb
,
544 pci_map_single(enic
->pdev
, skb
->data
,
545 head_len
, PCI_DMA_TODEVICE
),
549 vlan_tag_insert
, vlan_tag
,
553 enic_queue_wq_skb_cont(enic
, wq
, skb
, len_left
);
556 static inline void enic_queue_wq_skb_tso(struct enic
*enic
,
557 struct vnic_wq
*wq
, struct sk_buff
*skb
, unsigned int mss
,
558 int vlan_tag_insert
, unsigned int vlan_tag
)
560 unsigned int head_len
= skb_headlen(skb
);
561 unsigned int len_left
= skb
->len
- head_len
;
562 unsigned int hdr_len
= skb_transport_offset(skb
) + tcp_hdrlen(skb
);
563 int eop
= (len_left
== 0);
565 /* Preload TCP csum field with IP pseudo hdr calculated
566 * with IP length set to zero. HW will later add in length
567 * to each TCP segment resulting from the TSO.
570 if (skb
->protocol
== __constant_htons(ETH_P_IP
)) {
571 ip_hdr(skb
)->check
= 0;
572 tcp_hdr(skb
)->check
= ~csum_tcpudp_magic(ip_hdr(skb
)->saddr
,
573 ip_hdr(skb
)->daddr
, 0, IPPROTO_TCP
, 0);
574 } else if (skb
->protocol
== __constant_htons(ETH_P_IPV6
)) {
575 tcp_hdr(skb
)->check
= ~csum_ipv6_magic(&ipv6_hdr(skb
)->saddr
,
576 &ipv6_hdr(skb
)->daddr
, 0, IPPROTO_TCP
, 0);
579 /* Queue the main skb fragment */
580 enic_queue_wq_desc_tso(wq
, skb
,
581 pci_map_single(enic
->pdev
, skb
->data
,
582 head_len
, PCI_DMA_TODEVICE
),
585 vlan_tag_insert
, vlan_tag
,
589 enic_queue_wq_skb_cont(enic
, wq
, skb
, len_left
);
592 static inline void enic_queue_wq_skb(struct enic
*enic
,
593 struct vnic_wq
*wq
, struct sk_buff
*skb
)
595 unsigned int mss
= skb_shinfo(skb
)->gso_size
;
596 unsigned int vlan_tag
= 0;
597 int vlan_tag_insert
= 0;
599 if (enic
->vlan_group
&& vlan_tx_tag_present(skb
)) {
600 /* VLAN tag from trunking driver */
602 vlan_tag
= vlan_tx_tag_get(skb
);
606 enic_queue_wq_skb_tso(enic
, wq
, skb
, mss
,
607 vlan_tag_insert
, vlan_tag
);
608 else if (skb
->ip_summed
== CHECKSUM_PARTIAL
)
609 enic_queue_wq_skb_csum_l4(enic
, wq
, skb
,
610 vlan_tag_insert
, vlan_tag
);
612 enic_queue_wq_skb_vlan(enic
, wq
, skb
,
613 vlan_tag_insert
, vlan_tag
);
616 /* netif_tx_lock held, process context with BHs disabled */
617 static int enic_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*netdev
)
619 struct enic
*enic
= netdev_priv(netdev
);
620 struct vnic_wq
*wq
= &enic
->wq
[0];
628 /* Non-TSO sends must fit within ENIC_NON_TSO_MAX_DESC descs,
629 * which is very likely. In the off chance it's going to take
630 * more than * ENIC_NON_TSO_MAX_DESC, linearize the skb.
633 if (skb_shinfo(skb
)->gso_size
== 0 &&
634 skb_shinfo(skb
)->nr_frags
+ 1 > ENIC_NON_TSO_MAX_DESC
&&
635 skb_linearize(skb
)) {
640 spin_lock_irqsave(&enic
->wq_lock
[0], flags
);
642 if (vnic_wq_desc_avail(wq
) < skb_shinfo(skb
)->nr_frags
+ 1) {
643 netif_stop_queue(netdev
);
644 /* This is a hard error, log it */
645 printk(KERN_ERR PFX
"%s: BUG! Tx ring full when "
646 "queue awake!\n", netdev
->name
);
647 spin_unlock_irqrestore(&enic
->wq_lock
[0], flags
);
648 return NETDEV_TX_BUSY
;
651 enic_queue_wq_skb(enic
, wq
, skb
);
653 if (vnic_wq_desc_avail(wq
) < MAX_SKB_FRAGS
+ 1)
654 netif_stop_queue(netdev
);
656 netdev
->trans_start
= jiffies
;
658 spin_unlock_irqrestore(&enic
->wq_lock
[0], flags
);
663 /* dev_base_lock rwlock held, nominally process context */
664 static struct net_device_stats
*enic_get_stats(struct net_device
*netdev
)
666 struct enic
*enic
= netdev_priv(netdev
);
667 struct net_device_stats
*net_stats
= &netdev
->stats
;
668 struct vnic_stats
*stats
;
670 spin_lock(&enic
->devcmd_lock
);
671 vnic_dev_stats_dump(enic
->vdev
, &stats
);
672 spin_unlock(&enic
->devcmd_lock
);
674 net_stats
->tx_packets
= stats
->tx
.tx_frames_ok
;
675 net_stats
->tx_bytes
= stats
->tx
.tx_bytes_ok
;
676 net_stats
->tx_errors
= stats
->tx
.tx_errors
;
677 net_stats
->tx_dropped
= stats
->tx
.tx_drops
;
679 net_stats
->rx_packets
= stats
->rx
.rx_frames_ok
;
680 net_stats
->rx_bytes
= stats
->rx
.rx_bytes_ok
;
681 net_stats
->rx_errors
= stats
->rx
.rx_errors
;
682 net_stats
->multicast
= stats
->rx
.rx_multicast_frames_ok
;
683 net_stats
->rx_crc_errors
= stats
->rx
.rx_crc_errors
;
684 net_stats
->rx_dropped
= stats
->rx
.rx_no_bufs
;
689 static void enic_reset_mcaddrs(struct enic
*enic
)
694 static int enic_set_mac_addr(struct net_device
*netdev
, char *addr
)
696 if (!is_valid_ether_addr(addr
))
697 return -EADDRNOTAVAIL
;
699 memcpy(netdev
->dev_addr
, addr
, netdev
->addr_len
);
704 /* netif_tx_lock held, BHs disabled */
705 static void enic_set_multicast_list(struct net_device
*netdev
)
707 struct enic
*enic
= netdev_priv(netdev
);
708 struct dev_mc_list
*list
= netdev
->mc_list
;
710 int multicast
= (netdev
->flags
& IFF_MULTICAST
) ? 1 : 0;
711 int broadcast
= (netdev
->flags
& IFF_BROADCAST
) ? 1 : 0;
712 int promisc
= (netdev
->flags
& IFF_PROMISC
) ? 1 : 0;
713 int allmulti
= (netdev
->flags
& IFF_ALLMULTI
) ||
714 (netdev
->mc_count
> ENIC_MULTICAST_PERFECT_FILTERS
);
715 u8 mc_addr
[ENIC_MULTICAST_PERFECT_FILTERS
][ETH_ALEN
];
716 unsigned int mc_count
= netdev
->mc_count
;
719 if (mc_count
> ENIC_MULTICAST_PERFECT_FILTERS
)
720 mc_count
= ENIC_MULTICAST_PERFECT_FILTERS
;
722 spin_lock(&enic
->devcmd_lock
);
724 vnic_dev_packet_filter(enic
->vdev
, directed
,
725 multicast
, broadcast
, promisc
, allmulti
);
727 /* Is there an easier way? Trying to minimize to
728 * calls to add/del multicast addrs. We keep the
729 * addrs from the last call in enic->mc_addr and
730 * look for changes to add/del.
733 for (i
= 0; list
&& i
< mc_count
; i
++) {
734 memcpy(mc_addr
[i
], list
->dmi_addr
, ETH_ALEN
);
738 for (i
= 0; i
< enic
->mc_count
; i
++) {
739 for (j
= 0; j
< mc_count
; j
++)
740 if (compare_ether_addr(enic
->mc_addr
[i
],
744 enic_del_multicast_addr(enic
, enic
->mc_addr
[i
]);
747 for (i
= 0; i
< mc_count
; i
++) {
748 for (j
= 0; j
< enic
->mc_count
; j
++)
749 if (compare_ether_addr(mc_addr
[i
],
750 enic
->mc_addr
[j
]) == 0)
752 if (j
== enic
->mc_count
)
753 enic_add_multicast_addr(enic
, mc_addr
[i
]);
756 /* Save the list to compare against next time
759 for (i
= 0; i
< mc_count
; i
++)
760 memcpy(enic
->mc_addr
[i
], mc_addr
[i
], ETH_ALEN
);
762 enic
->mc_count
= mc_count
;
764 spin_unlock(&enic
->devcmd_lock
);
767 /* rtnl lock is held */
768 static void enic_vlan_rx_register(struct net_device
*netdev
,
769 struct vlan_group
*vlan_group
)
771 struct enic
*enic
= netdev_priv(netdev
);
772 enic
->vlan_group
= vlan_group
;
775 /* rtnl lock is held */
776 static void enic_vlan_rx_add_vid(struct net_device
*netdev
, u16 vid
)
778 struct enic
*enic
= netdev_priv(netdev
);
780 spin_lock(&enic
->devcmd_lock
);
781 enic_add_vlan(enic
, vid
);
782 spin_unlock(&enic
->devcmd_lock
);
785 /* rtnl lock is held */
786 static void enic_vlan_rx_kill_vid(struct net_device
*netdev
, u16 vid
)
788 struct enic
*enic
= netdev_priv(netdev
);
790 spin_lock(&enic
->devcmd_lock
);
791 enic_del_vlan(enic
, vid
);
792 spin_unlock(&enic
->devcmd_lock
);
795 /* netif_tx_lock held, BHs disabled */
796 static void enic_tx_timeout(struct net_device
*netdev
)
798 struct enic
*enic
= netdev_priv(netdev
);
799 schedule_work(&enic
->reset
);
802 static void enic_free_rq_buf(struct vnic_rq
*rq
, struct vnic_rq_buf
*buf
)
804 struct enic
*enic
= vnic_dev_priv(rq
->vdev
);
809 pci_unmap_single(enic
->pdev
, buf
->dma_addr
,
810 buf
->len
, PCI_DMA_FROMDEVICE
);
811 dev_kfree_skb_any(buf
->os_buf
);
814 static inline struct sk_buff
*enic_rq_alloc_skb(unsigned int size
)
818 skb
= dev_alloc_skb(size
+ NET_IP_ALIGN
);
821 skb_reserve(skb
, NET_IP_ALIGN
);
826 static int enic_rq_alloc_buf(struct vnic_rq
*rq
)
828 struct enic
*enic
= vnic_dev_priv(rq
->vdev
);
830 unsigned int len
= enic
->netdev
->mtu
+ ETH_HLEN
;
831 unsigned int os_buf_index
= 0;
834 skb
= enic_rq_alloc_skb(len
);
838 dma_addr
= pci_map_single(enic
->pdev
, skb
->data
,
839 len
, PCI_DMA_FROMDEVICE
);
841 enic_queue_rq_desc(rq
, skb
, os_buf_index
,
847 static int enic_get_skb_header(struct sk_buff
*skb
, void **iphdr
,
848 void **tcph
, u64
*hdr_flags
, void *priv
)
850 struct cq_enet_rq_desc
*cq_desc
= priv
;
854 u8 type
, color
, eop
, sop
, ingress_port
, vlan_stripped
;
855 u8 fcoe
, fcoe_sof
, fcoe_fc_crc_ok
, fcoe_enc_error
, fcoe_eof
;
856 u8 tcp_udp_csum_ok
, udp
, tcp
, ipv4_csum_ok
;
857 u8 ipv6
, ipv4
, ipv4_fragment
, fcs_ok
, rss_type
, csum_not_calc
;
859 u16 q_number
, completed_index
, bytes_written
, vlan
, checksum
;
862 cq_enet_rq_desc_dec(cq_desc
,
863 &type
, &color
, &q_number
, &completed_index
,
864 &ingress_port
, &fcoe
, &eop
, &sop
, &rss_type
,
865 &csum_not_calc
, &rss_hash
, &bytes_written
,
866 &packet_error
, &vlan_stripped
, &vlan
, &checksum
,
867 &fcoe_sof
, &fcoe_fc_crc_ok
, &fcoe_enc_error
,
868 &fcoe_eof
, &tcp_udp_csum_ok
, &udp
, &tcp
,
869 &ipv4_csum_ok
, &ipv6
, &ipv4
, &ipv4_fragment
,
872 if (!(ipv4
&& tcp
&& !ipv4_fragment
))
875 skb_reset_network_header(skb
);
878 ip_len
= ip_hdrlen(skb
);
879 skb_set_transport_header(skb
, ip_len
);
881 /* check if ip header and tcp header are complete */
882 if (ntohs(iph
->tot_len
) < ip_len
+ tcp_hdrlen(skb
))
885 *hdr_flags
= LRO_IPV4
| LRO_TCP
;
886 *tcph
= tcp_hdr(skb
);
892 static void enic_rq_indicate_buf(struct vnic_rq
*rq
,
893 struct cq_desc
*cq_desc
, struct vnic_rq_buf
*buf
,
894 int skipped
, void *opaque
)
896 struct enic
*enic
= vnic_dev_priv(rq
->vdev
);
899 u8 type
, color
, eop
, sop
, ingress_port
, vlan_stripped
;
900 u8 fcoe
, fcoe_sof
, fcoe_fc_crc_ok
, fcoe_enc_error
, fcoe_eof
;
901 u8 tcp_udp_csum_ok
, udp
, tcp
, ipv4_csum_ok
;
902 u8 ipv6
, ipv4
, ipv4_fragment
, fcs_ok
, rss_type
, csum_not_calc
;
904 u16 q_number
, completed_index
, bytes_written
, vlan
, checksum
;
911 prefetch(skb
->data
- NET_IP_ALIGN
);
912 pci_unmap_single(enic
->pdev
, buf
->dma_addr
,
913 buf
->len
, PCI_DMA_FROMDEVICE
);
915 cq_enet_rq_desc_dec((struct cq_enet_rq_desc
*)cq_desc
,
916 &type
, &color
, &q_number
, &completed_index
,
917 &ingress_port
, &fcoe
, &eop
, &sop
, &rss_type
,
918 &csum_not_calc
, &rss_hash
, &bytes_written
,
919 &packet_error
, &vlan_stripped
, &vlan
, &checksum
,
920 &fcoe_sof
, &fcoe_fc_crc_ok
, &fcoe_enc_error
,
921 &fcoe_eof
, &tcp_udp_csum_ok
, &udp
, &tcp
,
922 &ipv4_csum_ok
, &ipv6
, &ipv4
, &ipv4_fragment
,
927 if (bytes_written
> 0 && !fcs_ok
) {
930 "%s: packet error: bad FCS\n",
934 dev_kfree_skb_any(skb
);
939 if (eop
&& bytes_written
> 0) {
944 skb_put(skb
, bytes_written
);
945 skb
->protocol
= eth_type_trans(skb
, enic
->netdev
);
947 if (enic
->csum_rx_enabled
&& !csum_not_calc
) {
948 skb
->csum
= htons(checksum
);
949 skb
->ip_summed
= CHECKSUM_COMPLETE
;
952 skb
->dev
= enic
->netdev
;
953 enic
->netdev
->last_rx
= jiffies
;
955 if (enic
->vlan_group
&& vlan_stripped
) {
957 if (ENIC_SETTING(enic
, LRO
) && ipv4
)
958 lro_vlan_hwaccel_receive_skb(&enic
->lro_mgr
,
959 skb
, enic
->vlan_group
,
962 vlan_hwaccel_receive_skb(skb
,
963 enic
->vlan_group
, vlan
);
967 if (ENIC_SETTING(enic
, LRO
) && ipv4
)
968 lro_receive_skb(&enic
->lro_mgr
, skb
, cq_desc
);
970 netif_receive_skb(skb
);
979 dev_kfree_skb_any(skb
);
983 static int enic_rq_service(struct vnic_dev
*vdev
, struct cq_desc
*cq_desc
,
984 u8 type
, u16 q_number
, u16 completed_index
, void *opaque
)
986 struct enic
*enic
= vnic_dev_priv(vdev
);
988 vnic_rq_service(&enic
->rq
[q_number
], cq_desc
,
989 completed_index
, VNIC_RQ_RETURN_DESC
,
990 enic_rq_indicate_buf
, opaque
);
995 static void enic_rq_drop_buf(struct vnic_rq
*rq
,
996 struct cq_desc
*cq_desc
, struct vnic_rq_buf
*buf
,
997 int skipped
, void *opaque
)
999 struct enic
*enic
= vnic_dev_priv(rq
->vdev
);
1000 struct sk_buff
*skb
= buf
->os_buf
;
1005 pci_unmap_single(enic
->pdev
, buf
->dma_addr
,
1006 buf
->len
, PCI_DMA_FROMDEVICE
);
1008 dev_kfree_skb_any(skb
);
1011 static int enic_rq_service_drop(struct vnic_dev
*vdev
, struct cq_desc
*cq_desc
,
1012 u8 type
, u16 q_number
, u16 completed_index
, void *opaque
)
1014 struct enic
*enic
= vnic_dev_priv(vdev
);
1016 vnic_rq_service(&enic
->rq
[q_number
], cq_desc
,
1017 completed_index
, VNIC_RQ_RETURN_DESC
,
1018 enic_rq_drop_buf
, opaque
);
1023 static int enic_poll(struct napi_struct
*napi
, int budget
)
1025 struct enic
*enic
= container_of(napi
, struct enic
, napi
);
1026 struct net_device
*netdev
= enic
->netdev
;
1027 unsigned int rq_work_to_do
= budget
;
1028 unsigned int wq_work_to_do
= -1; /* no limit */
1029 unsigned int work_done
, rq_work_done
, wq_work_done
;
1031 /* Service RQ (first) and WQ
1034 rq_work_done
= vnic_cq_service(&enic
->cq
[ENIC_CQ_RQ
],
1035 rq_work_to_do
, enic_rq_service
, NULL
);
1037 wq_work_done
= vnic_cq_service(&enic
->cq
[ENIC_CQ_WQ
],
1038 wq_work_to_do
, enic_wq_service
, NULL
);
1040 /* Accumulate intr event credits for this polling
1041 * cycle. An intr event is the completion of a
1042 * a WQ or RQ packet.
1045 work_done
= rq_work_done
+ wq_work_done
;
1048 vnic_intr_return_credits(&enic
->intr
[ENIC_INTX_WQ_RQ
],
1050 0 /* don't unmask intr */,
1051 0 /* don't reset intr timer */);
1053 if (rq_work_done
> 0) {
1058 vnic_rq_fill(&enic
->rq
[0], enic_rq_alloc_buf
);
1062 /* If no work done, flush all LROs and exit polling
1065 if (ENIC_SETTING(enic
, LRO
))
1066 lro_flush_all(&enic
->lro_mgr
);
1068 netif_rx_complete(netdev
, napi
);
1069 vnic_intr_unmask(&enic
->intr
[ENIC_MSIX_RQ
]);
1072 return rq_work_done
;
1075 static int enic_poll_msix(struct napi_struct
*napi
, int budget
)
1077 struct enic
*enic
= container_of(napi
, struct enic
, napi
);
1078 struct net_device
*netdev
= enic
->netdev
;
1079 unsigned int work_to_do
= budget
;
1080 unsigned int work_done
;
1085 work_done
= vnic_cq_service(&enic
->cq
[ENIC_CQ_RQ
],
1086 work_to_do
, enic_rq_service
, NULL
);
1088 if (work_done
> 0) {
1093 vnic_rq_fill(&enic
->rq
[0], enic_rq_alloc_buf
);
1095 /* Accumulate intr event credits for this polling
1096 * cycle. An intr event is the completion of a
1097 * a WQ or RQ packet.
1100 vnic_intr_return_credits(&enic
->intr
[ENIC_MSIX_RQ
],
1102 0 /* don't unmask intr */,
1103 0 /* don't reset intr timer */);
1106 /* If no work done, flush all LROs and exit polling
1109 if (ENIC_SETTING(enic
, LRO
))
1110 lro_flush_all(&enic
->lro_mgr
);
1112 netif_rx_complete(netdev
, napi
);
1113 vnic_intr_unmask(&enic
->intr
[ENIC_MSIX_RQ
]);
1119 static void enic_notify_timer(unsigned long data
)
1121 struct enic
*enic
= (struct enic
*)data
;
1123 enic_notify_check(enic
);
1125 mod_timer(&enic
->notify_timer
,
1126 round_jiffies(jiffies
+ ENIC_NOTIFY_TIMER_PERIOD
));
1129 static void enic_free_intr(struct enic
*enic
)
1131 struct net_device
*netdev
= enic
->netdev
;
1134 switch (vnic_dev_get_intr_mode(enic
->vdev
)) {
1135 case VNIC_DEV_INTR_MODE_INTX
:
1136 case VNIC_DEV_INTR_MODE_MSI
:
1137 free_irq(enic
->pdev
->irq
, netdev
);
1139 case VNIC_DEV_INTR_MODE_MSIX
:
1140 for (i
= 0; i
< ARRAY_SIZE(enic
->msix
); i
++)
1141 if (enic
->msix
[i
].requested
)
1142 free_irq(enic
->msix_entry
[i
].vector
,
1143 enic
->msix
[i
].devid
);
1150 static int enic_request_intr(struct enic
*enic
)
1152 struct net_device
*netdev
= enic
->netdev
;
1156 switch (vnic_dev_get_intr_mode(enic
->vdev
)) {
1158 case VNIC_DEV_INTR_MODE_INTX
:
1160 err
= request_irq(enic
->pdev
->irq
, enic_isr_legacy
,
1161 IRQF_SHARED
, netdev
->name
, netdev
);
1164 case VNIC_DEV_INTR_MODE_MSI
:
1166 err
= request_irq(enic
->pdev
->irq
, enic_isr_msi
,
1167 0, netdev
->name
, enic
);
1170 case VNIC_DEV_INTR_MODE_MSIX
:
1172 sprintf(enic
->msix
[ENIC_MSIX_RQ
].devname
,
1173 "%.11s-rx", netdev
->name
);
1174 enic
->msix
[ENIC_MSIX_RQ
].isr
= enic_isr_msix_rq
;
1175 enic
->msix
[ENIC_MSIX_RQ
].devid
= enic
;
1177 sprintf(enic
->msix
[ENIC_MSIX_WQ
].devname
,
1178 "%.11s-tx", netdev
->name
);
1179 enic
->msix
[ENIC_MSIX_WQ
].isr
= enic_isr_msix_wq
;
1180 enic
->msix
[ENIC_MSIX_WQ
].devid
= enic
;
1182 sprintf(enic
->msix
[ENIC_MSIX_ERR
].devname
,
1183 "%.11s-err", netdev
->name
);
1184 enic
->msix
[ENIC_MSIX_ERR
].isr
= enic_isr_msix_err
;
1185 enic
->msix
[ENIC_MSIX_ERR
].devid
= enic
;
1187 sprintf(enic
->msix
[ENIC_MSIX_NOTIFY
].devname
,
1188 "%.11s-notify", netdev
->name
);
1189 enic
->msix
[ENIC_MSIX_NOTIFY
].isr
= enic_isr_msix_notify
;
1190 enic
->msix
[ENIC_MSIX_NOTIFY
].devid
= enic
;
1192 for (i
= 0; i
< ARRAY_SIZE(enic
->msix
); i
++) {
1193 err
= request_irq(enic
->msix_entry
[i
].vector
,
1194 enic
->msix
[i
].isr
, 0,
1195 enic
->msix
[i
].devname
,
1196 enic
->msix
[i
].devid
);
1198 enic_free_intr(enic
);
1201 enic
->msix
[i
].requested
= 1;
1213 static int enic_notify_set(struct enic
*enic
)
1217 switch (vnic_dev_get_intr_mode(enic
->vdev
)) {
1218 case VNIC_DEV_INTR_MODE_INTX
:
1219 err
= vnic_dev_notify_set(enic
->vdev
, ENIC_INTX_NOTIFY
);
1221 case VNIC_DEV_INTR_MODE_MSIX
:
1222 err
= vnic_dev_notify_set(enic
->vdev
, ENIC_MSIX_NOTIFY
);
1225 err
= vnic_dev_notify_set(enic
->vdev
, -1 /* no intr */);
1232 static void enic_notify_timer_start(struct enic
*enic
)
1234 switch (vnic_dev_get_intr_mode(enic
->vdev
)) {
1235 case VNIC_DEV_INTR_MODE_MSI
:
1236 mod_timer(&enic
->notify_timer
, jiffies
);
1239 /* Using intr for notification for INTx/MSI-X */
1244 /* rtnl lock is held, process context */
1245 static int enic_open(struct net_device
*netdev
)
1247 struct enic
*enic
= netdev_priv(netdev
);
1251 for (i
= 0; i
< enic
->rq_count
; i
++) {
1252 err
= vnic_rq_fill(&enic
->rq
[i
], enic_rq_alloc_buf
);
1255 "%s: Unable to alloc receive buffers.\n",
1261 for (i
= 0; i
< enic
->wq_count
; i
++)
1262 vnic_wq_enable(&enic
->wq
[i
]);
1263 for (i
= 0; i
< enic
->rq_count
; i
++)
1264 vnic_rq_enable(&enic
->rq
[i
]);
1266 enic_add_station_addr(enic
);
1267 enic_set_multicast_list(netdev
);
1269 netif_wake_queue(netdev
);
1270 napi_enable(&enic
->napi
);
1271 vnic_dev_enable(enic
->vdev
);
1273 for (i
= 0; i
< enic
->intr_count
; i
++)
1274 vnic_intr_unmask(&enic
->intr
[i
]);
1276 enic_notify_timer_start(enic
);
1281 /* rtnl lock is held, process context */
1282 static int enic_stop(struct net_device
*netdev
)
1284 struct enic
*enic
= netdev_priv(netdev
);
1288 del_timer_sync(&enic
->notify_timer
);
1290 vnic_dev_disable(enic
->vdev
);
1291 napi_disable(&enic
->napi
);
1292 netif_stop_queue(netdev
);
1294 for (i
= 0; i
< enic
->intr_count
; i
++)
1295 vnic_intr_mask(&enic
->intr
[i
]);
1297 for (i
= 0; i
< enic
->wq_count
; i
++) {
1298 err
= vnic_wq_disable(&enic
->wq
[i
]);
1302 for (i
= 0; i
< enic
->rq_count
; i
++) {
1303 err
= vnic_rq_disable(&enic
->rq
[i
]);
1308 (void)vnic_cq_service(&enic
->cq
[ENIC_CQ_RQ
],
1309 -1, enic_rq_service_drop
, NULL
);
1310 (void)vnic_cq_service(&enic
->cq
[ENIC_CQ_WQ
],
1311 -1, enic_wq_service
, NULL
);
1313 for (i
= 0; i
< enic
->wq_count
; i
++)
1314 vnic_wq_clean(&enic
->wq
[i
], enic_free_wq_buf
);
1315 for (i
= 0; i
< enic
->rq_count
; i
++)
1316 vnic_rq_clean(&enic
->rq
[i
], enic_free_rq_buf
);
1317 for (i
= 0; i
< enic
->cq_count
; i
++)
1318 vnic_cq_clean(&enic
->cq
[i
]);
1319 for (i
= 0; i
< enic
->intr_count
; i
++)
1320 vnic_intr_clean(&enic
->intr
[i
]);
1325 static int enic_change_mtu(struct net_device
*netdev
, int new_mtu
)
1327 struct enic
*enic
= netdev_priv(netdev
);
1328 int running
= netif_running(netdev
);
1330 if (new_mtu
< ENIC_MIN_MTU
|| new_mtu
> ENIC_MAX_MTU
)
1336 netdev
->mtu
= new_mtu
;
1338 if (netdev
->mtu
> enic
->port_mtu
)
1339 printk(KERN_WARNING PFX
1340 "%s: interface MTU (%d) set higher "
1341 "than port MTU (%d)\n",
1342 netdev
->name
, netdev
->mtu
, enic
->port_mtu
);
1350 #ifdef CONFIG_NET_POLL_CONTROLLER
1351 static void enic_poll_controller(struct net_device
*netdev
)
1353 struct enic
*enic
= netdev_priv(netdev
);
1354 struct vnic_dev
*vdev
= enic
->vdev
;
1356 switch (vnic_dev_get_intr_mode(vdev
)) {
1357 case VNIC_DEV_INTR_MODE_MSIX
:
1358 enic_isr_msix_rq(enic
->pdev
->irq
, enic
);
1359 enic_isr_msix_wq(enic
->pdev
->irq
, enic
);
1361 case VNIC_DEV_INTR_MODE_MSI
:
1362 enic_isr_msi(enic
->pdev
->irq
, enic
);
1364 case VNIC_DEV_INTR_MODE_INTX
:
1365 enic_isr_legacy(enic
->pdev
->irq
, netdev
);
1373 static int enic_dev_wait(struct vnic_dev
*vdev
,
1374 int (*start
)(struct vnic_dev
*, int),
1375 int (*finished
)(struct vnic_dev
*, int *),
1382 BUG_ON(in_interrupt());
1384 err
= start(vdev
, arg
);
1388 /* Wait for func to complete...2 seconds max
1391 time
= jiffies
+ (HZ
* 2);
1394 err
= finished(vdev
, &done
);
1401 schedule_timeout_uninterruptible(HZ
/ 10);
1403 } while (time_after(time
, jiffies
));
1408 static int enic_dev_open(struct enic
*enic
)
1412 err
= enic_dev_wait(enic
->vdev
, vnic_dev_open
,
1413 vnic_dev_open_done
, 0);
1416 "vNIC device open failed, err %d.\n", err
);
1421 static int enic_dev_soft_reset(struct enic
*enic
)
1425 err
= enic_dev_wait(enic
->vdev
, vnic_dev_soft_reset
,
1426 vnic_dev_soft_reset_done
, 0);
1429 "vNIC soft reset failed, err %d.\n", err
);
1434 static void enic_reset(struct work_struct
*work
)
1436 struct enic
*enic
= container_of(work
, struct enic
, reset
);
1438 if (!netif_running(enic
->netdev
))
1443 spin_lock(&enic
->devcmd_lock
);
1444 vnic_dev_hang_notify(enic
->vdev
);
1445 spin_unlock(&enic
->devcmd_lock
);
1447 enic_stop(enic
->netdev
);
1448 enic_dev_soft_reset(enic
);
1449 enic_reset_mcaddrs(enic
);
1450 enic_init_vnic_resources(enic
);
1451 enic_open(enic
->netdev
);
1456 static int enic_set_intr_mode(struct enic
*enic
)
1458 unsigned int n
= ARRAY_SIZE(enic
->rq
);
1459 unsigned int m
= ARRAY_SIZE(enic
->wq
);
1462 /* Set interrupt mode (INTx, MSI, MSI-X) depending
1463 * system capabilities.
1467 * We need n RQs, m WQs, n+m CQs, and n+m+2 INTRs
1468 * (the second to last INTR is used for WQ/RQ errors)
1469 * (the last INTR is used for notifications)
1472 BUG_ON(ARRAY_SIZE(enic
->msix_entry
) < n
+ m
+ 2);
1473 for (i
= 0; i
< n
+ m
+ 2; i
++)
1474 enic
->msix_entry
[i
].entry
= i
;
1476 if (enic
->config
.intr_mode
< 1 &&
1477 enic
->rq_count
>= n
&&
1478 enic
->wq_count
>= m
&&
1479 enic
->cq_count
>= n
+ m
&&
1480 enic
->intr_count
>= n
+ m
+ 2 &&
1481 !pci_enable_msix(enic
->pdev
, enic
->msix_entry
, n
+ m
+ 2)) {
1485 enic
->cq_count
= n
+ m
;
1486 enic
->intr_count
= n
+ m
+ 2;
1488 vnic_dev_set_intr_mode(enic
->vdev
, VNIC_DEV_INTR_MODE_MSIX
);
1495 * We need 1 RQ, 1 WQ, 2 CQs, and 1 INTR
1498 if (enic
->config
.intr_mode
< 2 &&
1499 enic
->rq_count
>= 1 &&
1500 enic
->wq_count
>= 1 &&
1501 enic
->cq_count
>= 2 &&
1502 enic
->intr_count
>= 1 &&
1503 !pci_enable_msi(enic
->pdev
)) {
1508 enic
->intr_count
= 1;
1510 vnic_dev_set_intr_mode(enic
->vdev
, VNIC_DEV_INTR_MODE_MSI
);
1517 * We need 1 RQ, 1 WQ, 2 CQs, and 3 INTRs
1518 * (the first INTR is used for WQ/RQ)
1519 * (the second INTR is used for WQ/RQ errors)
1520 * (the last INTR is used for notifications)
1523 if (enic
->config
.intr_mode
< 3 &&
1524 enic
->rq_count
>= 1 &&
1525 enic
->wq_count
>= 1 &&
1526 enic
->cq_count
>= 2 &&
1527 enic
->intr_count
>= 3) {
1532 enic
->intr_count
= 3;
1534 vnic_dev_set_intr_mode(enic
->vdev
, VNIC_DEV_INTR_MODE_INTX
);
1539 vnic_dev_set_intr_mode(enic
->vdev
, VNIC_DEV_INTR_MODE_UNKNOWN
);
1544 static void enic_clear_intr_mode(struct enic
*enic
)
1546 switch (vnic_dev_get_intr_mode(enic
->vdev
)) {
1547 case VNIC_DEV_INTR_MODE_MSIX
:
1548 pci_disable_msix(enic
->pdev
);
1550 case VNIC_DEV_INTR_MODE_MSI
:
1551 pci_disable_msi(enic
->pdev
);
1557 vnic_dev_set_intr_mode(enic
->vdev
, VNIC_DEV_INTR_MODE_UNKNOWN
);
1560 static void enic_iounmap(struct enic
*enic
)
1562 if (enic
->bar0
.vaddr
)
1563 iounmap(enic
->bar0
.vaddr
);
1566 static int __devinit
enic_probe(struct pci_dev
*pdev
,
1567 const struct pci_device_id
*ent
)
1569 struct net_device
*netdev
;
1575 const u8 rss_default_cpu
= 0;
1576 const u8 rss_hash_type
= 0;
1577 const u8 rss_hash_bits
= 0;
1578 const u8 rss_base_cpu
= 0;
1579 const u8 rss_enable
= 0;
1580 const u8 tso_ipid_split_en
= 0;
1581 const u8 ig_vlan_strip_en
= 1;
1583 /* Allocate net device structure and initialize. Private
1584 * instance data is initialized to zero.
1587 netdev
= alloc_etherdev(sizeof(struct enic
));
1589 printk(KERN_ERR PFX
"Etherdev alloc failed, aborting.\n");
1593 /* Set the netdev name early so intr vectors are properly
1594 * named and any error msgs can include netdev->name
1598 err
= dev_alloc_name(netdev
, netdev
->name
);
1601 printk(KERN_ERR PFX
"Unable to allocate netdev name.\n");
1602 goto err_out_free_netdev
;
1605 pci_set_drvdata(pdev
, netdev
);
1607 SET_NETDEV_DEV(netdev
, &pdev
->dev
);
1609 enic
= netdev_priv(netdev
);
1610 enic
->netdev
= netdev
;
1613 /* Setup PCI resources
1616 err
= pci_enable_device(pdev
);
1619 "%s: Cannot enable PCI device, aborting.\n",
1621 goto err_out_free_netdev
;
1624 err
= pci_request_regions(pdev
, DRV_NAME
);
1627 "%s: Cannot request PCI regions, aborting.\n",
1629 goto err_out_disable_device
;
1632 pci_set_master(pdev
);
1634 /* Query PCI controller on system for DMA addressing
1635 * limitation for the device. Try 40-bit first, and
1639 err
= pci_set_dma_mask(pdev
, DMA_40BIT_MASK
);
1641 err
= pci_set_dma_mask(pdev
, DMA_32BIT_MASK
);
1644 "%s: No usable DMA configuration, aborting.\n",
1646 goto err_out_release_regions
;
1648 err
= pci_set_consistent_dma_mask(pdev
, DMA_32BIT_MASK
);
1651 "%s: Unable to obtain 32-bit DMA "
1652 "for consistent allocations, aborting.\n",
1654 goto err_out_release_regions
;
1657 err
= pci_set_consistent_dma_mask(pdev
, DMA_40BIT_MASK
);
1660 "%s: Unable to obtain 40-bit DMA "
1661 "for consistent allocations, aborting.\n",
1663 goto err_out_release_regions
;
1668 /* Map vNIC resources from BAR0
1671 if (!(pci_resource_flags(pdev
, 0) & IORESOURCE_MEM
)) {
1673 "%s: BAR0 not memory-map'able, aborting.\n",
1676 goto err_out_release_regions
;
1679 enic
->bar0
.vaddr
= pci_iomap(pdev
, 0, enic
->bar0
.len
);
1680 enic
->bar0
.bus_addr
= pci_resource_start(pdev
, 0);
1681 enic
->bar0
.len
= pci_resource_len(pdev
, 0);
1683 if (!enic
->bar0
.vaddr
) {
1685 "%s: Cannot memory-map BAR0 res hdr, aborting.\n",
1688 goto err_out_release_regions
;
1691 /* Register vNIC device
1694 enic
->vdev
= vnic_dev_register(NULL
, enic
, pdev
, &enic
->bar0
);
1697 "%s: vNIC registration failed, aborting.\n",
1700 goto err_out_iounmap
;
1703 /* Issue device open to get device in known state
1706 err
= enic_dev_open(enic
);
1709 "%s: vNIC dev open failed, aborting.\n",
1711 goto err_out_vnic_unregister
;
1714 /* Issue device init to initialize the vnic-to-switch link.
1715 * We'll start with carrier off and wait for link UP
1716 * notification later to turn on carrier. We don't need
1717 * to wait here for the vnic-to-switch link initialization
1718 * to complete; link UP notification is the indication that
1719 * the process is complete.
1722 netif_carrier_off(netdev
);
1724 err
= vnic_dev_init(enic
->vdev
, 0);
1727 "%s: vNIC dev init failed, aborting.\n",
1729 goto err_out_dev_close
;
1732 /* Get vNIC configuration
1735 err
= enic_get_vnic_config(enic
);
1738 "%s: Get vNIC configuration failed, aborting.\n",
1740 goto err_out_dev_close
;
1743 /* Get available resource counts
1746 enic_get_res_counts(enic
);
1748 /* Set interrupt mode based on resource counts and system
1752 err
= enic_set_intr_mode(enic
);
1755 "%s: Failed to set intr mode, aborting.\n",
1757 goto err_out_dev_close
;
1760 /* Request interrupt vector(s)
1763 err
= enic_request_intr(enic
);
1765 printk(KERN_ERR PFX
"%s: Unable to request irq.\n",
1767 goto err_out_dev_close
;
1770 /* Allocate and configure vNIC resources
1773 err
= enic_alloc_vnic_resources(enic
);
1776 "%s: Failed to alloc vNIC resources, aborting.\n",
1778 goto err_out_free_vnic_resources
;
1781 enic_init_vnic_resources(enic
);
1783 /* Enable VLAN tag stripping. RSS not enabled (yet).
1786 err
= enic_set_nic_cfg(enic
,
1787 rss_default_cpu
, rss_hash_type
,
1788 rss_hash_bits
, rss_base_cpu
,
1789 rss_enable
, tso_ipid_split_en
,
1793 "%s: Failed to config nic, aborting.\n",
1795 goto err_out_free_vnic_resources
;
1798 /* Setup notification buffer area
1801 err
= enic_notify_set(enic
);
1804 "%s: Failed to alloc notify buffer, aborting.\n",
1806 goto err_out_free_vnic_resources
;
1809 /* Setup notification timer, HW reset task, and locks
1812 init_timer(&enic
->notify_timer
);
1813 enic
->notify_timer
.function
= enic_notify_timer
;
1814 enic
->notify_timer
.data
= (unsigned long)enic
;
1816 INIT_WORK(&enic
->reset
, enic_reset
);
1818 for (i
= 0; i
< enic
->wq_count
; i
++)
1819 spin_lock_init(&enic
->wq_lock
[i
]);
1821 spin_lock_init(&enic
->devcmd_lock
);
1823 /* Register net device
1826 enic
->port_mtu
= enic
->config
.mtu
;
1827 (void)enic_change_mtu(netdev
, enic
->port_mtu
);
1829 err
= enic_set_mac_addr(netdev
, enic
->mac_addr
);
1832 "%s: Invalid MAC address, aborting.\n",
1834 goto err_out_notify_unset
;
1837 netdev
->open
= enic_open
;
1838 netdev
->stop
= enic_stop
;
1839 netdev
->hard_start_xmit
= enic_hard_start_xmit
;
1840 netdev
->get_stats
= enic_get_stats
;
1841 netdev
->set_multicast_list
= enic_set_multicast_list
;
1842 netdev
->change_mtu
= enic_change_mtu
;
1843 netdev
->vlan_rx_register
= enic_vlan_rx_register
;
1844 netdev
->vlan_rx_add_vid
= enic_vlan_rx_add_vid
;
1845 netdev
->vlan_rx_kill_vid
= enic_vlan_rx_kill_vid
;
1846 netdev
->tx_timeout
= enic_tx_timeout
;
1847 netdev
->watchdog_timeo
= 2 * HZ
;
1848 netdev
->ethtool_ops
= &enic_ethtool_ops
;
1849 #ifdef CONFIG_NET_POLL_CONTROLLER
1850 netdev
->poll_controller
= enic_poll_controller
;
1853 switch (vnic_dev_get_intr_mode(enic
->vdev
)) {
1855 netif_napi_add(netdev
, &enic
->napi
, enic_poll
, 64);
1857 case VNIC_DEV_INTR_MODE_MSIX
:
1858 netif_napi_add(netdev
, &enic
->napi
, enic_poll_msix
, 64);
1862 netdev
->features
|= NETIF_F_HW_VLAN_TX
| NETIF_F_HW_VLAN_RX
;
1863 if (ENIC_SETTING(enic
, TXCSUM
))
1864 netdev
->features
|= NETIF_F_SG
| NETIF_F_HW_CSUM
;
1865 if (ENIC_SETTING(enic
, TSO
))
1866 netdev
->features
|= NETIF_F_TSO
|
1867 NETIF_F_TSO6
| NETIF_F_TSO_ECN
;
1869 netdev
->features
|= NETIF_F_HIGHDMA
;
1872 enic
->csum_rx_enabled
= ENIC_SETTING(enic
, RXCSUM
);
1874 if (ENIC_SETTING(enic
, LRO
)) {
1875 enic
->lro_mgr
.max_aggr
= ENIC_LRO_MAX_AGGR
;
1876 enic
->lro_mgr
.max_desc
= ENIC_LRO_MAX_DESC
;
1877 enic
->lro_mgr
.lro_arr
= enic
->lro_desc
;
1878 enic
->lro_mgr
.get_skb_header
= enic_get_skb_header
;
1879 enic
->lro_mgr
.features
= LRO_F_NAPI
| LRO_F_EXTRACT_VLAN_ID
;
1880 enic
->lro_mgr
.dev
= netdev
;
1881 enic
->lro_mgr
.ip_summed
= CHECKSUM_COMPLETE
;
1882 enic
->lro_mgr
.ip_summed_aggr
= CHECKSUM_UNNECESSARY
;
1885 err
= register_netdev(netdev
);
1888 "%s: Cannot register net device, aborting.\n",
1890 goto err_out_notify_unset
;
1895 err_out_notify_unset
:
1896 vnic_dev_notify_unset(enic
->vdev
);
1897 err_out_free_vnic_resources
:
1898 enic_free_vnic_resources(enic
);
1899 enic_free_intr(enic
);
1901 vnic_dev_close(enic
->vdev
);
1902 err_out_vnic_unregister
:
1903 enic_clear_intr_mode(enic
);
1904 vnic_dev_unregister(enic
->vdev
);
1907 err_out_release_regions
:
1908 pci_release_regions(pdev
);
1909 err_out_disable_device
:
1910 pci_disable_device(pdev
);
1911 err_out_free_netdev
:
1912 pci_set_drvdata(pdev
, NULL
);
1913 free_netdev(netdev
);
1918 static void __devexit
enic_remove(struct pci_dev
*pdev
)
1920 struct net_device
*netdev
= pci_get_drvdata(pdev
);
1923 struct enic
*enic
= netdev_priv(netdev
);
1925 flush_scheduled_work();
1926 unregister_netdev(netdev
);
1927 vnic_dev_notify_unset(enic
->vdev
);
1928 enic_free_vnic_resources(enic
);
1929 enic_free_intr(enic
);
1930 vnic_dev_close(enic
->vdev
);
1931 enic_clear_intr_mode(enic
);
1932 vnic_dev_unregister(enic
->vdev
);
1934 pci_release_regions(pdev
);
1935 pci_disable_device(pdev
);
1936 pci_set_drvdata(pdev
, NULL
);
1937 free_netdev(netdev
);
1941 static struct pci_driver enic_driver
= {
1943 .id_table
= enic_id_table
,
1944 .probe
= enic_probe
,
1945 .remove
= __devexit_p(enic_remove
),
1948 static int __init
enic_init_module(void)
1950 printk(KERN_INFO PFX
"%s, ver %s\n", DRV_DESCRIPTION
, DRV_VERSION
);
1952 return pci_register_driver(&enic_driver
);
1955 static void __exit
enic_cleanup_module(void)
1957 pci_unregister_driver(&enic_driver
);
1960 module_init(enic_init_module
);
1961 module_exit(enic_cleanup_module
);