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