aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/enic
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/enic')
-rw-r--r--drivers/net/enic/Makefile2
-rw-r--r--drivers/net/enic/enic.h43
-rw-r--r--drivers/net/enic/enic_dev.c275
-rw-r--r--drivers/net/enic/enic_dev.h44
-rw-r--r--drivers/net/enic/enic_main.c1032
-rw-r--r--drivers/net/enic/enic_pp.c264
-rw-r--r--drivers/net/enic/enic_pp.h27
-rw-r--r--drivers/net/enic/enic_res.c32
-rw-r--r--drivers/net/enic/enic_res.h3
-rw-r--r--drivers/net/enic/vnic_dev.c256
-rw-r--r--drivers/net/enic/vnic_dev.h33
-rw-r--r--drivers/net/enic/vnic_devcmd.h97
-rw-r--r--drivers/net/enic/vnic_enet.h2
-rw-r--r--drivers/net/enic/vnic_intr.c5
-rw-r--r--drivers/net/enic/vnic_resource.h13
-rw-r--r--drivers/net/enic/vnic_rq.c8
-rw-r--r--drivers/net/enic/vnic_rq.h9
-rw-r--r--drivers/net/enic/vnic_rss.h5
-rw-r--r--drivers/net/enic/vnic_vic.c12
-rw-r--r--drivers/net/enic/vnic_vic.h44
-rw-r--r--drivers/net/enic/vnic_wq.c8
-rw-r--r--drivers/net/enic/vnic_wq.h4
22 files changed, 1375 insertions, 843 deletions
diff --git a/drivers/net/enic/Makefile b/drivers/net/enic/Makefile
index e7b6c31880ba..9d4974bba247 100644
--- a/drivers/net/enic/Makefile
+++ b/drivers/net/enic/Makefile
@@ -1,5 +1,5 @@
1obj-$(CONFIG_ENIC) := enic.o 1obj-$(CONFIG_ENIC) := enic.o
2 2
3enic-y := enic_main.o vnic_cq.o vnic_intr.o vnic_wq.o \ 3enic-y := enic_main.o vnic_cq.o vnic_intr.o vnic_wq.o \
4 enic_res.o vnic_dev.o vnic_rq.o vnic_vic.o 4 enic_res.o enic_dev.o enic_pp.o vnic_dev.o vnic_rq.o vnic_vic.o
5 5
diff --git a/drivers/net/enic/enic.h b/drivers/net/enic/enic.h
index f239aa8c6f4c..38b351c7b979 100644
--- a/drivers/net/enic/enic.h
+++ b/drivers/net/enic/enic.h
@@ -32,35 +32,16 @@
32 32
33#define DRV_NAME "enic" 33#define DRV_NAME "enic"
34#define DRV_DESCRIPTION "Cisco VIC Ethernet NIC Driver" 34#define DRV_DESCRIPTION "Cisco VIC Ethernet NIC Driver"
35#define DRV_VERSION "1.4.1.1" 35#define DRV_VERSION "2.1.1.13"
36#define DRV_COPYRIGHT "Copyright 2008-2010 Cisco Systems, Inc" 36#define DRV_COPYRIGHT "Copyright 2008-2011 Cisco Systems, Inc"
37 37
38#define ENIC_BARS_MAX 6 38#define ENIC_BARS_MAX 6
39 39
40#define ENIC_WQ_MAX 8 40#define ENIC_WQ_MAX 1
41#define ENIC_RQ_MAX 8 41#define ENIC_RQ_MAX 1
42#define ENIC_CQ_MAX (ENIC_WQ_MAX + ENIC_RQ_MAX) 42#define ENIC_CQ_MAX (ENIC_WQ_MAX + ENIC_RQ_MAX)
43#define ENIC_INTR_MAX (ENIC_CQ_MAX + 2) 43#define ENIC_INTR_MAX (ENIC_CQ_MAX + 2)
44 44
45enum enic_cq_index {
46 ENIC_CQ_RQ,
47 ENIC_CQ_WQ,
48};
49
50enum enic_intx_intr_index {
51 ENIC_INTX_WQ_RQ,
52 ENIC_INTX_ERR,
53 ENIC_INTX_NOTIFY,
54};
55
56enum enic_msix_intr_index {
57 ENIC_MSIX_RQ,
58 ENIC_MSIX_WQ,
59 ENIC_MSIX_ERR,
60 ENIC_MSIX_NOTIFY,
61 ENIC_MSIX_MAX,
62};
63
64struct enic_msix_entry { 45struct enic_msix_entry {
65 int requested; 46 int requested;
66 char devname[IFNAMSIZ]; 47 char devname[IFNAMSIZ];
@@ -68,7 +49,7 @@ struct enic_msix_entry {
68 void *devid; 49 void *devid;
69}; 50};
70 51
71#define ENIC_SET_APPLIED (1 << 0) 52#define ENIC_PORT_REQUEST_APPLIED (1 << 0)
72#define ENIC_SET_REQUEST (1 << 1) 53#define ENIC_SET_REQUEST (1 << 1)
73#define ENIC_SET_NAME (1 << 2) 54#define ENIC_SET_NAME (1 << 2)
74#define ENIC_SET_INSTANCE (1 << 3) 55#define ENIC_SET_INSTANCE (1 << 3)
@@ -80,6 +61,8 @@ struct enic_port_profile {
80 char name[PORT_PROFILE_MAX]; 61 char name[PORT_PROFILE_MAX];
81 u8 instance_uuid[PORT_UUID_MAX]; 62 u8 instance_uuid[PORT_UUID_MAX];
82 u8 host_uuid[PORT_UUID_MAX]; 63 u8 host_uuid[PORT_UUID_MAX];
64 u8 vf_mac[ETH_ALEN];
65 u8 mac_addr[ETH_ALEN];
83}; 66};
84 67
85/* Per-instance private data structure */ 68/* Per-instance private data structure */
@@ -91,15 +74,16 @@ struct enic {
91 struct vnic_dev *vdev; 74 struct vnic_dev *vdev;
92 struct timer_list notify_timer; 75 struct timer_list notify_timer;
93 struct work_struct reset; 76 struct work_struct reset;
94 struct msix_entry msix_entry[ENIC_MSIX_MAX]; 77 struct msix_entry msix_entry[ENIC_INTR_MAX];
95 struct enic_msix_entry msix[ENIC_MSIX_MAX]; 78 struct enic_msix_entry msix[ENIC_INTR_MAX];
96 u32 msg_enable; 79 u32 msg_enable;
97 spinlock_t devcmd_lock; 80 spinlock_t devcmd_lock;
98 u8 mac_addr[ETH_ALEN]; 81 u8 mac_addr[ETH_ALEN];
99 u8 mc_addr[ENIC_MULTICAST_PERFECT_FILTERS][ETH_ALEN]; 82 u8 mc_addr[ENIC_MULTICAST_PERFECT_FILTERS][ETH_ALEN];
83 u8 uc_addr[ENIC_UNICAST_PERFECT_FILTERS][ETH_ALEN];
100 unsigned int flags; 84 unsigned int flags;
101 unsigned int mc_count; 85 unsigned int mc_count;
102 int csum_rx_enabled; 86 unsigned int uc_count;
103 u32 port_mtu; 87 u32 port_mtu;
104 u32 rx_coalesce_usecs; 88 u32 rx_coalesce_usecs;
105 u32 tx_coalesce_usecs; 89 u32 tx_coalesce_usecs;
@@ -116,10 +100,9 @@ struct enic {
116 /* receive queue cache line section */ 100 /* receive queue cache line section */
117 ____cacheline_aligned struct vnic_rq rq[ENIC_RQ_MAX]; 101 ____cacheline_aligned struct vnic_rq rq[ENIC_RQ_MAX];
118 unsigned int rq_count; 102 unsigned int rq_count;
119 int (*rq_alloc_buf)(struct vnic_rq *rq);
120 u64 rq_truncated_pkts; 103 u64 rq_truncated_pkts;
121 u64 rq_bad_fcs; 104 u64 rq_bad_fcs;
122 struct napi_struct napi; 105 struct napi_struct napi[ENIC_RQ_MAX];
123 106
124 /* interrupt resource cache line section */ 107 /* interrupt resource cache line section */
125 ____cacheline_aligned struct vnic_intr intr[ENIC_INTR_MAX]; 108 ____cacheline_aligned struct vnic_intr intr[ENIC_INTR_MAX];
@@ -136,4 +119,6 @@ static inline struct device *enic_get_dev(struct enic *enic)
136 return &(enic->pdev->dev); 119 return &(enic->pdev->dev);
137} 120}
138 121
122void enic_reset_addr_lists(struct enic *enic);
123
139#endif /* _ENIC_H_ */ 124#endif /* _ENIC_H_ */
diff --git a/drivers/net/enic/enic_dev.c b/drivers/net/enic/enic_dev.c
new file mode 100644
index 000000000000..90687b14e60f
--- /dev/null
+++ b/drivers/net/enic/enic_dev.c
@@ -0,0 +1,275 @@
1/*
2 * Copyright 2011 Cisco Systems, Inc. All rights reserved.
3 *
4 * This program is free software; you may redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; version 2 of the License.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
10 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
11 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
12 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
13 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
14 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
15 * SOFTWARE.
16 *
17 */
18
19#include <linux/pci.h>
20#include <linux/etherdevice.h>
21
22#include "vnic_dev.h"
23#include "vnic_vic.h"
24#include "enic_res.h"
25#include "enic.h"
26#include "enic_dev.h"
27
28int enic_dev_fw_info(struct enic *enic, struct vnic_devcmd_fw_info **fw_info)
29{
30 int err;
31
32 spin_lock(&enic->devcmd_lock);
33 err = vnic_dev_fw_info(enic->vdev, fw_info);
34 spin_unlock(&enic->devcmd_lock);
35
36 return err;
37}
38
39int enic_dev_stats_dump(struct enic *enic, struct vnic_stats **vstats)
40{
41 int err;
42
43 spin_lock(&enic->devcmd_lock);
44 err = vnic_dev_stats_dump(enic->vdev, vstats);
45 spin_unlock(&enic->devcmd_lock);
46
47 return err;
48}
49
50int enic_dev_add_station_addr(struct enic *enic)
51{
52 int err;
53
54 if (!is_valid_ether_addr(enic->netdev->dev_addr))
55 return -EADDRNOTAVAIL;
56
57 spin_lock(&enic->devcmd_lock);
58 err = vnic_dev_add_addr(enic->vdev, enic->netdev->dev_addr);
59 spin_unlock(&enic->devcmd_lock);
60
61 return err;
62}
63
64int enic_dev_del_station_addr(struct enic *enic)
65{
66 int err;
67
68 if (!is_valid_ether_addr(enic->netdev->dev_addr))
69 return -EADDRNOTAVAIL;
70
71 spin_lock(&enic->devcmd_lock);
72 err = vnic_dev_del_addr(enic->vdev, enic->netdev->dev_addr);
73 spin_unlock(&enic->devcmd_lock);
74
75 return err;
76}
77
78int enic_dev_packet_filter(struct enic *enic, int directed, int multicast,
79 int broadcast, int promisc, int allmulti)
80{
81 int err;
82
83 spin_lock(&enic->devcmd_lock);
84 err = vnic_dev_packet_filter(enic->vdev, directed,
85 multicast, broadcast, promisc, allmulti);
86 spin_unlock(&enic->devcmd_lock);
87
88 return err;
89}
90
91int enic_dev_add_addr(struct enic *enic, u8 *addr)
92{
93 int err;
94
95 spin_lock(&enic->devcmd_lock);
96 err = vnic_dev_add_addr(enic->vdev, addr);
97 spin_unlock(&enic->devcmd_lock);
98
99 return err;
100}
101
102int enic_dev_del_addr(struct enic *enic, u8 *addr)
103{
104 int err;
105
106 spin_lock(&enic->devcmd_lock);
107 err = vnic_dev_del_addr(enic->vdev, addr);
108 spin_unlock(&enic->devcmd_lock);
109
110 return err;
111}
112
113int enic_dev_notify_unset(struct enic *enic)
114{
115 int err;
116
117 spin_lock(&enic->devcmd_lock);
118 err = vnic_dev_notify_unset(enic->vdev);
119 spin_unlock(&enic->devcmd_lock);
120
121 return err;
122}
123
124int enic_dev_hang_notify(struct enic *enic)
125{
126 int err;
127
128 spin_lock(&enic->devcmd_lock);
129 err = vnic_dev_hang_notify(enic->vdev);
130 spin_unlock(&enic->devcmd_lock);
131
132 return err;
133}
134
135int enic_dev_set_ig_vlan_rewrite_mode(struct enic *enic)
136{
137 int err;
138
139 spin_lock(&enic->devcmd_lock);
140 err = vnic_dev_set_ig_vlan_rewrite_mode(enic->vdev,
141 IG_VLAN_REWRITE_MODE_PRIORITY_TAG_DEFAULT_VLAN);
142 spin_unlock(&enic->devcmd_lock);
143
144 return err;
145}
146
147int enic_dev_enable(struct enic *enic)
148{
149 int err;
150
151 spin_lock(&enic->devcmd_lock);
152 err = vnic_dev_enable_wait(enic->vdev);
153 spin_unlock(&enic->devcmd_lock);
154
155 return err;
156}
157
158int enic_dev_disable(struct enic *enic)
159{
160 int err;
161
162 spin_lock(&enic->devcmd_lock);
163 err = vnic_dev_disable(enic->vdev);
164 spin_unlock(&enic->devcmd_lock);
165
166 return err;
167}
168
169int enic_vnic_dev_deinit(struct enic *enic)
170{
171 int err;
172
173 spin_lock(&enic->devcmd_lock);
174 err = vnic_dev_deinit(enic->vdev);
175 spin_unlock(&enic->devcmd_lock);
176
177 return err;
178}
179
180int enic_dev_init_prov2(struct enic *enic, struct vic_provinfo *vp)
181{
182 int err;
183
184 spin_lock(&enic->devcmd_lock);
185 err = vnic_dev_init_prov2(enic->vdev,
186 (u8 *)vp, vic_provinfo_size(vp));
187 spin_unlock(&enic->devcmd_lock);
188
189 return err;
190}
191
192int enic_dev_deinit_done(struct enic *enic, int *status)
193{
194 int err;
195
196 spin_lock(&enic->devcmd_lock);
197 err = vnic_dev_deinit_done(enic->vdev, status);
198 spin_unlock(&enic->devcmd_lock);
199
200 return err;
201}
202
203/* rtnl lock is held */
204void enic_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
205{
206 struct enic *enic = netdev_priv(netdev);
207
208 spin_lock(&enic->devcmd_lock);
209 enic_add_vlan(enic, vid);
210 spin_unlock(&enic->devcmd_lock);
211}
212
213/* rtnl lock is held */
214void enic_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
215{
216 struct enic *enic = netdev_priv(netdev);
217
218 spin_lock(&enic->devcmd_lock);
219 enic_del_vlan(enic, vid);
220 spin_unlock(&enic->devcmd_lock);
221}
222
223int enic_dev_enable2(struct enic *enic, int active)
224{
225 int err;
226
227 spin_lock(&enic->devcmd_lock);
228 err = vnic_dev_enable2(enic->vdev, active);
229 spin_unlock(&enic->devcmd_lock);
230
231 return err;
232}
233
234int enic_dev_enable2_done(struct enic *enic, int *status)
235{
236 int err;
237
238 spin_lock(&enic->devcmd_lock);
239 err = vnic_dev_enable2_done(enic->vdev, status);
240 spin_unlock(&enic->devcmd_lock);
241
242 return err;
243}
244
245int enic_dev_status_to_errno(int devcmd_status)
246{
247 switch (devcmd_status) {
248 case ERR_SUCCESS:
249 return 0;
250 case ERR_EINVAL:
251 return -EINVAL;
252 case ERR_EFAULT:
253 return -EFAULT;
254 case ERR_EPERM:
255 return -EPERM;
256 case ERR_EBUSY:
257 return -EBUSY;
258 case ERR_ECMDUNKNOWN:
259 case ERR_ENOTSUPPORTED:
260 return -EOPNOTSUPP;
261 case ERR_EBADSTATE:
262 return -EINVAL;
263 case ERR_ENOMEM:
264 return -ENOMEM;
265 case ERR_ETIMEDOUT:
266 return -ETIMEDOUT;
267 case ERR_ELINKDOWN:
268 return -ENETDOWN;
269 case ERR_EINPROGRESS:
270 return -EINPROGRESS;
271 case ERR_EMAXRES:
272 default:
273 return (devcmd_status < 0) ? devcmd_status : -1;
274 }
275}
diff --git a/drivers/net/enic/enic_dev.h b/drivers/net/enic/enic_dev.h
new file mode 100644
index 000000000000..d5f681337626
--- /dev/null
+++ b/drivers/net/enic/enic_dev.h
@@ -0,0 +1,44 @@
1/*
2 * Copyright 2011 Cisco Systems, Inc. All rights reserved.
3 *
4 * This program is free software; you may redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; version 2 of the License.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
10 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
11 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
12 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
13 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
14 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
15 * SOFTWARE.
16 *
17 */
18
19#ifndef _ENIC_DEV_H_
20#define _ENIC_DEV_H_
21
22int enic_dev_fw_info(struct enic *enic, struct vnic_devcmd_fw_info **fw_info);
23int enic_dev_stats_dump(struct enic *enic, struct vnic_stats **vstats);
24int enic_dev_add_station_addr(struct enic *enic);
25int enic_dev_del_station_addr(struct enic *enic);
26int enic_dev_packet_filter(struct enic *enic, int directed, int multicast,
27 int broadcast, int promisc, int allmulti);
28int enic_dev_add_addr(struct enic *enic, u8 *addr);
29int enic_dev_del_addr(struct enic *enic, u8 *addr);
30void enic_vlan_rx_add_vid(struct net_device *netdev, u16 vid);
31void enic_vlan_rx_kill_vid(struct net_device *netdev, u16 vid);
32int enic_dev_notify_unset(struct enic *enic);
33int enic_dev_hang_notify(struct enic *enic);
34int enic_dev_set_ig_vlan_rewrite_mode(struct enic *enic);
35int enic_dev_enable(struct enic *enic);
36int enic_dev_disable(struct enic *enic);
37int enic_vnic_dev_deinit(struct enic *enic);
38int enic_dev_init_prov2(struct enic *enic, struct vic_provinfo *vp);
39int enic_dev_deinit_done(struct enic *enic, int *status);
40int enic_dev_enable2(struct enic *enic, int arg);
41int enic_dev_enable2_done(struct enic *enic, int *status);
42int enic_dev_status_to_errno(int devcmd_status);
43
44#endif /* _ENIC_DEV_H_ */
diff --git a/drivers/net/enic/enic_main.c b/drivers/net/enic/enic_main.c
index 9aab85366d21..2f433fbfca0c 100644
--- a/drivers/net/enic/enic_main.c
+++ b/drivers/net/enic/enic_main.c
@@ -35,6 +35,7 @@
35#include <linux/ipv6.h> 35#include <linux/ipv6.h>
36#include <linux/tcp.h> 36#include <linux/tcp.h>
37#include <linux/rtnetlink.h> 37#include <linux/rtnetlink.h>
38#include <linux/prefetch.h>
38#include <net/ip6_checksum.h> 39#include <net/ip6_checksum.h>
39 40
40#include "cq_enet_desc.h" 41#include "cq_enet_desc.h"
@@ -44,6 +45,8 @@
44#include "vnic_vic.h" 45#include "vnic_vic.h"
45#include "enic_res.h" 46#include "enic_res.h"
46#include "enic.h" 47#include "enic.h"
48#include "enic_dev.h"
49#include "enic_pp.h"
47 50
48#define ENIC_NOTIFY_TIMER_PERIOD (2 * HZ) 51#define ENIC_NOTIFY_TIMER_PERIOD (2 * HZ)
49#define WQ_ENET_MAX_DESC_LEN (1 << WQ_ENET_LEN_BITS) 52#define WQ_ENET_MAX_DESC_LEN (1 << WQ_ENET_LEN_BITS)
@@ -122,6 +125,51 @@ static int enic_is_dynamic(struct enic *enic)
122 return enic->pdev->device == PCI_DEVICE_ID_CISCO_VIC_ENET_DYN; 125 return enic->pdev->device == PCI_DEVICE_ID_CISCO_VIC_ENET_DYN;
123} 126}
124 127
128static inline unsigned int enic_cq_rq(struct enic *enic, unsigned int rq)
129{
130 return rq;
131}
132
133static inline unsigned int enic_cq_wq(struct enic *enic, unsigned int wq)
134{
135 return enic->rq_count + wq;
136}
137
138static inline unsigned int enic_legacy_io_intr(void)
139{
140 return 0;
141}
142
143static inline unsigned int enic_legacy_err_intr(void)
144{
145 return 1;
146}
147
148static inline unsigned int enic_legacy_notify_intr(void)
149{
150 return 2;
151}
152
153static inline unsigned int enic_msix_rq_intr(struct enic *enic, unsigned int rq)
154{
155 return rq;
156}
157
158static inline unsigned int enic_msix_wq_intr(struct enic *enic, unsigned int wq)
159{
160 return enic->rq_count + wq;
161}
162
163static inline unsigned int enic_msix_err_intr(struct enic *enic)
164{
165 return enic->rq_count + enic->wq_count;
166}
167
168static inline unsigned int enic_msix_notify_intr(struct enic *enic)
169{
170 return enic->rq_count + enic->wq_count + 1;
171}
172
125static int enic_get_settings(struct net_device *netdev, 173static int enic_get_settings(struct net_device *netdev,
126 struct ethtool_cmd *ecmd) 174 struct ethtool_cmd *ecmd)
127{ 175{
@@ -133,10 +181,10 @@ static int enic_get_settings(struct net_device *netdev,
133 ecmd->transceiver = XCVR_EXTERNAL; 181 ecmd->transceiver = XCVR_EXTERNAL;
134 182
135 if (netif_carrier_ok(netdev)) { 183 if (netif_carrier_ok(netdev)) {
136 ecmd->speed = vnic_dev_port_speed(enic->vdev); 184 ethtool_cmd_speed_set(ecmd, vnic_dev_port_speed(enic->vdev));
137 ecmd->duplex = DUPLEX_FULL; 185 ecmd->duplex = DUPLEX_FULL;
138 } else { 186 } else {
139 ecmd->speed = -1; 187 ethtool_cmd_speed_set(ecmd, -1);
140 ecmd->duplex = -1; 188 ecmd->duplex = -1;
141 } 189 }
142 190
@@ -145,18 +193,6 @@ static int enic_get_settings(struct net_device *netdev,
145 return 0; 193 return 0;
146} 194}
147 195
148static int enic_dev_fw_info(struct enic *enic,
149 struct vnic_devcmd_fw_info **fw_info)
150{
151 int err;
152
153 spin_lock(&enic->devcmd_lock);
154 err = vnic_dev_fw_info(enic->vdev, fw_info);
155 spin_unlock(&enic->devcmd_lock);
156
157 return err;
158}
159
160static void enic_get_drvinfo(struct net_device *netdev, 196static void enic_get_drvinfo(struct net_device *netdev,
161 struct ethtool_drvinfo *drvinfo) 197 struct ethtool_drvinfo *drvinfo)
162{ 198{
@@ -201,17 +237,6 @@ static int enic_get_sset_count(struct net_device *netdev, int sset)
201 } 237 }
202} 238}
203 239
204static int enic_dev_stats_dump(struct enic *enic, struct vnic_stats **vstats)
205{
206 int err;
207
208 spin_lock(&enic->devcmd_lock);
209 err = vnic_dev_stats_dump(enic->vdev, vstats);
210 spin_unlock(&enic->devcmd_lock);
211
212 return err;
213}
214
215static void enic_get_ethtool_stats(struct net_device *netdev, 240static void enic_get_ethtool_stats(struct net_device *netdev,
216 struct ethtool_stats *stats, u64 *data) 241 struct ethtool_stats *stats, u64 *data)
217{ 242{
@@ -227,56 +252,6 @@ static void enic_get_ethtool_stats(struct net_device *netdev,
227 *(data++) = ((u64 *)&vstats->rx)[enic_rx_stats[i].offset]; 252 *(data++) = ((u64 *)&vstats->rx)[enic_rx_stats[i].offset];
228} 253}
229 254
230static u32 enic_get_rx_csum(struct net_device *netdev)
231{
232 struct enic *enic = netdev_priv(netdev);
233 return enic->csum_rx_enabled;
234}
235
236static int enic_set_rx_csum(struct net_device *netdev, u32 data)
237{
238 struct enic *enic = netdev_priv(netdev);
239
240 if (data && !ENIC_SETTING(enic, RXCSUM))
241 return -EINVAL;
242
243 enic->csum_rx_enabled = !!data;
244
245 return 0;
246}
247
248static int enic_set_tx_csum(struct net_device *netdev, u32 data)
249{
250 struct enic *enic = netdev_priv(netdev);
251
252 if (data && !ENIC_SETTING(enic, TXCSUM))
253 return -EINVAL;
254
255 if (data)
256 netdev->features |= NETIF_F_HW_CSUM;
257 else
258 netdev->features &= ~NETIF_F_HW_CSUM;
259
260 return 0;
261}
262
263static int enic_set_tso(struct net_device *netdev, u32 data)
264{
265 struct enic *enic = netdev_priv(netdev);
266
267 if (data && !ENIC_SETTING(enic, TSO))
268 return -EINVAL;
269
270 if (data)
271 netdev->features |=
272 NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN;
273 else
274 netdev->features &=
275 ~(NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN);
276
277 return 0;
278}
279
280static u32 enic_get_msglevel(struct net_device *netdev) 255static u32 enic_get_msglevel(struct net_device *netdev)
281{ 256{
282 struct enic *enic = netdev_priv(netdev); 257 struct enic *enic = netdev_priv(netdev);
@@ -306,6 +281,7 @@ static int enic_set_coalesce(struct net_device *netdev,
306 struct enic *enic = netdev_priv(netdev); 281 struct enic *enic = netdev_priv(netdev);
307 u32 tx_coalesce_usecs; 282 u32 tx_coalesce_usecs;
308 u32 rx_coalesce_usecs; 283 u32 rx_coalesce_usecs;
284 unsigned int i, intr;
309 285
310 tx_coalesce_usecs = min_t(u32, 286 tx_coalesce_usecs = min_t(u32,
311 INTR_COALESCE_HW_TO_USEC(VNIC_INTR_TIMER_MAX), 287 INTR_COALESCE_HW_TO_USEC(VNIC_INTR_TIMER_MAX),
@@ -319,7 +295,8 @@ static int enic_set_coalesce(struct net_device *netdev,
319 if (tx_coalesce_usecs != rx_coalesce_usecs) 295 if (tx_coalesce_usecs != rx_coalesce_usecs)
320 return -EINVAL; 296 return -EINVAL;
321 297
322 vnic_intr_coalescing_timer_set(&enic->intr[ENIC_INTX_WQ_RQ], 298 intr = enic_legacy_io_intr();
299 vnic_intr_coalescing_timer_set(&enic->intr[intr],
323 INTR_COALESCE_USEC_TO_HW(tx_coalesce_usecs)); 300 INTR_COALESCE_USEC_TO_HW(tx_coalesce_usecs));
324 break; 301 break;
325 case VNIC_DEV_INTR_MODE_MSI: 302 case VNIC_DEV_INTR_MODE_MSI:
@@ -330,10 +307,18 @@ static int enic_set_coalesce(struct net_device *netdev,
330 INTR_COALESCE_USEC_TO_HW(tx_coalesce_usecs)); 307 INTR_COALESCE_USEC_TO_HW(tx_coalesce_usecs));
331 break; 308 break;
332 case VNIC_DEV_INTR_MODE_MSIX: 309 case VNIC_DEV_INTR_MODE_MSIX:
333 vnic_intr_coalescing_timer_set(&enic->intr[ENIC_MSIX_WQ], 310 for (i = 0; i < enic->wq_count; i++) {
334 INTR_COALESCE_USEC_TO_HW(tx_coalesce_usecs)); 311 intr = enic_msix_wq_intr(enic, i);
335 vnic_intr_coalescing_timer_set(&enic->intr[ENIC_MSIX_RQ], 312 vnic_intr_coalescing_timer_set(&enic->intr[intr],
336 INTR_COALESCE_USEC_TO_HW(rx_coalesce_usecs)); 313 INTR_COALESCE_USEC_TO_HW(tx_coalesce_usecs));
314 }
315
316 for (i = 0; i < enic->rq_count; i++) {
317 intr = enic_msix_rq_intr(enic, i);
318 vnic_intr_coalescing_timer_set(&enic->intr[intr],
319 INTR_COALESCE_USEC_TO_HW(rx_coalesce_usecs));
320 }
321
337 break; 322 break;
338 default: 323 default:
339 break; 324 break;
@@ -354,17 +339,8 @@ static const struct ethtool_ops enic_ethtool_ops = {
354 .get_strings = enic_get_strings, 339 .get_strings = enic_get_strings,
355 .get_sset_count = enic_get_sset_count, 340 .get_sset_count = enic_get_sset_count,
356 .get_ethtool_stats = enic_get_ethtool_stats, 341 .get_ethtool_stats = enic_get_ethtool_stats,
357 .get_rx_csum = enic_get_rx_csum,
358 .set_rx_csum = enic_set_rx_csum,
359 .get_tx_csum = ethtool_op_get_tx_csum,
360 .set_tx_csum = enic_set_tx_csum,
361 .get_sg = ethtool_op_get_sg,
362 .set_sg = ethtool_op_set_sg,
363 .get_tso = ethtool_op_get_tso,
364 .set_tso = enic_set_tso,
365 .get_coalesce = enic_get_coalesce, 342 .get_coalesce = enic_get_coalesce,
366 .set_coalesce = enic_set_coalesce, 343 .set_coalesce = enic_set_coalesce,
367 .get_flags = ethtool_op_get_flags,
368}; 344};
369 345
370static void enic_free_wq_buf(struct vnic_wq *wq, struct vnic_wq_buf *buf) 346static void enic_free_wq_buf(struct vnic_wq *wq, struct vnic_wq_buf *buf)
@@ -482,34 +458,37 @@ static irqreturn_t enic_isr_legacy(int irq, void *data)
482{ 458{
483 struct net_device *netdev = data; 459 struct net_device *netdev = data;
484 struct enic *enic = netdev_priv(netdev); 460 struct enic *enic = netdev_priv(netdev);
461 unsigned int io_intr = enic_legacy_io_intr();
462 unsigned int err_intr = enic_legacy_err_intr();
463 unsigned int notify_intr = enic_legacy_notify_intr();
485 u32 pba; 464 u32 pba;
486 465
487 vnic_intr_mask(&enic->intr[ENIC_INTX_WQ_RQ]); 466 vnic_intr_mask(&enic->intr[io_intr]);
488 467
489 pba = vnic_intr_legacy_pba(enic->legacy_pba); 468 pba = vnic_intr_legacy_pba(enic->legacy_pba);
490 if (!pba) { 469 if (!pba) {
491 vnic_intr_unmask(&enic->intr[ENIC_INTX_WQ_RQ]); 470 vnic_intr_unmask(&enic->intr[io_intr]);
492 return IRQ_NONE; /* not our interrupt */ 471 return IRQ_NONE; /* not our interrupt */
493 } 472 }
494 473
495 if (ENIC_TEST_INTR(pba, ENIC_INTX_NOTIFY)) { 474 if (ENIC_TEST_INTR(pba, notify_intr)) {
496 vnic_intr_return_all_credits(&enic->intr[ENIC_INTX_NOTIFY]); 475 vnic_intr_return_all_credits(&enic->intr[notify_intr]);
497 enic_notify_check(enic); 476 enic_notify_check(enic);
498 } 477 }
499 478
500 if (ENIC_TEST_INTR(pba, ENIC_INTX_ERR)) { 479 if (ENIC_TEST_INTR(pba, err_intr)) {
501 vnic_intr_return_all_credits(&enic->intr[ENIC_INTX_ERR]); 480 vnic_intr_return_all_credits(&enic->intr[err_intr]);
502 enic_log_q_error(enic); 481 enic_log_q_error(enic);
503 /* schedule recovery from WQ/RQ error */ 482 /* schedule recovery from WQ/RQ error */
504 schedule_work(&enic->reset); 483 schedule_work(&enic->reset);
505 return IRQ_HANDLED; 484 return IRQ_HANDLED;
506 } 485 }
507 486
508 if (ENIC_TEST_INTR(pba, ENIC_INTX_WQ_RQ)) { 487 if (ENIC_TEST_INTR(pba, io_intr)) {
509 if (napi_schedule_prep(&enic->napi)) 488 if (napi_schedule_prep(&enic->napi[0]))
510 __napi_schedule(&enic->napi); 489 __napi_schedule(&enic->napi[0]);
511 } else { 490 } else {
512 vnic_intr_unmask(&enic->intr[ENIC_INTX_WQ_RQ]); 491 vnic_intr_unmask(&enic->intr[io_intr]);
513 } 492 }
514 493
515 return IRQ_HANDLED; 494 return IRQ_HANDLED;
@@ -535,17 +514,17 @@ static irqreturn_t enic_isr_msi(int irq, void *data)
535 * writes). 514 * writes).
536 */ 515 */
537 516
538 napi_schedule(&enic->napi); 517 napi_schedule(&enic->napi[0]);
539 518
540 return IRQ_HANDLED; 519 return IRQ_HANDLED;
541} 520}
542 521
543static irqreturn_t enic_isr_msix_rq(int irq, void *data) 522static irqreturn_t enic_isr_msix_rq(int irq, void *data)
544{ 523{
545 struct enic *enic = data; 524 struct napi_struct *napi = data;
546 525
547 /* schedule NAPI polling for RQ cleanup */ 526 /* schedule NAPI polling for RQ cleanup */
548 napi_schedule(&enic->napi); 527 napi_schedule(napi);
549 528
550 return IRQ_HANDLED; 529 return IRQ_HANDLED;
551} 530}
@@ -553,13 +532,15 @@ static irqreturn_t enic_isr_msix_rq(int irq, void *data)
553static irqreturn_t enic_isr_msix_wq(int irq, void *data) 532static irqreturn_t enic_isr_msix_wq(int irq, void *data)
554{ 533{
555 struct enic *enic = data; 534 struct enic *enic = data;
535 unsigned int cq = enic_cq_wq(enic, 0);
536 unsigned int intr = enic_msix_wq_intr(enic, 0);
556 unsigned int wq_work_to_do = -1; /* no limit */ 537 unsigned int wq_work_to_do = -1; /* no limit */
557 unsigned int wq_work_done; 538 unsigned int wq_work_done;
558 539
559 wq_work_done = vnic_cq_service(&enic->cq[ENIC_CQ_WQ], 540 wq_work_done = vnic_cq_service(&enic->cq[cq],
560 wq_work_to_do, enic_wq_service, NULL); 541 wq_work_to_do, enic_wq_service, NULL);
561 542
562 vnic_intr_return_credits(&enic->intr[ENIC_MSIX_WQ], 543 vnic_intr_return_credits(&enic->intr[intr],
563 wq_work_done, 544 wq_work_done,
564 1 /* unmask intr */, 545 1 /* unmask intr */,
565 1 /* reset intr timer */); 546 1 /* reset intr timer */);
@@ -570,8 +551,9 @@ static irqreturn_t enic_isr_msix_wq(int irq, void *data)
570static irqreturn_t enic_isr_msix_err(int irq, void *data) 551static irqreturn_t enic_isr_msix_err(int irq, void *data)
571{ 552{
572 struct enic *enic = data; 553 struct enic *enic = data;
554 unsigned int intr = enic_msix_err_intr(enic);
573 555
574 vnic_intr_return_all_credits(&enic->intr[ENIC_MSIX_ERR]); 556 vnic_intr_return_all_credits(&enic->intr[intr]);
575 557
576 enic_log_q_error(enic); 558 enic_log_q_error(enic);
577 559
@@ -584,8 +566,9 @@ static irqreturn_t enic_isr_msix_err(int irq, void *data)
584static irqreturn_t enic_isr_msix_notify(int irq, void *data) 566static irqreturn_t enic_isr_msix_notify(int irq, void *data)
585{ 567{
586 struct enic *enic = data; 568 struct enic *enic = data;
569 unsigned int intr = enic_msix_notify_intr(enic);
587 570
588 vnic_intr_return_all_credits(&enic->intr[ENIC_MSIX_NOTIFY]); 571 vnic_intr_return_all_credits(&enic->intr[intr]);
589 enic_notify_check(enic); 572 enic_notify_check(enic);
590 573
591 return IRQ_HANDLED; 574 return IRQ_HANDLED;
@@ -640,7 +623,7 @@ static inline void enic_queue_wq_skb_csum_l4(struct enic *enic,
640{ 623{
641 unsigned int head_len = skb_headlen(skb); 624 unsigned int head_len = skb_headlen(skb);
642 unsigned int len_left = skb->len - head_len; 625 unsigned int len_left = skb->len - head_len;
643 unsigned int hdr_len = skb_transport_offset(skb); 626 unsigned int hdr_len = skb_checksum_start_offset(skb);
644 unsigned int csum_offset = hdr_len + skb->csum_offset; 627 unsigned int csum_offset = hdr_len + skb->csum_offset;
645 int eop = (len_left == 0); 628 int eop = (len_left == 0);
646 629
@@ -743,7 +726,7 @@ static inline void enic_queue_wq_skb(struct enic *enic,
743 int vlan_tag_insert = 0; 726 int vlan_tag_insert = 0;
744 int loopback = 0; 727 int loopback = 0;
745 728
746 if (enic->vlan_group && vlan_tx_tag_present(skb)) { 729 if (vlan_tx_tag_present(skb)) {
747 /* VLAN tag from trunking driver */ 730 /* VLAN tag from trunking driver */
748 vlan_tag_insert = 1; 731 vlan_tag_insert = 1;
749 vlan_tag = vlan_tx_tag_get(skb); 732 vlan_tag = vlan_tx_tag_get(skb);
@@ -834,9 +817,10 @@ static struct net_device_stats *enic_get_stats(struct net_device *netdev)
834 return net_stats; 817 return net_stats;
835} 818}
836 819
837static void enic_reset_multicast_list(struct enic *enic) 820void enic_reset_addr_lists(struct enic *enic)
838{ 821{
839 enic->mc_count = 0; 822 enic->mc_count = 0;
823 enic->uc_count = 0;
840 enic->flags = 0; 824 enic->flags = 0;
841} 825}
842 826
@@ -857,32 +841,6 @@ static int enic_set_mac_addr(struct net_device *netdev, char *addr)
857 return 0; 841 return 0;
858} 842}
859 843
860static int enic_dev_add_station_addr(struct enic *enic)
861{
862 int err = 0;
863
864 if (is_valid_ether_addr(enic->netdev->dev_addr)) {
865 spin_lock(&enic->devcmd_lock);
866 err = vnic_dev_add_addr(enic->vdev, enic->netdev->dev_addr);
867 spin_unlock(&enic->devcmd_lock);
868 }
869
870 return err;
871}
872
873static int enic_dev_del_station_addr(struct enic *enic)
874{
875 int err = 0;
876
877 if (is_valid_ether_addr(enic->netdev->dev_addr)) {
878 spin_lock(&enic->devcmd_lock);
879 err = vnic_dev_del_addr(enic->vdev, enic->netdev->dev_addr);
880 spin_unlock(&enic->devcmd_lock);
881 }
882
883 return err;
884}
885
886static int enic_set_mac_address_dynamic(struct net_device *netdev, void *p) 844static int enic_set_mac_address_dynamic(struct net_device *netdev, void *p)
887{ 845{
888 struct enic *enic = netdev_priv(netdev); 846 struct enic *enic = netdev_priv(netdev);
@@ -911,67 +869,35 @@ static int enic_set_mac_address_dynamic(struct net_device *netdev, void *p)
911 869
912static int enic_set_mac_address(struct net_device *netdev, void *p) 870static int enic_set_mac_address(struct net_device *netdev, void *p)
913{ 871{
914 return -EOPNOTSUPP; 872 struct sockaddr *saddr = p;
915} 873 char *addr = saddr->sa_data;
916 874 struct enic *enic = netdev_priv(netdev);
917static int enic_dev_packet_filter(struct enic *enic, int directed,
918 int multicast, int broadcast, int promisc, int allmulti)
919{
920 int err;
921
922 spin_lock(&enic->devcmd_lock);
923 err = vnic_dev_packet_filter(enic->vdev, directed,
924 multicast, broadcast, promisc, allmulti);
925 spin_unlock(&enic->devcmd_lock);
926
927 return err;
928}
929
930static int enic_dev_add_multicast_addr(struct enic *enic, u8 *addr)
931{
932 int err; 875 int err;
933 876
934 spin_lock(&enic->devcmd_lock); 877 err = enic_dev_del_station_addr(enic);
935 err = vnic_dev_add_addr(enic->vdev, addr); 878 if (err)
936 spin_unlock(&enic->devcmd_lock); 879 return err;
937
938 return err;
939}
940
941static int enic_dev_del_multicast_addr(struct enic *enic, u8 *addr)
942{
943 int err;
944 880
945 spin_lock(&enic->devcmd_lock); 881 err = enic_set_mac_addr(netdev, addr);
946 err = vnic_dev_del_addr(enic->vdev, addr); 882 if (err)
947 spin_unlock(&enic->devcmd_lock); 883 return err;
948 884
949 return err; 885 return enic_dev_add_station_addr(enic);
950} 886}
951 887
952/* netif_tx_lock held, BHs disabled */ 888static void enic_update_multicast_addr_list(struct enic *enic)
953static void enic_set_multicast_list(struct net_device *netdev)
954{ 889{
955 struct enic *enic = netdev_priv(netdev); 890 struct net_device *netdev = enic->netdev;
956 struct netdev_hw_addr *ha; 891 struct netdev_hw_addr *ha;
957 int directed = 1;
958 int multicast = (netdev->flags & IFF_MULTICAST) ? 1 : 0;
959 int broadcast = (netdev->flags & IFF_BROADCAST) ? 1 : 0;
960 int promisc = (netdev->flags & IFF_PROMISC) ? 1 : 0;
961 unsigned int mc_count = netdev_mc_count(netdev); 892 unsigned int mc_count = netdev_mc_count(netdev);
962 int allmulti = (netdev->flags & IFF_ALLMULTI) ||
963 mc_count > ENIC_MULTICAST_PERFECT_FILTERS;
964 unsigned int flags = netdev->flags | (allmulti ? IFF_ALLMULTI : 0);
965 u8 mc_addr[ENIC_MULTICAST_PERFECT_FILTERS][ETH_ALEN]; 893 u8 mc_addr[ENIC_MULTICAST_PERFECT_FILTERS][ETH_ALEN];
966 unsigned int i, j; 894 unsigned int i, j;
967 895
968 if (mc_count > ENIC_MULTICAST_PERFECT_FILTERS) 896 if (mc_count > ENIC_MULTICAST_PERFECT_FILTERS) {
897 netdev_warn(netdev, "Registering only %d out of %d "
898 "multicast addresses\n",
899 ENIC_MULTICAST_PERFECT_FILTERS, mc_count);
969 mc_count = ENIC_MULTICAST_PERFECT_FILTERS; 900 mc_count = ENIC_MULTICAST_PERFECT_FILTERS;
970
971 if (enic->flags != flags) {
972 enic->flags = flags;
973 enic_dev_packet_filter(enic, directed,
974 multicast, broadcast, promisc, allmulti);
975 } 901 }
976 902
977 /* Is there an easier way? Trying to minimize to 903 /* Is there an easier way? Trying to minimize to
@@ -993,7 +919,7 @@ static void enic_set_multicast_list(struct net_device *netdev)
993 mc_addr[j]) == 0) 919 mc_addr[j]) == 0)
994 break; 920 break;
995 if (j == mc_count) 921 if (j == mc_count)
996 enic_dev_del_multicast_addr(enic, enic->mc_addr[i]); 922 enic_dev_del_addr(enic, enic->mc_addr[i]);
997 } 923 }
998 924
999 for (i = 0; i < mc_count; i++) { 925 for (i = 0; i < mc_count; i++) {
@@ -1002,7 +928,7 @@ static void enic_set_multicast_list(struct net_device *netdev)
1002 enic->mc_addr[j]) == 0) 928 enic->mc_addr[j]) == 0)
1003 break; 929 break;
1004 if (j == enic->mc_count) 930 if (j == enic->mc_count)
1005 enic_dev_add_multicast_addr(enic, mc_addr[i]); 931 enic_dev_add_addr(enic, mc_addr[i]);
1006 } 932 }
1007 933
1008 /* Save the list to compare against next time 934 /* Save the list to compare against next time
@@ -1014,151 +940,140 @@ static void enic_set_multicast_list(struct net_device *netdev)
1014 enic->mc_count = mc_count; 940 enic->mc_count = mc_count;
1015} 941}
1016 942
1017/* rtnl lock is held */ 943static void enic_update_unicast_addr_list(struct enic *enic)
1018static void enic_vlan_rx_register(struct net_device *netdev,
1019 struct vlan_group *vlan_group)
1020{ 944{
1021 struct enic *enic = netdev_priv(netdev); 945 struct net_device *netdev = enic->netdev;
1022 enic->vlan_group = vlan_group; 946 struct netdev_hw_addr *ha;
1023} 947 unsigned int uc_count = netdev_uc_count(netdev);
948 u8 uc_addr[ENIC_UNICAST_PERFECT_FILTERS][ETH_ALEN];
949 unsigned int i, j;
1024 950
1025/* rtnl lock is held */ 951 if (uc_count > ENIC_UNICAST_PERFECT_FILTERS) {
1026static void enic_vlan_rx_add_vid(struct net_device *netdev, u16 vid) 952 netdev_warn(netdev, "Registering only %d out of %d "
1027{ 953 "unicast addresses\n",
1028 struct enic *enic = netdev_priv(netdev); 954 ENIC_UNICAST_PERFECT_FILTERS, uc_count);
955 uc_count = ENIC_UNICAST_PERFECT_FILTERS;
956 }
1029 957
1030 spin_lock(&enic->devcmd_lock); 958 /* Is there an easier way? Trying to minimize to
1031 enic_add_vlan(enic, vid); 959 * calls to add/del unicast addrs. We keep the
1032 spin_unlock(&enic->devcmd_lock); 960 * addrs from the last call in enic->uc_addr and
1033} 961 * look for changes to add/del.
962 */
1034 963
1035/* rtnl lock is held */ 964 i = 0;
1036static void enic_vlan_rx_kill_vid(struct net_device *netdev, u16 vid) 965 netdev_for_each_uc_addr(ha, netdev) {
1037{ 966 if (i == uc_count)
1038 struct enic *enic = netdev_priv(netdev); 967 break;
968 memcpy(uc_addr[i++], ha->addr, ETH_ALEN);
969 }
1039 970
1040 spin_lock(&enic->devcmd_lock); 971 for (i = 0; i < enic->uc_count; i++) {
1041 enic_del_vlan(enic, vid); 972 for (j = 0; j < uc_count; j++)
1042 spin_unlock(&enic->devcmd_lock); 973 if (compare_ether_addr(enic->uc_addr[i],
1043} 974 uc_addr[j]) == 0)
975 break;
976 if (j == uc_count)
977 enic_dev_del_addr(enic, enic->uc_addr[i]);
978 }
1044 979
1045/* netif_tx_lock held, BHs disabled */ 980 for (i = 0; i < uc_count; i++) {
1046static void enic_tx_timeout(struct net_device *netdev) 981 for (j = 0; j < enic->uc_count; j++)
1047{ 982 if (compare_ether_addr(uc_addr[i],
1048 struct enic *enic = netdev_priv(netdev); 983 enic->uc_addr[j]) == 0)
1049 schedule_work(&enic->reset); 984 break;
1050} 985 if (j == enic->uc_count)
986 enic_dev_add_addr(enic, uc_addr[i]);
987 }
1051 988
1052static int enic_vnic_dev_deinit(struct enic *enic) 989 /* Save the list to compare against next time
1053{ 990 */
1054 int err;
1055 991
1056 spin_lock(&enic->devcmd_lock); 992 for (i = 0; i < uc_count; i++)
1057 err = vnic_dev_deinit(enic->vdev); 993 memcpy(enic->uc_addr[i], uc_addr[i], ETH_ALEN);
1058 spin_unlock(&enic->devcmd_lock);
1059 994
1060 return err; 995 enic->uc_count = uc_count;
1061} 996}
1062 997
1063static int enic_dev_init_prov(struct enic *enic, struct vic_provinfo *vp) 998/* netif_tx_lock held, BHs disabled */
999static void enic_set_rx_mode(struct net_device *netdev)
1064{ 1000{
1065 int err; 1001 struct enic *enic = netdev_priv(netdev);
1002 int directed = 1;
1003 int multicast = (netdev->flags & IFF_MULTICAST) ? 1 : 0;
1004 int broadcast = (netdev->flags & IFF_BROADCAST) ? 1 : 0;
1005 int promisc = (netdev->flags & IFF_PROMISC) ||
1006 netdev_uc_count(netdev) > ENIC_UNICAST_PERFECT_FILTERS;
1007 int allmulti = (netdev->flags & IFF_ALLMULTI) ||
1008 netdev_mc_count(netdev) > ENIC_MULTICAST_PERFECT_FILTERS;
1009 unsigned int flags = netdev->flags |
1010 (allmulti ? IFF_ALLMULTI : 0) |
1011 (promisc ? IFF_PROMISC : 0);
1066 1012
1067 spin_lock(&enic->devcmd_lock); 1013 if (enic->flags != flags) {
1068 err = vnic_dev_init_prov(enic->vdev, 1014 enic->flags = flags;
1069 (u8 *)vp, vic_provinfo_size(vp)); 1015 enic_dev_packet_filter(enic, directed,
1070 spin_unlock(&enic->devcmd_lock); 1016 multicast, broadcast, promisc, allmulti);
1017 }
1071 1018
1072 return err; 1019 if (!promisc) {
1020 enic_update_unicast_addr_list(enic);
1021 if (!allmulti)
1022 enic_update_multicast_addr_list(enic);
1023 }
1073} 1024}
1074 1025
1075static int enic_dev_init_done(struct enic *enic, int *done, int *error) 1026/* rtnl lock is held */
1027static void enic_vlan_rx_register(struct net_device *netdev,
1028 struct vlan_group *vlan_group)
1076{ 1029{
1077 int err; 1030 struct enic *enic = netdev_priv(netdev);
1078 1031 enic->vlan_group = vlan_group;
1079 spin_lock(&enic->devcmd_lock);
1080 err = vnic_dev_init_done(enic->vdev, done, error);
1081 spin_unlock(&enic->devcmd_lock);
1082
1083 return err;
1084} 1032}
1085 1033
1086static int enic_set_port_profile(struct enic *enic, u8 *mac) 1034/* netif_tx_lock held, BHs disabled */
1035static void enic_tx_timeout(struct net_device *netdev)
1087{ 1036{
1088 struct vic_provinfo *vp; 1037 struct enic *enic = netdev_priv(netdev);
1089 u8 oui[3] = VIC_PROVINFO_CISCO_OUI; 1038 schedule_work(&enic->reset);
1090 char uuid_str[38]; 1039}
1091 int err;
1092
1093 err = enic_vnic_dev_deinit(enic);
1094 if (err)
1095 return err;
1096
1097 switch (enic->pp.request) {
1098
1099 case PORT_REQUEST_ASSOCIATE:
1100
1101 if (!(enic->pp.set & ENIC_SET_NAME) || !strlen(enic->pp.name))
1102 return -EINVAL;
1103
1104 if (!is_valid_ether_addr(mac))
1105 return -EADDRNOTAVAIL;
1106
1107 vp = vic_provinfo_alloc(GFP_KERNEL, oui,
1108 VIC_PROVINFO_LINUX_TYPE);
1109 if (!vp)
1110 return -ENOMEM;
1111
1112 vic_provinfo_add_tlv(vp,
1113 VIC_LINUX_PROV_TLV_PORT_PROFILE_NAME_STR,
1114 strlen(enic->pp.name) + 1, enic->pp.name);
1115
1116 vic_provinfo_add_tlv(vp,
1117 VIC_LINUX_PROV_TLV_CLIENT_MAC_ADDR,
1118 ETH_ALEN, mac);
1119
1120 if (enic->pp.set & ENIC_SET_INSTANCE) {
1121 sprintf(uuid_str, "%pUB", enic->pp.instance_uuid);
1122 vic_provinfo_add_tlv(vp,
1123 VIC_LINUX_PROV_TLV_CLIENT_UUID_STR,
1124 sizeof(uuid_str), uuid_str);
1125 }
1126
1127 if (enic->pp.set & ENIC_SET_HOST) {
1128 sprintf(uuid_str, "%pUB", enic->pp.host_uuid);
1129 vic_provinfo_add_tlv(vp,
1130 VIC_LINUX_PROV_TLV_HOST_UUID_STR,
1131 sizeof(uuid_str), uuid_str);
1132 }
1133 1040
1134 err = enic_dev_init_prov(enic, vp); 1041static int enic_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1135 vic_provinfo_free(vp); 1042{
1136 if (err) 1043 struct enic *enic = netdev_priv(netdev);
1137 return err;
1138 break;
1139 1044
1140 case PORT_REQUEST_DISASSOCIATE: 1045 if (vf != PORT_SELF_VF)
1141 break; 1046 return -EOPNOTSUPP;
1142 1047
1143 default: 1048 /* Ignore the vf argument for now. We can assume the request
1049 * is coming on a vf.
1050 */
1051 if (is_valid_ether_addr(mac)) {
1052 memcpy(enic->pp.vf_mac, mac, ETH_ALEN);
1053 return 0;
1054 } else
1144 return -EINVAL; 1055 return -EINVAL;
1145 }
1146
1147 enic->pp.set |= ENIC_SET_APPLIED;
1148 return 0;
1149} 1056}
1150 1057
1151static int enic_set_vf_port(struct net_device *netdev, int vf, 1058static int enic_set_vf_port(struct net_device *netdev, int vf,
1152 struct nlattr *port[]) 1059 struct nlattr *port[])
1153{ 1060{
1154 struct enic *enic = netdev_priv(netdev); 1061 struct enic *enic = netdev_priv(netdev);
1062 struct enic_port_profile prev_pp;
1063 int err = 0, restore_pp = 1;
1064
1065 /* don't support VFs, yet */
1066 if (vf != PORT_SELF_VF)
1067 return -EOPNOTSUPP;
1155 1068
1069 if (!port[IFLA_PORT_REQUEST])
1070 return -EOPNOTSUPP;
1071
1072 memcpy(&prev_pp, &enic->pp, sizeof(enic->pp));
1156 memset(&enic->pp, 0, sizeof(enic->pp)); 1073 memset(&enic->pp, 0, sizeof(enic->pp));
1157 1074
1158 if (port[IFLA_PORT_REQUEST]) { 1075 enic->pp.set |= ENIC_SET_REQUEST;
1159 enic->pp.set |= ENIC_SET_REQUEST; 1076 enic->pp.request = nla_get_u8(port[IFLA_PORT_REQUEST]);
1160 enic->pp.request = nla_get_u8(port[IFLA_PORT_REQUEST]);
1161 }
1162 1077
1163 if (port[IFLA_PORT_PROFILE]) { 1078 if (port[IFLA_PORT_PROFILE]) {
1164 enic->pp.set |= ENIC_SET_NAME; 1079 enic->pp.set |= ENIC_SET_NAME;
@@ -1178,59 +1093,55 @@ static int enic_set_vf_port(struct net_device *netdev, int vf,
1178 nla_data(port[IFLA_PORT_HOST_UUID]), PORT_UUID_MAX); 1093 nla_data(port[IFLA_PORT_HOST_UUID]), PORT_UUID_MAX);
1179 } 1094 }
1180 1095
1181 /* don't support VFs, yet */ 1096 /* Special case handling: mac came from IFLA_VF_MAC */
1182 if (vf != PORT_SELF_VF) 1097 if (!is_zero_ether_addr(prev_pp.vf_mac))
1183 return -EOPNOTSUPP; 1098 memcpy(enic->pp.mac_addr, prev_pp.vf_mac, ETH_ALEN);
1184 1099
1185 if (!(enic->pp.set & ENIC_SET_REQUEST)) 1100 if (is_zero_ether_addr(netdev->dev_addr))
1186 return -EOPNOTSUPP; 1101 random_ether_addr(netdev->dev_addr);
1187
1188 if (enic->pp.request == PORT_REQUEST_ASSOCIATE) {
1189 1102
1190 /* If the interface mac addr hasn't been assigned, 1103 err = enic_process_set_pp_request(enic, &prev_pp, &restore_pp);
1191 * assign a random mac addr before setting port- 1104 if (err) {
1192 * profile. 1105 if (restore_pp) {
1106 /* Things are still the way they were: Implicit
1107 * DISASSOCIATE failed
1108 */
1109 memcpy(&enic->pp, &prev_pp, sizeof(enic->pp));
1110 } else {
1111 memset(&enic->pp, 0, sizeof(enic->pp));
1112 memset(netdev->dev_addr, 0, ETH_ALEN);
1113 }
1114 } else {
1115 /* Set flag to indicate that the port assoc/disassoc
1116 * request has been sent out to fw
1193 */ 1117 */
1118 enic->pp.set |= ENIC_PORT_REQUEST_APPLIED;
1194 1119
1195 if (is_zero_ether_addr(netdev->dev_addr)) 1120 /* If DISASSOCIATE, clean up all assigned/saved macaddresses */
1196 random_ether_addr(netdev->dev_addr); 1121 if (enic->pp.request == PORT_REQUEST_DISASSOCIATE) {
1122 memset(enic->pp.mac_addr, 0, ETH_ALEN);
1123 memset(netdev->dev_addr, 0, ETH_ALEN);
1124 }
1197 } 1125 }
1198 1126
1199 return enic_set_port_profile(enic, netdev->dev_addr); 1127 memset(enic->pp.vf_mac, 0, ETH_ALEN);
1128
1129 return err;
1200} 1130}
1201 1131
1202static int enic_get_vf_port(struct net_device *netdev, int vf, 1132static int enic_get_vf_port(struct net_device *netdev, int vf,
1203 struct sk_buff *skb) 1133 struct sk_buff *skb)
1204{ 1134{
1205 struct enic *enic = netdev_priv(netdev); 1135 struct enic *enic = netdev_priv(netdev);
1206 int err, error, done;
1207 u16 response = PORT_PROFILE_RESPONSE_SUCCESS; 1136 u16 response = PORT_PROFILE_RESPONSE_SUCCESS;
1137 int err;
1208 1138
1209 if (!(enic->pp.set & ENIC_SET_APPLIED)) 1139 if (!(enic->pp.set & ENIC_PORT_REQUEST_APPLIED))
1210 return -ENODATA; 1140 return -ENODATA;
1211 1141
1212 err = enic_dev_init_done(enic, &done, &error); 1142 err = enic_process_get_pp_request(enic, enic->pp.request, &response);
1213 if (err) 1143 if (err)
1214 error = err; 1144 return err;
1215
1216 switch (error) {
1217 case ERR_SUCCESS:
1218 if (!done)
1219 response = PORT_PROFILE_RESPONSE_INPROGRESS;
1220 break;
1221 case ERR_EINVAL:
1222 response = PORT_PROFILE_RESPONSE_INVALID;
1223 break;
1224 case ERR_EBADSTATE:
1225 response = PORT_PROFILE_RESPONSE_BADSTATE;
1226 break;
1227 case ERR_ENOMEM:
1228 response = PORT_PROFILE_RESPONSE_INSUFFICIENT_RESOURCES;
1229 break;
1230 default:
1231 response = PORT_PROFILE_RESPONSE_ERROR;
1232 break;
1233 }
1234 1145
1235 NLA_PUT_U16(skb, IFLA_PORT_REQUEST, enic->pp.request); 1146 NLA_PUT_U16(skb, IFLA_PORT_REQUEST, enic->pp.request);
1236 NLA_PUT_U16(skb, IFLA_PORT_RESPONSE, response); 1147 NLA_PUT_U16(skb, IFLA_PORT_RESPONSE, response);
@@ -1284,62 +1195,6 @@ static int enic_rq_alloc_buf(struct vnic_rq *rq)
1284 return 0; 1195 return 0;
1285} 1196}
1286 1197
1287static int enic_rq_alloc_buf_a1(struct vnic_rq *rq)
1288{
1289 struct rq_enet_desc *desc = vnic_rq_next_desc(rq);
1290
1291 if (vnic_rq_posting_soon(rq)) {
1292
1293 /* SW workaround for A0 HW erratum: if we're just about
1294 * to write posted_index, insert a dummy desc
1295 * of type resvd
1296 */
1297
1298 rq_enet_desc_enc(desc, 0, RQ_ENET_TYPE_RESV2, 0);
1299 vnic_rq_post(rq, 0, 0, 0, 0);
1300 } else {
1301 return enic_rq_alloc_buf(rq);
1302 }
1303
1304 return 0;
1305}
1306
1307static int enic_dev_hw_version(struct enic *enic,
1308 enum vnic_dev_hw_version *hw_ver)
1309{
1310 int err;
1311
1312 spin_lock(&enic->devcmd_lock);
1313 err = vnic_dev_hw_version(enic->vdev, hw_ver);
1314 spin_unlock(&enic->devcmd_lock);
1315
1316 return err;
1317}
1318
1319static int enic_set_rq_alloc_buf(struct enic *enic)
1320{
1321 enum vnic_dev_hw_version hw_ver;
1322 int err;
1323
1324 err = enic_dev_hw_version(enic, &hw_ver);
1325 if (err)
1326 return err;
1327
1328 switch (hw_ver) {
1329 case VNIC_DEV_HW_VER_A1:
1330 enic->rq_alloc_buf = enic_rq_alloc_buf_a1;
1331 break;
1332 case VNIC_DEV_HW_VER_A2:
1333 case VNIC_DEV_HW_VER_UNKNOWN:
1334 enic->rq_alloc_buf = enic_rq_alloc_buf;
1335 break;
1336 default:
1337 return -ENODEV;
1338 }
1339
1340 return 0;
1341}
1342
1343static void enic_rq_indicate_buf(struct vnic_rq *rq, 1198static void enic_rq_indicate_buf(struct vnic_rq *rq,
1344 struct cq_desc *cq_desc, struct vnic_rq_buf *buf, 1199 struct cq_desc *cq_desc, struct vnic_rq_buf *buf,
1345 int skipped, void *opaque) 1200 int skipped, void *opaque)
@@ -1396,7 +1251,7 @@ static void enic_rq_indicate_buf(struct vnic_rq *rq,
1396 skb_put(skb, bytes_written); 1251 skb_put(skb, bytes_written);
1397 skb->protocol = eth_type_trans(skb, netdev); 1252 skb->protocol = eth_type_trans(skb, netdev);
1398 1253
1399 if (enic->csum_rx_enabled && !csum_not_calc) { 1254 if ((netdev->features & NETIF_F_RXCSUM) && !csum_not_calc) {
1400 skb->csum = htons(checksum); 1255 skb->csum = htons(checksum);
1401 skb->ip_summed = CHECKSUM_COMPLETE; 1256 skb->ip_summed = CHECKSUM_COMPLETE;
1402 } 1257 }
@@ -1407,8 +1262,8 @@ static void enic_rq_indicate_buf(struct vnic_rq *rq,
1407 (vlan_tci & CQ_ENET_RQ_DESC_VLAN_TCI_VLAN_MASK)) { 1262 (vlan_tci & CQ_ENET_RQ_DESC_VLAN_TCI_VLAN_MASK)) {
1408 1263
1409 if (netdev->features & NETIF_F_GRO) 1264 if (netdev->features & NETIF_F_GRO)
1410 vlan_gro_receive(&enic->napi, enic->vlan_group, 1265 vlan_gro_receive(&enic->napi[q_number],
1411 vlan_tci, skb); 1266 enic->vlan_group, vlan_tci, skb);
1412 else 1267 else
1413 vlan_hwaccel_receive_skb(skb, 1268 vlan_hwaccel_receive_skb(skb,
1414 enic->vlan_group, vlan_tci); 1269 enic->vlan_group, vlan_tci);
@@ -1416,12 +1271,11 @@ static void enic_rq_indicate_buf(struct vnic_rq *rq,
1416 } else { 1271 } else {
1417 1272
1418 if (netdev->features & NETIF_F_GRO) 1273 if (netdev->features & NETIF_F_GRO)
1419 napi_gro_receive(&enic->napi, skb); 1274 napi_gro_receive(&enic->napi[q_number], skb);
1420 else 1275 else
1421 netif_receive_skb(skb); 1276 netif_receive_skb(skb);
1422 1277
1423 } 1278 }
1424
1425 } else { 1279 } else {
1426 1280
1427 /* Buffer overflow 1281 /* Buffer overflow
@@ -1445,7 +1299,11 @@ static int enic_rq_service(struct vnic_dev *vdev, struct cq_desc *cq_desc,
1445 1299
1446static int enic_poll(struct napi_struct *napi, int budget) 1300static int enic_poll(struct napi_struct *napi, int budget)
1447{ 1301{
1448 struct enic *enic = container_of(napi, struct enic, napi); 1302 struct net_device *netdev = napi->dev;
1303 struct enic *enic = netdev_priv(netdev);
1304 unsigned int cq_rq = enic_cq_rq(enic, 0);
1305 unsigned int cq_wq = enic_cq_wq(enic, 0);
1306 unsigned int intr = enic_legacy_io_intr();
1449 unsigned int rq_work_to_do = budget; 1307 unsigned int rq_work_to_do = budget;
1450 unsigned int wq_work_to_do = -1; /* no limit */ 1308 unsigned int wq_work_to_do = -1; /* no limit */
1451 unsigned int work_done, rq_work_done, wq_work_done; 1309 unsigned int work_done, rq_work_done, wq_work_done;
@@ -1454,10 +1312,10 @@ static int enic_poll(struct napi_struct *napi, int budget)
1454 /* Service RQ (first) and WQ 1312 /* Service RQ (first) and WQ
1455 */ 1313 */
1456 1314
1457 rq_work_done = vnic_cq_service(&enic->cq[ENIC_CQ_RQ], 1315 rq_work_done = vnic_cq_service(&enic->cq[cq_rq],
1458 rq_work_to_do, enic_rq_service, NULL); 1316 rq_work_to_do, enic_rq_service, NULL);
1459 1317
1460 wq_work_done = vnic_cq_service(&enic->cq[ENIC_CQ_WQ], 1318 wq_work_done = vnic_cq_service(&enic->cq[cq_wq],
1461 wq_work_to_do, enic_wq_service, NULL); 1319 wq_work_to_do, enic_wq_service, NULL);
1462 1320
1463 /* Accumulate intr event credits for this polling 1321 /* Accumulate intr event credits for this polling
@@ -1468,12 +1326,12 @@ static int enic_poll(struct napi_struct *napi, int budget)
1468 work_done = rq_work_done + wq_work_done; 1326 work_done = rq_work_done + wq_work_done;
1469 1327
1470 if (work_done > 0) 1328 if (work_done > 0)
1471 vnic_intr_return_credits(&enic->intr[ENIC_INTX_WQ_RQ], 1329 vnic_intr_return_credits(&enic->intr[intr],
1472 work_done, 1330 work_done,
1473 0 /* don't unmask intr */, 1331 0 /* don't unmask intr */,
1474 0 /* don't reset intr timer */); 1332 0 /* don't reset intr timer */);
1475 1333
1476 err = vnic_rq_fill(&enic->rq[0], enic->rq_alloc_buf); 1334 err = vnic_rq_fill(&enic->rq[0], enic_rq_alloc_buf);
1477 1335
1478 /* Buffer allocation failed. Stay in polling 1336 /* Buffer allocation failed. Stay in polling
1479 * mode so we can try to fill the ring again. 1337 * mode so we can try to fill the ring again.
@@ -1489,7 +1347,7 @@ static int enic_poll(struct napi_struct *napi, int budget)
1489 */ 1347 */
1490 1348
1491 napi_complete(napi); 1349 napi_complete(napi);
1492 vnic_intr_unmask(&enic->intr[ENIC_INTX_WQ_RQ]); 1350 vnic_intr_unmask(&enic->intr[intr]);
1493 } 1351 }
1494 1352
1495 return rq_work_done; 1353 return rq_work_done;
@@ -1497,7 +1355,11 @@ static int enic_poll(struct napi_struct *napi, int budget)
1497 1355
1498static int enic_poll_msix(struct napi_struct *napi, int budget) 1356static int enic_poll_msix(struct napi_struct *napi, int budget)
1499{ 1357{
1500 struct enic *enic = container_of(napi, struct enic, napi); 1358 struct net_device *netdev = napi->dev;
1359 struct enic *enic = netdev_priv(netdev);
1360 unsigned int rq = (napi - &enic->napi[0]);
1361 unsigned int cq = enic_cq_rq(enic, rq);
1362 unsigned int intr = enic_msix_rq_intr(enic, rq);
1501 unsigned int work_to_do = budget; 1363 unsigned int work_to_do = budget;
1502 unsigned int work_done; 1364 unsigned int work_done;
1503 int err; 1365 int err;
@@ -1505,7 +1367,7 @@ static int enic_poll_msix(struct napi_struct *napi, int budget)
1505 /* Service RQ 1367 /* Service RQ
1506 */ 1368 */
1507 1369
1508 work_done = vnic_cq_service(&enic->cq[ENIC_CQ_RQ], 1370 work_done = vnic_cq_service(&enic->cq[cq],
1509 work_to_do, enic_rq_service, NULL); 1371 work_to_do, enic_rq_service, NULL);
1510 1372
1511 /* Return intr event credits for this polling 1373 /* Return intr event credits for this polling
@@ -1514,12 +1376,12 @@ static int enic_poll_msix(struct napi_struct *napi, int budget)
1514 */ 1376 */
1515 1377
1516 if (work_done > 0) 1378 if (work_done > 0)
1517 vnic_intr_return_credits(&enic->intr[ENIC_MSIX_RQ], 1379 vnic_intr_return_credits(&enic->intr[intr],
1518 work_done, 1380 work_done,
1519 0 /* don't unmask intr */, 1381 0 /* don't unmask intr */,
1520 0 /* don't reset intr timer */); 1382 0 /* don't reset intr timer */);
1521 1383
1522 err = vnic_rq_fill(&enic->rq[0], enic->rq_alloc_buf); 1384 err = vnic_rq_fill(&enic->rq[rq], enic_rq_alloc_buf);
1523 1385
1524 /* Buffer allocation failed. Stay in polling mode 1386 /* Buffer allocation failed. Stay in polling mode
1525 * so we can try to fill the ring again. 1387 * so we can try to fill the ring again.
@@ -1535,7 +1397,7 @@ static int enic_poll_msix(struct napi_struct *napi, int budget)
1535 */ 1397 */
1536 1398
1537 napi_complete(napi); 1399 napi_complete(napi);
1538 vnic_intr_unmask(&enic->intr[ENIC_MSIX_RQ]); 1400 vnic_intr_unmask(&enic->intr[intr]);
1539 } 1401 }
1540 1402
1541 return work_done; 1403 return work_done;
@@ -1577,7 +1439,7 @@ static void enic_free_intr(struct enic *enic)
1577static int enic_request_intr(struct enic *enic) 1439static int enic_request_intr(struct enic *enic)
1578{ 1440{
1579 struct net_device *netdev = enic->netdev; 1441 struct net_device *netdev = enic->netdev;
1580 unsigned int i; 1442 unsigned int i, intr;
1581 int err = 0; 1443 int err = 0;
1582 1444
1583 switch (vnic_dev_get_intr_mode(enic->vdev)) { 1445 switch (vnic_dev_get_intr_mode(enic->vdev)) {
@@ -1596,27 +1458,38 @@ static int enic_request_intr(struct enic *enic)
1596 1458
1597 case VNIC_DEV_INTR_MODE_MSIX: 1459 case VNIC_DEV_INTR_MODE_MSIX:
1598 1460
1599 sprintf(enic->msix[ENIC_MSIX_RQ].devname, 1461 for (i = 0; i < enic->rq_count; i++) {
1600 "%.11s-rx-0", netdev->name); 1462 intr = enic_msix_rq_intr(enic, i);
1601 enic->msix[ENIC_MSIX_RQ].isr = enic_isr_msix_rq; 1463 sprintf(enic->msix[intr].devname,
1602 enic->msix[ENIC_MSIX_RQ].devid = enic; 1464 "%.11s-rx-%d", netdev->name, i);
1465 enic->msix[intr].isr = enic_isr_msix_rq;
1466 enic->msix[intr].devid = &enic->napi[i];
1467 }
1603 1468
1604 sprintf(enic->msix[ENIC_MSIX_WQ].devname, 1469 for (i = 0; i < enic->wq_count; i++) {
1605 "%.11s-tx-0", netdev->name); 1470 intr = enic_msix_wq_intr(enic, i);
1606 enic->msix[ENIC_MSIX_WQ].isr = enic_isr_msix_wq; 1471 sprintf(enic->msix[intr].devname,
1607 enic->msix[ENIC_MSIX_WQ].devid = enic; 1472 "%.11s-tx-%d", netdev->name, i);
1473 enic->msix[intr].isr = enic_isr_msix_wq;
1474 enic->msix[intr].devid = enic;
1475 }
1608 1476
1609 sprintf(enic->msix[ENIC_MSIX_ERR].devname, 1477 intr = enic_msix_err_intr(enic);
1478 sprintf(enic->msix[intr].devname,
1610 "%.11s-err", netdev->name); 1479 "%.11s-err", netdev->name);
1611 enic->msix[ENIC_MSIX_ERR].isr = enic_isr_msix_err; 1480 enic->msix[intr].isr = enic_isr_msix_err;
1612 enic->msix[ENIC_MSIX_ERR].devid = enic; 1481 enic->msix[intr].devid = enic;
1613 1482
1614 sprintf(enic->msix[ENIC_MSIX_NOTIFY].devname, 1483 intr = enic_msix_notify_intr(enic);
1484 sprintf(enic->msix[intr].devname,
1615 "%.11s-notify", netdev->name); 1485 "%.11s-notify", netdev->name);
1616 enic->msix[ENIC_MSIX_NOTIFY].isr = enic_isr_msix_notify; 1486 enic->msix[intr].isr = enic_isr_msix_notify;
1617 enic->msix[ENIC_MSIX_NOTIFY].devid = enic; 1487 enic->msix[intr].devid = enic;
1618 1488
1619 for (i = 0; i < ARRAY_SIZE(enic->msix); i++) { 1489 for (i = 0; i < ARRAY_SIZE(enic->msix); i++)
1490 enic->msix[i].requested = 0;
1491
1492 for (i = 0; i < enic->intr_count; i++) {
1620 err = request_irq(enic->msix_entry[i].vector, 1493 err = request_irq(enic->msix_entry[i].vector,
1621 enic->msix[i].isr, 0, 1494 enic->msix[i].isr, 0,
1622 enic->msix[i].devname, 1495 enic->msix[i].devname,
@@ -1662,10 +1535,12 @@ static int enic_dev_notify_set(struct enic *enic)
1662 spin_lock(&enic->devcmd_lock); 1535 spin_lock(&enic->devcmd_lock);
1663 switch (vnic_dev_get_intr_mode(enic->vdev)) { 1536 switch (vnic_dev_get_intr_mode(enic->vdev)) {
1664 case VNIC_DEV_INTR_MODE_INTX: 1537 case VNIC_DEV_INTR_MODE_INTX:
1665 err = vnic_dev_notify_set(enic->vdev, ENIC_INTX_NOTIFY); 1538 err = vnic_dev_notify_set(enic->vdev,
1539 enic_legacy_notify_intr());
1666 break; 1540 break;
1667 case VNIC_DEV_INTR_MODE_MSIX: 1541 case VNIC_DEV_INTR_MODE_MSIX:
1668 err = vnic_dev_notify_set(enic->vdev, ENIC_MSIX_NOTIFY); 1542 err = vnic_dev_notify_set(enic->vdev,
1543 enic_msix_notify_intr(enic));
1669 break; 1544 break;
1670 default: 1545 default:
1671 err = vnic_dev_notify_set(enic->vdev, -1 /* no intr */); 1546 err = vnic_dev_notify_set(enic->vdev, -1 /* no intr */);
@@ -1676,39 +1551,6 @@ static int enic_dev_notify_set(struct enic *enic)
1676 return err; 1551 return err;
1677} 1552}
1678 1553
1679static int enic_dev_notify_unset(struct enic *enic)
1680{
1681 int err;
1682
1683 spin_lock(&enic->devcmd_lock);
1684 err = vnic_dev_notify_unset(enic->vdev);
1685 spin_unlock(&enic->devcmd_lock);
1686
1687 return err;
1688}
1689
1690static int enic_dev_enable(struct enic *enic)
1691{
1692 int err;
1693
1694 spin_lock(&enic->devcmd_lock);
1695 err = vnic_dev_enable(enic->vdev);
1696 spin_unlock(&enic->devcmd_lock);
1697
1698 return err;
1699}
1700
1701static int enic_dev_disable(struct enic *enic)
1702{
1703 int err;
1704
1705 spin_lock(&enic->devcmd_lock);
1706 err = vnic_dev_disable(enic->vdev);
1707 spin_unlock(&enic->devcmd_lock);
1708
1709 return err;
1710}
1711
1712static void enic_notify_timer_start(struct enic *enic) 1554static void enic_notify_timer_start(struct enic *enic)
1713{ 1555{
1714 switch (vnic_dev_get_intr_mode(enic->vdev)) { 1556 switch (vnic_dev_get_intr_mode(enic->vdev)) {
@@ -1742,7 +1584,7 @@ static int enic_open(struct net_device *netdev)
1742 } 1584 }
1743 1585
1744 for (i = 0; i < enic->rq_count; i++) { 1586 for (i = 0; i < enic->rq_count; i++) {
1745 vnic_rq_fill(&enic->rq[i], enic->rq_alloc_buf); 1587 vnic_rq_fill(&enic->rq[i], enic_rq_alloc_buf);
1746 /* Need at least one buffer on ring to get going */ 1588 /* Need at least one buffer on ring to get going */
1747 if (vnic_rq_desc_used(&enic->rq[i]) == 0) { 1589 if (vnic_rq_desc_used(&enic->rq[i]) == 0) {
1748 netdev_err(netdev, "Unable to alloc receive buffers\n"); 1590 netdev_err(netdev, "Unable to alloc receive buffers\n");
@@ -1756,11 +1598,17 @@ static int enic_open(struct net_device *netdev)
1756 for (i = 0; i < enic->rq_count; i++) 1598 for (i = 0; i < enic->rq_count; i++)
1757 vnic_rq_enable(&enic->rq[i]); 1599 vnic_rq_enable(&enic->rq[i]);
1758 1600
1759 enic_dev_add_station_addr(enic); 1601 if (enic_is_dynamic(enic) && !is_zero_ether_addr(enic->pp.mac_addr))
1760 enic_set_multicast_list(netdev); 1602 enic_dev_add_addr(enic, enic->pp.mac_addr);
1603 else
1604 enic_dev_add_station_addr(enic);
1605 enic_set_rx_mode(netdev);
1761 1606
1762 netif_wake_queue(netdev); 1607 netif_wake_queue(netdev);
1763 napi_enable(&enic->napi); 1608
1609 for (i = 0; i < enic->rq_count; i++)
1610 napi_enable(&enic->napi[i]);
1611
1764 enic_dev_enable(enic); 1612 enic_dev_enable(enic);
1765 1613
1766 for (i = 0; i < enic->intr_count; i++) 1614 for (i = 0; i < enic->intr_count; i++)
@@ -1795,10 +1643,16 @@ static int enic_stop(struct net_device *netdev)
1795 del_timer_sync(&enic->notify_timer); 1643 del_timer_sync(&enic->notify_timer);
1796 1644
1797 enic_dev_disable(enic); 1645 enic_dev_disable(enic);
1798 napi_disable(&enic->napi); 1646
1647 for (i = 0; i < enic->rq_count; i++)
1648 napi_disable(&enic->napi[i]);
1649
1799 netif_carrier_off(netdev); 1650 netif_carrier_off(netdev);
1800 netif_tx_disable(netdev); 1651 netif_tx_disable(netdev);
1801 enic_dev_del_station_addr(enic); 1652 if (enic_is_dynamic(enic) && !is_zero_ether_addr(enic->pp.mac_addr))
1653 enic_dev_del_addr(enic, enic->pp.mac_addr);
1654 else
1655 enic_dev_del_station_addr(enic);
1802 1656
1803 for (i = 0; i < enic->wq_count; i++) { 1657 for (i = 0; i < enic->wq_count; i++) {
1804 err = vnic_wq_disable(&enic->wq[i]); 1658 err = vnic_wq_disable(&enic->wq[i]);
@@ -1855,11 +1709,17 @@ static void enic_poll_controller(struct net_device *netdev)
1855{ 1709{
1856 struct enic *enic = netdev_priv(netdev); 1710 struct enic *enic = netdev_priv(netdev);
1857 struct vnic_dev *vdev = enic->vdev; 1711 struct vnic_dev *vdev = enic->vdev;
1712 unsigned int i, intr;
1858 1713
1859 switch (vnic_dev_get_intr_mode(vdev)) { 1714 switch (vnic_dev_get_intr_mode(vdev)) {
1860 case VNIC_DEV_INTR_MODE_MSIX: 1715 case VNIC_DEV_INTR_MODE_MSIX:
1861 enic_isr_msix_rq(enic->pdev->irq, enic); 1716 for (i = 0; i < enic->rq_count; i++) {
1862 enic_isr_msix_wq(enic->pdev->irq, enic); 1717 intr = enic_msix_rq_intr(enic, i);
1718 enic_isr_msix_rq(enic->msix_entry[intr].vector,
1719 &enic->napi[i]);
1720 }
1721 intr = enic_msix_wq_intr(enic, i);
1722 enic_isr_msix_wq(enic->msix_entry[intr].vector, enic);
1863 break; 1723 break;
1864 case VNIC_DEV_INTR_MODE_MSI: 1724 case VNIC_DEV_INTR_MODE_MSI:
1865 enic_isr_msi(enic->pdev->irq, enic); 1725 enic_isr_msi(enic->pdev->irq, enic);
@@ -1934,54 +1794,114 @@ static int enic_dev_hang_reset(struct enic *enic)
1934 return err; 1794 return err;
1935} 1795}
1936 1796
1937static int enic_set_niccfg(struct enic *enic) 1797static int enic_set_rsskey(struct enic *enic)
1938{ 1798{
1939 const u8 rss_default_cpu = 0; 1799 dma_addr_t rss_key_buf_pa;
1940 const u8 rss_hash_type = 0; 1800 union vnic_rss_key *rss_key_buf_va = NULL;
1941 const u8 rss_hash_bits = 0; 1801 union vnic_rss_key rss_key = {
1942 const u8 rss_base_cpu = 0; 1802 .key[0].b = {85, 67, 83, 97, 119, 101, 115, 111, 109, 101},
1943 const u8 rss_enable = 0; 1803 .key[1].b = {80, 65, 76, 79, 117, 110, 105, 113, 117, 101},
1944 const u8 tso_ipid_split_en = 0; 1804 .key[2].b = {76, 73, 78, 85, 88, 114, 111, 99, 107, 115},
1945 const u8 ig_vlan_strip_en = 1; 1805 .key[3].b = {69, 78, 73, 67, 105, 115, 99, 111, 111, 108},
1806 };
1946 int err; 1807 int err;
1947 1808
1948 /* Enable VLAN tag stripping. RSS not enabled (yet). 1809 rss_key_buf_va = pci_alloc_consistent(enic->pdev,
1949 */ 1810 sizeof(union vnic_rss_key), &rss_key_buf_pa);
1811 if (!rss_key_buf_va)
1812 return -ENOMEM;
1813
1814 memcpy(rss_key_buf_va, &rss_key, sizeof(union vnic_rss_key));
1950 1815
1951 spin_lock(&enic->devcmd_lock); 1816 spin_lock(&enic->devcmd_lock);
1952 err = enic_set_nic_cfg(enic, 1817 err = enic_set_rss_key(enic,
1953 rss_default_cpu, rss_hash_type, 1818 rss_key_buf_pa,
1954 rss_hash_bits, rss_base_cpu, 1819 sizeof(union vnic_rss_key));
1955 rss_enable, tso_ipid_split_en,
1956 ig_vlan_strip_en);
1957 spin_unlock(&enic->devcmd_lock); 1820 spin_unlock(&enic->devcmd_lock);
1958 1821
1822 pci_free_consistent(enic->pdev, sizeof(union vnic_rss_key),
1823 rss_key_buf_va, rss_key_buf_pa);
1824
1959 return err; 1825 return err;
1960} 1826}
1961 1827
1962static int enic_dev_hang_notify(struct enic *enic) 1828static int enic_set_rsscpu(struct enic *enic, u8 rss_hash_bits)
1963{ 1829{
1830 dma_addr_t rss_cpu_buf_pa;
1831 union vnic_rss_cpu *rss_cpu_buf_va = NULL;
1832 unsigned int i;
1964 int err; 1833 int err;
1965 1834
1835 rss_cpu_buf_va = pci_alloc_consistent(enic->pdev,
1836 sizeof(union vnic_rss_cpu), &rss_cpu_buf_pa);
1837 if (!rss_cpu_buf_va)
1838 return -ENOMEM;
1839
1840 for (i = 0; i < (1 << rss_hash_bits); i++)
1841 (*rss_cpu_buf_va).cpu[i/4].b[i%4] = i % enic->rq_count;
1842
1966 spin_lock(&enic->devcmd_lock); 1843 spin_lock(&enic->devcmd_lock);
1967 err = vnic_dev_hang_notify(enic->vdev); 1844 err = enic_set_rss_cpu(enic,
1845 rss_cpu_buf_pa,
1846 sizeof(union vnic_rss_cpu));
1968 spin_unlock(&enic->devcmd_lock); 1847 spin_unlock(&enic->devcmd_lock);
1969 1848
1849 pci_free_consistent(enic->pdev, sizeof(union vnic_rss_cpu),
1850 rss_cpu_buf_va, rss_cpu_buf_pa);
1851
1970 return err; 1852 return err;
1971} 1853}
1972 1854
1973int enic_dev_set_ig_vlan_rewrite_mode(struct enic *enic) 1855static int enic_set_niccfg(struct enic *enic, u8 rss_default_cpu,
1856 u8 rss_hash_type, u8 rss_hash_bits, u8 rss_base_cpu, u8 rss_enable)
1974{ 1857{
1858 const u8 tso_ipid_split_en = 0;
1859 const u8 ig_vlan_strip_en = 1;
1975 int err; 1860 int err;
1976 1861
1862 /* Enable VLAN tag stripping.
1863 */
1864
1977 spin_lock(&enic->devcmd_lock); 1865 spin_lock(&enic->devcmd_lock);
1978 err = vnic_dev_set_ig_vlan_rewrite_mode(enic->vdev, 1866 err = enic_set_nic_cfg(enic,
1979 IG_VLAN_REWRITE_MODE_PRIORITY_TAG_DEFAULT_VLAN); 1867 rss_default_cpu, rss_hash_type,
1868 rss_hash_bits, rss_base_cpu,
1869 rss_enable, tso_ipid_split_en,
1870 ig_vlan_strip_en);
1980 spin_unlock(&enic->devcmd_lock); 1871 spin_unlock(&enic->devcmd_lock);
1981 1872
1982 return err; 1873 return err;
1983} 1874}
1984 1875
1876static int enic_set_rss_nic_cfg(struct enic *enic)
1877{
1878 struct device *dev = enic_get_dev(enic);
1879 const u8 rss_default_cpu = 0;
1880 const u8 rss_hash_type = NIC_CFG_RSS_HASH_TYPE_IPV4 |
1881 NIC_CFG_RSS_HASH_TYPE_TCP_IPV4 |
1882 NIC_CFG_RSS_HASH_TYPE_IPV6 |
1883 NIC_CFG_RSS_HASH_TYPE_TCP_IPV6;
1884 const u8 rss_hash_bits = 7;
1885 const u8 rss_base_cpu = 0;
1886 u8 rss_enable = ENIC_SETTING(enic, RSS) && (enic->rq_count > 1);
1887
1888 if (rss_enable) {
1889 if (!enic_set_rsskey(enic)) {
1890 if (enic_set_rsscpu(enic, rss_hash_bits)) {
1891 rss_enable = 0;
1892 dev_warn(dev, "RSS disabled, "
1893 "Failed to set RSS cpu indirection table.");
1894 }
1895 } else {
1896 rss_enable = 0;
1897 dev_warn(dev, "RSS disabled, Failed to set RSS key.\n");
1898 }
1899 }
1900
1901 return enic_set_niccfg(enic, rss_default_cpu, rss_hash_type,
1902 rss_hash_bits, rss_base_cpu, rss_enable);
1903}
1904
1985static void enic_reset(struct work_struct *work) 1905static void enic_reset(struct work_struct *work)
1986{ 1906{
1987 struct enic *enic = container_of(work, struct enic, reset); 1907 struct enic *enic = container_of(work, struct enic, reset);
@@ -1994,9 +1914,9 @@ static void enic_reset(struct work_struct *work)
1994 enic_dev_hang_notify(enic); 1914 enic_dev_hang_notify(enic);
1995 enic_stop(enic->netdev); 1915 enic_stop(enic->netdev);
1996 enic_dev_hang_reset(enic); 1916 enic_dev_hang_reset(enic);
1997 enic_reset_multicast_list(enic); 1917 enic_reset_addr_lists(enic);
1998 enic_init_vnic_resources(enic); 1918 enic_init_vnic_resources(enic);
1999 enic_set_niccfg(enic); 1919 enic_set_rss_nic_cfg(enic);
2000 enic_dev_set_ig_vlan_rewrite_mode(enic); 1920 enic_dev_set_ig_vlan_rewrite_mode(enic);
2001 enic_open(enic->netdev); 1921 enic_open(enic->netdev);
2002 1922
@@ -2005,12 +1925,12 @@ static void enic_reset(struct work_struct *work)
2005 1925
2006static int enic_set_intr_mode(struct enic *enic) 1926static int enic_set_intr_mode(struct enic *enic)
2007{ 1927{
2008 unsigned int n = 1; 1928 unsigned int n = min_t(unsigned int, enic->rq_count, ENIC_RQ_MAX);
2009 unsigned int m = 1; 1929 unsigned int m = min_t(unsigned int, enic->wq_count, ENIC_WQ_MAX);
2010 unsigned int i; 1930 unsigned int i;
2011 1931
2012 /* Set interrupt mode (INTx, MSI, MSI-X) depending 1932 /* Set interrupt mode (INTx, MSI, MSI-X) depending
2013 * system capabilities. 1933 * on system capabilities.
2014 * 1934 *
2015 * Try MSI-X first 1935 * Try MSI-X first
2016 * 1936 *
@@ -2023,21 +1943,47 @@ static int enic_set_intr_mode(struct enic *enic)
2023 for (i = 0; i < n + m + 2; i++) 1943 for (i = 0; i < n + m + 2; i++)
2024 enic->msix_entry[i].entry = i; 1944 enic->msix_entry[i].entry = i;
2025 1945
2026 if (enic->config.intr_mode < 1 && 1946 /* Use multiple RQs if RSS is enabled
1947 */
1948
1949 if (ENIC_SETTING(enic, RSS) &&
1950 enic->config.intr_mode < 1 &&
2027 enic->rq_count >= n && 1951 enic->rq_count >= n &&
2028 enic->wq_count >= m && 1952 enic->wq_count >= m &&
2029 enic->cq_count >= n + m && 1953 enic->cq_count >= n + m &&
2030 enic->intr_count >= n + m + 2 && 1954 enic->intr_count >= n + m + 2) {
2031 !pci_enable_msix(enic->pdev, enic->msix_entry, n + m + 2)) {
2032 1955
2033 enic->rq_count = n; 1956 if (!pci_enable_msix(enic->pdev, enic->msix_entry, n + m + 2)) {
2034 enic->wq_count = m;
2035 enic->cq_count = n + m;
2036 enic->intr_count = n + m + 2;
2037 1957
2038 vnic_dev_set_intr_mode(enic->vdev, VNIC_DEV_INTR_MODE_MSIX); 1958 enic->rq_count = n;
1959 enic->wq_count = m;
1960 enic->cq_count = n + m;
1961 enic->intr_count = n + m + 2;
2039 1962
2040 return 0; 1963 vnic_dev_set_intr_mode(enic->vdev,
1964 VNIC_DEV_INTR_MODE_MSIX);
1965
1966 return 0;
1967 }
1968 }
1969
1970 if (enic->config.intr_mode < 1 &&
1971 enic->rq_count >= 1 &&
1972 enic->wq_count >= m &&
1973 enic->cq_count >= 1 + m &&
1974 enic->intr_count >= 1 + m + 2) {
1975 if (!pci_enable_msix(enic->pdev, enic->msix_entry, 1 + m + 2)) {
1976
1977 enic->rq_count = 1;
1978 enic->wq_count = m;
1979 enic->cq_count = 1 + m;
1980 enic->intr_count = 1 + m + 2;
1981
1982 vnic_dev_set_intr_mode(enic->vdev,
1983 VNIC_DEV_INTR_MODE_MSIX);
1984
1985 return 0;
1986 }
2041 } 1987 }
2042 1988
2043 /* Next try MSI 1989 /* Next try MSI
@@ -2113,7 +2059,8 @@ static const struct net_device_ops enic_netdev_dynamic_ops = {
2113 .ndo_start_xmit = enic_hard_start_xmit, 2059 .ndo_start_xmit = enic_hard_start_xmit,
2114 .ndo_get_stats = enic_get_stats, 2060 .ndo_get_stats = enic_get_stats,
2115 .ndo_validate_addr = eth_validate_addr, 2061 .ndo_validate_addr = eth_validate_addr,
2116 .ndo_set_multicast_list = enic_set_multicast_list, 2062 .ndo_set_rx_mode = enic_set_rx_mode,
2063 .ndo_set_multicast_list = enic_set_rx_mode,
2117 .ndo_set_mac_address = enic_set_mac_address_dynamic, 2064 .ndo_set_mac_address = enic_set_mac_address_dynamic,
2118 .ndo_change_mtu = enic_change_mtu, 2065 .ndo_change_mtu = enic_change_mtu,
2119 .ndo_vlan_rx_register = enic_vlan_rx_register, 2066 .ndo_vlan_rx_register = enic_vlan_rx_register,
@@ -2122,6 +2069,7 @@ static const struct net_device_ops enic_netdev_dynamic_ops = {
2122 .ndo_tx_timeout = enic_tx_timeout, 2069 .ndo_tx_timeout = enic_tx_timeout,
2123 .ndo_set_vf_port = enic_set_vf_port, 2070 .ndo_set_vf_port = enic_set_vf_port,
2124 .ndo_get_vf_port = enic_get_vf_port, 2071 .ndo_get_vf_port = enic_get_vf_port,
2072 .ndo_set_vf_mac = enic_set_vf_mac,
2125#ifdef CONFIG_NET_POLL_CONTROLLER 2073#ifdef CONFIG_NET_POLL_CONTROLLER
2126 .ndo_poll_controller = enic_poll_controller, 2074 .ndo_poll_controller = enic_poll_controller,
2127#endif 2075#endif
@@ -2134,7 +2082,8 @@ static const struct net_device_ops enic_netdev_ops = {
2134 .ndo_get_stats = enic_get_stats, 2082 .ndo_get_stats = enic_get_stats,
2135 .ndo_validate_addr = eth_validate_addr, 2083 .ndo_validate_addr = eth_validate_addr,
2136 .ndo_set_mac_address = enic_set_mac_address, 2084 .ndo_set_mac_address = enic_set_mac_address,
2137 .ndo_set_multicast_list = enic_set_multicast_list, 2085 .ndo_set_rx_mode = enic_set_rx_mode,
2086 .ndo_set_multicast_list = enic_set_rx_mode,
2138 .ndo_change_mtu = enic_change_mtu, 2087 .ndo_change_mtu = enic_change_mtu,
2139 .ndo_vlan_rx_register = enic_vlan_rx_register, 2088 .ndo_vlan_rx_register = enic_vlan_rx_register,
2140 .ndo_vlan_rx_add_vid = enic_vlan_rx_add_vid, 2089 .ndo_vlan_rx_add_vid = enic_vlan_rx_add_vid,
@@ -2145,28 +2094,22 @@ static const struct net_device_ops enic_netdev_ops = {
2145#endif 2094#endif
2146}; 2095};
2147 2096
2148void enic_dev_deinit(struct enic *enic) 2097static void enic_dev_deinit(struct enic *enic)
2149{
2150 netif_napi_del(&enic->napi);
2151 enic_free_vnic_resources(enic);
2152 enic_clear_intr_mode(enic);
2153}
2154
2155static int enic_dev_stats_clear(struct enic *enic)
2156{ 2098{
2157 int err; 2099 unsigned int i;
2158 2100
2159 spin_lock(&enic->devcmd_lock); 2101 for (i = 0; i < enic->rq_count; i++)
2160 err = vnic_dev_stats_clear(enic->vdev); 2102 netif_napi_del(&enic->napi[i]);
2161 spin_unlock(&enic->devcmd_lock);
2162 2103
2163 return err; 2104 enic_free_vnic_resources(enic);
2105 enic_clear_intr_mode(enic);
2164} 2106}
2165 2107
2166int enic_dev_init(struct enic *enic) 2108static int enic_dev_init(struct enic *enic)
2167{ 2109{
2168 struct device *dev = enic_get_dev(enic); 2110 struct device *dev = enic_get_dev(enic);
2169 struct net_device *netdev = enic->netdev; 2111 struct net_device *netdev = enic->netdev;
2112 unsigned int i;
2170 int err; 2113 int err;
2171 2114
2172 /* Get vNIC configuration 2115 /* Get vNIC configuration
@@ -2205,35 +2148,20 @@ int enic_dev_init(struct enic *enic)
2205 2148
2206 enic_init_vnic_resources(enic); 2149 enic_init_vnic_resources(enic);
2207 2150
2208 /* Clear LIF stats 2151 err = enic_set_rss_nic_cfg(enic);
2209 */
2210 enic_dev_stats_clear(enic);
2211
2212 err = enic_set_rq_alloc_buf(enic);
2213 if (err) {
2214 dev_err(dev, "Failed to set RQ buffer allocator, aborting\n");
2215 goto err_out_free_vnic_resources;
2216 }
2217
2218 err = enic_set_niccfg(enic);
2219 if (err) { 2152 if (err) {
2220 dev_err(dev, "Failed to config nic, aborting\n"); 2153 dev_err(dev, "Failed to config nic, aborting\n");
2221 goto err_out_free_vnic_resources; 2154 goto err_out_free_vnic_resources;
2222 } 2155 }
2223 2156
2224 err = enic_dev_set_ig_vlan_rewrite_mode(enic);
2225 if (err) {
2226 netdev_err(netdev,
2227 "Failed to set ingress vlan rewrite mode, aborting.\n");
2228 goto err_out_free_vnic_resources;
2229 }
2230
2231 switch (vnic_dev_get_intr_mode(enic->vdev)) { 2157 switch (vnic_dev_get_intr_mode(enic->vdev)) {
2232 default: 2158 default:
2233 netif_napi_add(netdev, &enic->napi, enic_poll, 64); 2159 netif_napi_add(netdev, &enic->napi[0], enic_poll, 64);
2234 break; 2160 break;
2235 case VNIC_DEV_INTR_MODE_MSIX: 2161 case VNIC_DEV_INTR_MODE_MSIX:
2236 netif_napi_add(netdev, &enic->napi, enic_poll_msix, 64); 2162 for (i = 0; i < enic->rq_count; i++)
2163 netif_napi_add(netdev, &enic->napi[i],
2164 enic_poll_msix, 64);
2237 break; 2165 break;
2238 } 2166 }
2239 2167
@@ -2364,6 +2292,22 @@ static int __devinit enic_probe(struct pci_dev *pdev,
2364 goto err_out_vnic_unregister; 2292 goto err_out_vnic_unregister;
2365 } 2293 }
2366 2294
2295 /* Setup devcmd lock
2296 */
2297
2298 spin_lock_init(&enic->devcmd_lock);
2299
2300 /*
2301 * Set ingress vlan rewrite mode before vnic initialization
2302 */
2303
2304 err = enic_dev_set_ig_vlan_rewrite_mode(enic);
2305 if (err) {
2306 dev_err(dev,
2307 "Failed to set ingress vlan rewrite mode, aborting.\n");
2308 goto err_out_dev_close;
2309 }
2310
2367 /* Issue device init to initialize the vnic-to-switch link. 2311 /* Issue device init to initialize the vnic-to-switch link.
2368 * We'll start with carrier off and wait for link UP 2312 * We'll start with carrier off and wait for link UP
2369 * notification later to turn on carrier. We don't need 2313 * notification later to turn on carrier. We don't need
@@ -2387,11 +2331,6 @@ static int __devinit enic_probe(struct pci_dev *pdev,
2387 } 2331 }
2388 } 2332 }
2389 2333
2390 /* Setup devcmd lock
2391 */
2392
2393 spin_lock_init(&enic->devcmd_lock);
2394
2395 err = enic_dev_init(enic); 2334 err = enic_dev_init(enic);
2396 if (err) { 2335 if (err) {
2397 dev_err(dev, "Device initialization failed, aborting\n"); 2336 dev_err(dev, "Device initialization failed, aborting\n");
@@ -2441,17 +2380,18 @@ static int __devinit enic_probe(struct pci_dev *pdev,
2441 dev_info(dev, "loopback tag=0x%04x\n", enic->loop_tag); 2380 dev_info(dev, "loopback tag=0x%04x\n", enic->loop_tag);
2442 } 2381 }
2443 if (ENIC_SETTING(enic, TXCSUM)) 2382 if (ENIC_SETTING(enic, TXCSUM))
2444 netdev->features |= NETIF_F_SG | NETIF_F_HW_CSUM; 2383 netdev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM;
2445 if (ENIC_SETTING(enic, TSO)) 2384 if (ENIC_SETTING(enic, TSO))
2446 netdev->features |= NETIF_F_TSO | 2385 netdev->hw_features |= NETIF_F_TSO |
2447 NETIF_F_TSO6 | NETIF_F_TSO_ECN; 2386 NETIF_F_TSO6 | NETIF_F_TSO_ECN;
2448 if (ENIC_SETTING(enic, LRO)) 2387 if (ENIC_SETTING(enic, RXCSUM))
2449 netdev->features |= NETIF_F_GRO; 2388 netdev->hw_features |= NETIF_F_RXCSUM;
2389
2390 netdev->features |= netdev->hw_features;
2391
2450 if (using_dac) 2392 if (using_dac)
2451 netdev->features |= NETIF_F_HIGHDMA; 2393 netdev->features |= NETIF_F_HIGHDMA;
2452 2394
2453 enic->csum_rx_enabled = ENIC_SETTING(enic, RXCSUM);
2454
2455 err = register_netdev(netdev); 2395 err = register_netdev(netdev);
2456 if (err) { 2396 if (err) {
2457 dev_err(dev, "Cannot register net device, aborting\n"); 2397 dev_err(dev, "Cannot register net device, aborting\n");
@@ -2486,7 +2426,7 @@ static void __devexit enic_remove(struct pci_dev *pdev)
2486 if (netdev) { 2426 if (netdev) {
2487 struct enic *enic = netdev_priv(netdev); 2427 struct enic *enic = netdev_priv(netdev);
2488 2428
2489 flush_scheduled_work(); 2429 cancel_work_sync(&enic->reset);
2490 unregister_netdev(netdev); 2430 unregister_netdev(netdev);
2491 enic_dev_deinit(enic); 2431 enic_dev_deinit(enic);
2492 vnic_dev_close(enic->vdev); 2432 vnic_dev_close(enic->vdev);
diff --git a/drivers/net/enic/enic_pp.c b/drivers/net/enic/enic_pp.c
new file mode 100644
index 000000000000..ffaa75dd1ded
--- /dev/null
+++ b/drivers/net/enic/enic_pp.c
@@ -0,0 +1,264 @@
1/*
2 * Copyright 2011 Cisco Systems, Inc. All rights reserved.
3 *
4 * This program is free software; you may redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; version 2 of the License.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
10 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
11 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
12 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
13 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
14 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
15 * SOFTWARE.
16 *
17 */
18
19#include <linux/kernel.h>
20#include <linux/string.h>
21#include <linux/errno.h>
22#include <linux/types.h>
23#include <linux/netdevice.h>
24#include <linux/etherdevice.h>
25#include <linux/rtnetlink.h>
26#include <net/ip.h>
27
28#include "vnic_vic.h"
29#include "enic_res.h"
30#include "enic.h"
31#include "enic_dev.h"
32
33static int enic_set_port_profile(struct enic *enic)
34{
35 struct net_device *netdev = enic->netdev;
36 struct vic_provinfo *vp;
37 const u8 oui[3] = VIC_PROVINFO_CISCO_OUI;
38 const u16 os_type = htons(VIC_GENERIC_PROV_OS_TYPE_LINUX);
39 char uuid_str[38];
40 char client_mac_str[18];
41 u8 *client_mac;
42 int err;
43
44 if (!(enic->pp.set & ENIC_SET_NAME) || !strlen(enic->pp.name))
45 return -EINVAL;
46
47 vp = vic_provinfo_alloc(GFP_KERNEL, oui,
48 VIC_PROVINFO_GENERIC_TYPE);
49 if (!vp)
50 return -ENOMEM;
51
52 VIC_PROVINFO_ADD_TLV(vp,
53 VIC_GENERIC_PROV_TLV_PORT_PROFILE_NAME_STR,
54 strlen(enic->pp.name) + 1, enic->pp.name);
55
56 if (!is_zero_ether_addr(enic->pp.mac_addr))
57 client_mac = enic->pp.mac_addr;
58 else
59 client_mac = netdev->dev_addr;
60
61 VIC_PROVINFO_ADD_TLV(vp,
62 VIC_GENERIC_PROV_TLV_CLIENT_MAC_ADDR,
63 ETH_ALEN, client_mac);
64
65 snprintf(client_mac_str, sizeof(client_mac_str), "%pM", client_mac);
66 VIC_PROVINFO_ADD_TLV(vp,
67 VIC_GENERIC_PROV_TLV_CLUSTER_PORT_UUID_STR,
68 sizeof(client_mac_str), client_mac_str);
69
70 if (enic->pp.set & ENIC_SET_INSTANCE) {
71 sprintf(uuid_str, "%pUB", enic->pp.instance_uuid);
72 VIC_PROVINFO_ADD_TLV(vp,
73 VIC_GENERIC_PROV_TLV_CLIENT_UUID_STR,
74 sizeof(uuid_str), uuid_str);
75 }
76
77 if (enic->pp.set & ENIC_SET_HOST) {
78 sprintf(uuid_str, "%pUB", enic->pp.host_uuid);
79 VIC_PROVINFO_ADD_TLV(vp,
80 VIC_GENERIC_PROV_TLV_HOST_UUID_STR,
81 sizeof(uuid_str), uuid_str);
82 }
83
84 VIC_PROVINFO_ADD_TLV(vp,
85 VIC_GENERIC_PROV_TLV_OS_TYPE,
86 sizeof(os_type), &os_type);
87
88 err = enic_dev_status_to_errno(enic_dev_init_prov2(enic, vp));
89
90add_tlv_failure:
91 vic_provinfo_free(vp);
92
93 return err;
94}
95
96static int enic_unset_port_profile(struct enic *enic)
97{
98 int err;
99
100 err = enic_vnic_dev_deinit(enic);
101 if (err)
102 return enic_dev_status_to_errno(err);
103
104 enic_reset_addr_lists(enic);
105
106 return 0;
107}
108
109static int enic_are_pp_different(struct enic_port_profile *pp1,
110 struct enic_port_profile *pp2)
111{
112 return strcmp(pp1->name, pp2->name) | !!memcmp(pp1->instance_uuid,
113 pp2->instance_uuid, PORT_UUID_MAX) |
114 !!memcmp(pp1->host_uuid, pp2->host_uuid, PORT_UUID_MAX) |
115 !!memcmp(pp1->mac_addr, pp2->mac_addr, ETH_ALEN);
116}
117
118static int enic_pp_preassociate(struct enic *enic,
119 struct enic_port_profile *prev_pp, int *restore_pp);
120static int enic_pp_disassociate(struct enic *enic,
121 struct enic_port_profile *prev_pp, int *restore_pp);
122static int enic_pp_preassociate_rr(struct enic *enic,
123 struct enic_port_profile *prev_pp, int *restore_pp);
124static int enic_pp_associate(struct enic *enic,
125 struct enic_port_profile *prev_pp, int *restore_pp);
126
127static int (*enic_pp_handlers[])(struct enic *enic,
128 struct enic_port_profile *prev_state, int *restore_pp) = {
129 [PORT_REQUEST_PREASSOCIATE] = enic_pp_preassociate,
130 [PORT_REQUEST_PREASSOCIATE_RR] = enic_pp_preassociate_rr,
131 [PORT_REQUEST_ASSOCIATE] = enic_pp_associate,
132 [PORT_REQUEST_DISASSOCIATE] = enic_pp_disassociate,
133};
134
135static const int enic_pp_handlers_count =
136 sizeof(enic_pp_handlers)/sizeof(*enic_pp_handlers);
137
138static int enic_pp_preassociate(struct enic *enic,
139 struct enic_port_profile *prev_pp, int *restore_pp)
140{
141 return -EOPNOTSUPP;
142}
143
144static int enic_pp_disassociate(struct enic *enic,
145 struct enic_port_profile *prev_pp, int *restore_pp)
146{
147 return enic_unset_port_profile(enic);
148}
149
150static int enic_pp_preassociate_rr(struct enic *enic,
151 struct enic_port_profile *prev_pp, int *restore_pp)
152{
153 int err;
154 int active = 0;
155
156 if (enic->pp.request != PORT_REQUEST_ASSOCIATE) {
157 /* If pre-associate is not part of an associate.
158 We always disassociate first */
159 err = enic_pp_handlers[PORT_REQUEST_DISASSOCIATE](enic,
160 prev_pp, restore_pp);
161 if (err)
162 return err;
163
164 *restore_pp = 0;
165 }
166
167 *restore_pp = 0;
168
169 err = enic_set_port_profile(enic);
170 if (err)
171 return err;
172
173 /* If pre-associate is not part of an associate. */
174 if (enic->pp.request != PORT_REQUEST_ASSOCIATE)
175 err = enic_dev_status_to_errno(enic_dev_enable2(enic, active));
176
177 return err;
178}
179
180static int enic_pp_associate(struct enic *enic,
181 struct enic_port_profile *prev_pp, int *restore_pp)
182{
183 int err;
184 int active = 1;
185
186 /* Check if a pre-associate was called before */
187 if (prev_pp->request != PORT_REQUEST_PREASSOCIATE_RR ||
188 (prev_pp->request == PORT_REQUEST_PREASSOCIATE_RR &&
189 enic_are_pp_different(prev_pp, &enic->pp))) {
190 err = enic_pp_handlers[PORT_REQUEST_DISASSOCIATE](
191 enic, prev_pp, restore_pp);
192 if (err)
193 return err;
194
195 *restore_pp = 0;
196 }
197
198 err = enic_pp_handlers[PORT_REQUEST_PREASSOCIATE_RR](
199 enic, prev_pp, restore_pp);
200 if (err)
201 return err;
202
203 *restore_pp = 0;
204
205 return enic_dev_status_to_errno(enic_dev_enable2(enic, active));
206}
207
208int enic_process_set_pp_request(struct enic *enic,
209 struct enic_port_profile *prev_pp, int *restore_pp)
210{
211 if (enic->pp.request < enic_pp_handlers_count
212 && enic_pp_handlers[enic->pp.request])
213 return enic_pp_handlers[enic->pp.request](enic,
214 prev_pp, restore_pp);
215 else
216 return -EOPNOTSUPP;
217}
218
219int enic_process_get_pp_request(struct enic *enic, int request,
220 u16 *response)
221{
222 int err, status = ERR_SUCCESS;
223
224 switch (request) {
225
226 case PORT_REQUEST_PREASSOCIATE_RR:
227 case PORT_REQUEST_ASSOCIATE:
228 err = enic_dev_enable2_done(enic, &status);
229 break;
230
231 case PORT_REQUEST_DISASSOCIATE:
232 err = enic_dev_deinit_done(enic, &status);
233 break;
234
235 default:
236 return -EINVAL;
237 }
238
239 if (err)
240 status = err;
241
242 switch (status) {
243 case ERR_SUCCESS:
244 *response = PORT_PROFILE_RESPONSE_SUCCESS;
245 break;
246 case ERR_EINVAL:
247 *response = PORT_PROFILE_RESPONSE_INVALID;
248 break;
249 case ERR_EBADSTATE:
250 *response = PORT_PROFILE_RESPONSE_BADSTATE;
251 break;
252 case ERR_ENOMEM:
253 *response = PORT_PROFILE_RESPONSE_INSUFFICIENT_RESOURCES;
254 break;
255 case ERR_EINPROGRESS:
256 *response = PORT_PROFILE_RESPONSE_INPROGRESS;
257 break;
258 default:
259 *response = PORT_PROFILE_RESPONSE_ERROR;
260 break;
261 }
262
263 return 0;
264}
diff --git a/drivers/net/enic/enic_pp.h b/drivers/net/enic/enic_pp.h
new file mode 100644
index 000000000000..699e365a944d
--- /dev/null
+++ b/drivers/net/enic/enic_pp.h
@@ -0,0 +1,27 @@
1/*
2 * Copyright 2011 Cisco Systems, Inc. All rights reserved.
3 *
4 * This program is free software; you may redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; version 2 of the License.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
10 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
11 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
12 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
13 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
14 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
15 * SOFTWARE.
16 *
17 */
18
19#ifndef _ENIC_PP_H_
20#define _ENIC_PP_H_
21
22int enic_process_set_pp_request(struct enic *enic,
23 struct enic_port_profile *prev_pp, int *restore_pp);
24int enic_process_get_pp_request(struct enic *enic, int request,
25 u16 *response);
26
27#endif /* _ENIC_PP_H_ */
diff --git a/drivers/net/enic/enic_res.c b/drivers/net/enic/enic_res.c
index 29ede8a17a2c..6e5c6356e7df 100644
--- a/drivers/net/enic/enic_res.c
+++ b/drivers/net/enic/enic_res.c
@@ -94,13 +94,14 @@ int enic_get_vnic_config(struct enic *enic)
94 INTR_COALESCE_HW_TO_USEC(VNIC_INTR_TIMER_MAX), 94 INTR_COALESCE_HW_TO_USEC(VNIC_INTR_TIMER_MAX),
95 c->intr_timer_usec); 95 c->intr_timer_usec);
96 96
97 dev_info(enic_get_dev(enic), "vNIC MAC addr %pM wq/rq %d/%d\n", 97 dev_info(enic_get_dev(enic),
98 enic->mac_addr, c->wq_desc_count, c->rq_desc_count); 98 "vNIC MAC addr %pM wq/rq %d/%d mtu %d\n",
99 dev_info(enic_get_dev(enic), "vNIC mtu %d csum tx/rx %d/%d " 99 enic->mac_addr, c->wq_desc_count, c->rq_desc_count, c->mtu);
100 "tso/lro %d/%d intr timer %d usec\n", 100 dev_info(enic_get_dev(enic), "vNIC csum tx/rx %d/%d "
101 c->mtu, ENIC_SETTING(enic, TXCSUM), 101 "tso %d intr timer %d usec rss %d\n",
102 ENIC_SETTING(enic, RXCSUM), ENIC_SETTING(enic, TSO), 102 ENIC_SETTING(enic, TXCSUM), ENIC_SETTING(enic, RXCSUM),
103 ENIC_SETTING(enic, LRO), c->intr_timer_usec); 103 ENIC_SETTING(enic, TSO),
104 c->intr_timer_usec, ENIC_SETTING(enic, RSS));
104 105
105 return 0; 106 return 0;
106} 107}
@@ -181,18 +182,11 @@ void enic_free_vnic_resources(struct enic *enic)
181 182
182void enic_get_res_counts(struct enic *enic) 183void enic_get_res_counts(struct enic *enic)
183{ 184{
184 enic->wq_count = min_t(int, 185 enic->wq_count = vnic_dev_get_res_count(enic->vdev, RES_TYPE_WQ);
185 vnic_dev_get_res_count(enic->vdev, RES_TYPE_WQ), 186 enic->rq_count = vnic_dev_get_res_count(enic->vdev, RES_TYPE_RQ);
186 ENIC_WQ_MAX); 187 enic->cq_count = vnic_dev_get_res_count(enic->vdev, RES_TYPE_CQ);
187 enic->rq_count = min_t(int, 188 enic->intr_count = vnic_dev_get_res_count(enic->vdev,
188 vnic_dev_get_res_count(enic->vdev, RES_TYPE_RQ), 189 RES_TYPE_INTR_CTRL);
189 ENIC_RQ_MAX);
190 enic->cq_count = min_t(int,
191 vnic_dev_get_res_count(enic->vdev, RES_TYPE_CQ),
192 ENIC_CQ_MAX);
193 enic->intr_count = min_t(int,
194 vnic_dev_get_res_count(enic->vdev, RES_TYPE_INTR_CTRL),
195 ENIC_INTR_MAX);
196 190
197 dev_info(enic_get_dev(enic), 191 dev_info(enic_get_dev(enic),
198 "vNIC resources avail: wq %d rq %d cq %d intr %d\n", 192 "vNIC resources avail: wq %d rq %d cq %d intr %d\n",
diff --git a/drivers/net/enic/enic_res.h b/drivers/net/enic/enic_res.h
index 83bd172c356c..25be2734c3fe 100644
--- a/drivers/net/enic/enic_res.h
+++ b/drivers/net/enic/enic_res.h
@@ -30,10 +30,11 @@
30#define ENIC_MIN_RQ_DESCS 64 30#define ENIC_MIN_RQ_DESCS 64
31#define ENIC_MAX_RQ_DESCS 4096 31#define ENIC_MAX_RQ_DESCS 4096
32 32
33#define ENIC_MIN_MTU 576 /* minimum for IPv4 */ 33#define ENIC_MIN_MTU 68
34#define ENIC_MAX_MTU 9000 34#define ENIC_MAX_MTU 9000
35 35
36#define ENIC_MULTICAST_PERFECT_FILTERS 32 36#define ENIC_MULTICAST_PERFECT_FILTERS 32
37#define ENIC_UNICAST_PERFECT_FILTERS 32
37 38
38#define ENIC_NON_TSO_MAX_DESC 16 39#define ENIC_NON_TSO_MAX_DESC 16
39 40
diff --git a/drivers/net/enic/vnic_dev.c b/drivers/net/enic/vnic_dev.c
index 6a5b578a69e1..68f24ae860ae 100644
--- a/drivers/net/enic/vnic_dev.c
+++ b/drivers/net/enic/vnic_dev.c
@@ -74,6 +74,7 @@ static int vnic_dev_discover_res(struct vnic_dev *vdev,
74 struct vnic_dev_bar *bar, unsigned int num_bars) 74 struct vnic_dev_bar *bar, unsigned int num_bars)
75{ 75{
76 struct vnic_resource_header __iomem *rh; 76 struct vnic_resource_header __iomem *rh;
77 struct mgmt_barmap_hdr __iomem *mrh;
77 struct vnic_resource __iomem *r; 78 struct vnic_resource __iomem *r;
78 u8 type; 79 u8 type;
79 80
@@ -85,22 +86,32 @@ static int vnic_dev_discover_res(struct vnic_dev *vdev,
85 return -EINVAL; 86 return -EINVAL;
86 } 87 }
87 88
88 rh = bar->vaddr; 89 rh = bar->vaddr;
90 mrh = bar->vaddr;
89 if (!rh) { 91 if (!rh) {
90 pr_err("vNIC BAR0 res hdr not mem-mapped\n"); 92 pr_err("vNIC BAR0 res hdr not mem-mapped\n");
91 return -EINVAL; 93 return -EINVAL;
92 } 94 }
93 95
94 if (ioread32(&rh->magic) != VNIC_RES_MAGIC || 96 /* Check for mgmt vnic in addition to normal vnic */
95 ioread32(&rh->version) != VNIC_RES_VERSION) { 97 if ((ioread32(&rh->magic) != VNIC_RES_MAGIC) ||
96 pr_err("vNIC BAR0 res magic/version error " 98 (ioread32(&rh->version) != VNIC_RES_VERSION)) {
97 "exp (%lx/%lx) curr (%x/%x)\n", 99 if ((ioread32(&mrh->magic) != MGMTVNIC_MAGIC) ||
100 (ioread32(&mrh->version) != MGMTVNIC_VERSION)) {
101 pr_err("vNIC BAR0 res magic/version error "
102 "exp (%lx/%lx) or (%lx/%lx), curr (%x/%x)\n",
98 VNIC_RES_MAGIC, VNIC_RES_VERSION, 103 VNIC_RES_MAGIC, VNIC_RES_VERSION,
104 MGMTVNIC_MAGIC, MGMTVNIC_VERSION,
99 ioread32(&rh->magic), ioread32(&rh->version)); 105 ioread32(&rh->magic), ioread32(&rh->version));
100 return -EINVAL; 106 return -EINVAL;
107 }
101 } 108 }
102 109
103 r = (struct vnic_resource __iomem *)(rh + 1); 110 if (ioread32(&mrh->magic) == MGMTVNIC_MAGIC)
111 r = (struct vnic_resource __iomem *)(mrh + 1);
112 else
113 r = (struct vnic_resource __iomem *)(rh + 1);
114
104 115
105 while ((type = ioread8(&r->type)) != RES_TYPE_EOL) { 116 while ((type = ioread8(&r->type)) != RES_TYPE_EOL) {
106 117
@@ -175,22 +186,7 @@ void __iomem *vnic_dev_get_res(struct vnic_dev *vdev, enum vnic_res_type type,
175 } 186 }
176} 187}
177 188
178dma_addr_t vnic_dev_get_res_bus_addr(struct vnic_dev *vdev, 189static unsigned int vnic_dev_desc_ring_size(struct vnic_dev_ring *ring,
179 enum vnic_res_type type, unsigned int index)
180{
181 switch (type) {
182 case RES_TYPE_WQ:
183 case RES_TYPE_RQ:
184 case RES_TYPE_CQ:
185 case RES_TYPE_INTR_CTRL:
186 return vdev->res[type].bus_addr +
187 index * VNIC_RES_STRIDE;
188 default:
189 return vdev->res[type].bus_addr;
190 }
191}
192
193unsigned int vnic_dev_desc_ring_size(struct vnic_dev_ring *ring,
194 unsigned int desc_count, unsigned int desc_size) 190 unsigned int desc_count, unsigned int desc_size)
195{ 191{
196 /* The base address of the desc rings must be 512 byte aligned. 192 /* The base address of the desc rings must be 512 byte aligned.
@@ -373,18 +369,6 @@ static int vnic_dev_cmd_no_proxy(struct vnic_dev *vdev,
373 return err; 369 return err;
374} 370}
375 371
376void vnic_dev_cmd_proxy_by_bdf_start(struct vnic_dev *vdev, u16 bdf)
377{
378 vdev->proxy = PROXY_BY_BDF;
379 vdev->proxy_index = bdf;
380}
381
382void vnic_dev_cmd_proxy_end(struct vnic_dev *vdev)
383{
384 vdev->proxy = PROXY_NONE;
385 vdev->proxy_index = 0;
386}
387
388int vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd, 372int vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
389 u64 *a0, u64 *a1, int wait) 373 u64 *a0, u64 *a1, int wait)
390{ 374{
@@ -424,10 +408,17 @@ int vnic_dev_fw_info(struct vnic_dev *vdev,
424 if (!vdev->fw_info) 408 if (!vdev->fw_info)
425 return -ENOMEM; 409 return -ENOMEM;
426 410
411 memset(vdev->fw_info, 0, sizeof(struct vnic_devcmd_fw_info));
412
427 a0 = vdev->fw_info_pa; 413 a0 = vdev->fw_info_pa;
414 a1 = sizeof(struct vnic_devcmd_fw_info);
428 415
429 /* only get fw_info once and cache it */ 416 /* only get fw_info once and cache it */
430 err = vnic_dev_cmd(vdev, CMD_MCPU_FW_INFO, &a0, &a1, wait); 417 err = vnic_dev_cmd(vdev, CMD_MCPU_FW_INFO, &a0, &a1, wait);
418 if (err == ERR_ECMDUNKNOWN) {
419 err = vnic_dev_cmd(vdev, CMD_MCPU_FW_INFO_OLD,
420 &a0, &a1, wait);
421 }
431 } 422 }
432 423
433 *fw_info = vdev->fw_info; 424 *fw_info = vdev->fw_info;
@@ -435,25 +426,6 @@ int vnic_dev_fw_info(struct vnic_dev *vdev,
435 return err; 426 return err;
436} 427}
437 428
438int vnic_dev_hw_version(struct vnic_dev *vdev, enum vnic_dev_hw_version *hw_ver)
439{
440 struct vnic_devcmd_fw_info *fw_info;
441 int err;
442
443 err = vnic_dev_fw_info(vdev, &fw_info);
444 if (err)
445 return err;
446
447 if (strncmp(fw_info->hw_version, "A1", sizeof("A1")) == 0)
448 *hw_ver = VNIC_DEV_HW_VER_A1;
449 else if (strncmp(fw_info->hw_version, "A2", sizeof("A2")) == 0)
450 *hw_ver = VNIC_DEV_HW_VER_A2;
451 else
452 *hw_ver = VNIC_DEV_HW_VER_UNKNOWN;
453
454 return 0;
455}
456
457int vnic_dev_spec(struct vnic_dev *vdev, unsigned int offset, unsigned int size, 429int vnic_dev_spec(struct vnic_dev *vdev, unsigned int offset, unsigned int size,
458 void *value) 430 void *value)
459{ 431{
@@ -477,13 +449,6 @@ int vnic_dev_spec(struct vnic_dev *vdev, unsigned int offset, unsigned int size,
477 return err; 449 return err;
478} 450}
479 451
480int vnic_dev_stats_clear(struct vnic_dev *vdev)
481{
482 u64 a0 = 0, a1 = 0;
483 int wait = 1000;
484 return vnic_dev_cmd(vdev, CMD_STATS_CLEAR, &a0, &a1, wait);
485}
486
487int vnic_dev_stats_dump(struct vnic_dev *vdev, struct vnic_stats **stats) 452int vnic_dev_stats_dump(struct vnic_dev *vdev, struct vnic_stats **stats)
488{ 453{
489 u64 a0, a1; 454 u64 a0, a1;
@@ -510,13 +475,6 @@ int vnic_dev_close(struct vnic_dev *vdev)
510 return vnic_dev_cmd(vdev, CMD_CLOSE, &a0, &a1, wait); 475 return vnic_dev_cmd(vdev, CMD_CLOSE, &a0, &a1, wait);
511} 476}
512 477
513int vnic_dev_enable(struct vnic_dev *vdev)
514{
515 u64 a0 = 0, a1 = 0;
516 int wait = 1000;
517 return vnic_dev_cmd(vdev, CMD_ENABLE, &a0, &a1, wait);
518}
519
520int vnic_dev_enable_wait(struct vnic_dev *vdev) 478int vnic_dev_enable_wait(struct vnic_dev *vdev)
521{ 479{
522 u64 a0 = 0, a1 = 0; 480 u64 a0 = 0, a1 = 0;
@@ -561,14 +519,14 @@ int vnic_dev_open_done(struct vnic_dev *vdev, int *done)
561 return 0; 519 return 0;
562} 520}
563 521
564int vnic_dev_soft_reset(struct vnic_dev *vdev, int arg) 522static int vnic_dev_soft_reset(struct vnic_dev *vdev, int arg)
565{ 523{
566 u64 a0 = (u32)arg, a1 = 0; 524 u64 a0 = (u32)arg, a1 = 0;
567 int wait = 1000; 525 int wait = 1000;
568 return vnic_dev_cmd(vdev, CMD_SOFT_RESET, &a0, &a1, wait); 526 return vnic_dev_cmd(vdev, CMD_SOFT_RESET, &a0, &a1, wait);
569} 527}
570 528
571int vnic_dev_soft_reset_done(struct vnic_dev *vdev, int *done) 529static int vnic_dev_soft_reset_done(struct vnic_dev *vdev, int *done)
572{ 530{
573 u64 a0 = 0, a1 = 0; 531 u64 a0 = 0, a1 = 0;
574 int wait = 1000; 532 int wait = 1000;
@@ -669,26 +627,6 @@ int vnic_dev_packet_filter(struct vnic_dev *vdev, int directed, int multicast,
669 return err; 627 return err;
670} 628}
671 629
672int vnic_dev_packet_filter_all(struct vnic_dev *vdev, int directed,
673 int multicast, int broadcast, int promisc, int allmulti)
674{
675 u64 a0, a1 = 0;
676 int wait = 1000;
677 int err;
678
679 a0 = (directed ? CMD_PFILTER_DIRECTED : 0) |
680 (multicast ? CMD_PFILTER_MULTICAST : 0) |
681 (broadcast ? CMD_PFILTER_BROADCAST : 0) |
682 (promisc ? CMD_PFILTER_PROMISCUOUS : 0) |
683 (allmulti ? CMD_PFILTER_ALL_MULTICAST : 0);
684
685 err = vnic_dev_cmd(vdev, CMD_PACKET_FILTER_ALL, &a0, &a1, wait);
686 if (err)
687 pr_err("Can't set packet filter\n");
688
689 return err;
690}
691
692int vnic_dev_add_addr(struct vnic_dev *vdev, u8 *addr) 630int vnic_dev_add_addr(struct vnic_dev *vdev, u8 *addr)
693{ 631{
694 u64 a0 = 0, a1 = 0; 632 u64 a0 = 0, a1 = 0;
@@ -737,20 +675,7 @@ int vnic_dev_set_ig_vlan_rewrite_mode(struct vnic_dev *vdev,
737 return err; 675 return err;
738} 676}
739 677
740int vnic_dev_raise_intr(struct vnic_dev *vdev, u16 intr) 678static int vnic_dev_notify_setcmd(struct vnic_dev *vdev,
741{
742 u64 a0 = intr, a1 = 0;
743 int wait = 1000;
744 int err;
745
746 err = vnic_dev_cmd(vdev, CMD_IAR, &a0, &a1, wait);
747 if (err)
748 pr_err("Failed to raise INTR[%d], err %d\n", intr, err);
749
750 return err;
751}
752
753int vnic_dev_notify_setcmd(struct vnic_dev *vdev,
754 void *notify_addr, dma_addr_t notify_pa, u16 intr) 679 void *notify_addr, dma_addr_t notify_pa, u16 intr)
755{ 680{
756 u64 a0, a1; 681 u64 a0, a1;
@@ -789,7 +714,7 @@ int vnic_dev_notify_set(struct vnic_dev *vdev, u16 intr)
789 return vnic_dev_notify_setcmd(vdev, notify_addr, notify_pa, intr); 714 return vnic_dev_notify_setcmd(vdev, notify_addr, notify_pa, intr);
790} 715}
791 716
792int vnic_dev_notify_unsetcmd(struct vnic_dev *vdev) 717static int vnic_dev_notify_unsetcmd(struct vnic_dev *vdev)
793{ 718{
794 u64 a0, a1; 719 u64 a0, a1;
795 int wait = 1000; 720 int wait = 1000;
@@ -861,48 +786,6 @@ int vnic_dev_init(struct vnic_dev *vdev, int arg)
861 return r; 786 return r;
862} 787}
863 788
864int vnic_dev_init_done(struct vnic_dev *vdev, int *done, int *err)
865{
866 u64 a0 = 0, a1 = 0;
867 int wait = 1000;
868 int ret;
869
870 *done = 0;
871
872 ret = vnic_dev_cmd(vdev, CMD_INIT_STATUS, &a0, &a1, wait);
873 if (ret)
874 return ret;
875
876 *done = (a0 == 0);
877
878 *err = (a0 == 0) ? (int)a1:0;
879
880 return 0;
881}
882
883int vnic_dev_init_prov(struct vnic_dev *vdev, u8 *buf, u32 len)
884{
885 u64 a0, a1 = len;
886 int wait = 1000;
887 dma_addr_t prov_pa;
888 void *prov_buf;
889 int ret;
890
891 prov_buf = pci_alloc_consistent(vdev->pdev, len, &prov_pa);
892 if (!prov_buf)
893 return -ENOMEM;
894
895 memcpy(prov_buf, buf, len);
896
897 a0 = prov_pa;
898
899 ret = vnic_dev_cmd(vdev, CMD_INIT_PROV_INFO, &a0, &a1, wait);
900
901 pci_free_consistent(vdev->pdev, len, prov_buf, prov_pa);
902
903 return ret;
904}
905
906int vnic_dev_deinit(struct vnic_dev *vdev) 789int vnic_dev_deinit(struct vnic_dev *vdev)
907{ 790{
908 u64 a0 = 0, a1 = 0; 791 u64 a0 = 0, a1 = 0;
@@ -943,30 +826,6 @@ u32 vnic_dev_mtu(struct vnic_dev *vdev)
943 return vdev->notify_copy.mtu; 826 return vdev->notify_copy.mtu;
944} 827}
945 828
946u32 vnic_dev_link_down_cnt(struct vnic_dev *vdev)
947{
948 if (!vnic_dev_notify_ready(vdev))
949 return 0;
950
951 return vdev->notify_copy.link_down_cnt;
952}
953
954u32 vnic_dev_notify_status(struct vnic_dev *vdev)
955{
956 if (!vnic_dev_notify_ready(vdev))
957 return 0;
958
959 return vdev->notify_copy.status;
960}
961
962u32 vnic_dev_uif(struct vnic_dev *vdev)
963{
964 if (!vnic_dev_notify_ready(vdev))
965 return 0;
966
967 return vdev->notify_copy.uif;
968}
969
970void vnic_dev_set_intr_mode(struct vnic_dev *vdev, 829void vnic_dev_set_intr_mode(struct vnic_dev *vdev,
971 enum vnic_dev_intr_mode intr_mode) 830 enum vnic_dev_intr_mode intr_mode)
972{ 831{
@@ -1026,4 +885,59 @@ err_out:
1026 return NULL; 885 return NULL;
1027} 886}
1028 887
888int vnic_dev_init_prov2(struct vnic_dev *vdev, u8 *buf, u32 len)
889{
890 u64 a0, a1 = len;
891 int wait = 1000;
892 dma_addr_t prov_pa;
893 void *prov_buf;
894 int ret;
895
896 prov_buf = pci_alloc_consistent(vdev->pdev, len, &prov_pa);
897 if (!prov_buf)
898 return -ENOMEM;
899
900 memcpy(prov_buf, buf, len);
901
902 a0 = prov_pa;
903
904 ret = vnic_dev_cmd(vdev, CMD_INIT_PROV_INFO2, &a0, &a1, wait);
905
906 pci_free_consistent(vdev->pdev, len, prov_buf, prov_pa);
907
908 return ret;
909}
1029 910
911int vnic_dev_enable2(struct vnic_dev *vdev, int active)
912{
913 u64 a0, a1 = 0;
914 int wait = 1000;
915
916 a0 = (active ? CMD_ENABLE2_ACTIVE : 0);
917
918 return vnic_dev_cmd(vdev, CMD_ENABLE2, &a0, &a1, wait);
919}
920
921static int vnic_dev_cmd_status(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
922 int *status)
923{
924 u64 a0 = cmd, a1 = 0;
925 int wait = 1000;
926 int ret;
927
928 ret = vnic_dev_cmd(vdev, CMD_STATUS, &a0, &a1, wait);
929 if (!ret)
930 *status = (int)a0;
931
932 return ret;
933}
934
935int vnic_dev_enable2_done(struct vnic_dev *vdev, int *status)
936{
937 return vnic_dev_cmd_status(vdev, CMD_ENABLE2, status);
938}
939
940int vnic_dev_deinit_done(struct vnic_dev *vdev, int *status)
941{
942 return vnic_dev_cmd_status(vdev, CMD_DEINIT, status);
943}
diff --git a/drivers/net/enic/vnic_dev.h b/drivers/net/enic/vnic_dev.h
index 3a61873138b6..cf482a2c9dd9 100644
--- a/drivers/net/enic/vnic_dev.h
+++ b/drivers/net/enic/vnic_dev.h
@@ -44,12 +44,6 @@ static inline void writeq(u64 val, void __iomem *reg)
44#undef pr_fmt 44#undef pr_fmt
45#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 45#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
46 46
47enum vnic_dev_hw_version {
48 VNIC_DEV_HW_VER_UNKNOWN,
49 VNIC_DEV_HW_VER_A1,
50 VNIC_DEV_HW_VER_A2,
51};
52
53enum vnic_dev_intr_mode { 47enum vnic_dev_intr_mode {
54 VNIC_DEV_INTR_MODE_UNKNOWN, 48 VNIC_DEV_INTR_MODE_UNKNOWN,
55 VNIC_DEV_INTR_MODE_INTX, 49 VNIC_DEV_INTR_MODE_INTX,
@@ -84,10 +78,6 @@ unsigned int vnic_dev_get_res_count(struct vnic_dev *vdev,
84 enum vnic_res_type type); 78 enum vnic_res_type type);
85void __iomem *vnic_dev_get_res(struct vnic_dev *vdev, enum vnic_res_type type, 79void __iomem *vnic_dev_get_res(struct vnic_dev *vdev, enum vnic_res_type type,
86 unsigned int index); 80 unsigned int index);
87dma_addr_t vnic_dev_get_res_bus_addr(struct vnic_dev *vdev,
88 enum vnic_res_type type, unsigned int index);
89unsigned int vnic_dev_desc_ring_size(struct vnic_dev_ring *ring,
90 unsigned int desc_count, unsigned int desc_size);
91void vnic_dev_clear_desc_ring(struct vnic_dev_ring *ring); 81void vnic_dev_clear_desc_ring(struct vnic_dev_ring *ring);
92int vnic_dev_alloc_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring, 82int vnic_dev_alloc_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring,
93 unsigned int desc_count, unsigned int desc_size); 83 unsigned int desc_count, unsigned int desc_size);
@@ -95,49 +85,30 @@ void vnic_dev_free_desc_ring(struct vnic_dev *vdev,
95 struct vnic_dev_ring *ring); 85 struct vnic_dev_ring *ring);
96int vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd, 86int vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
97 u64 *a0, u64 *a1, int wait); 87 u64 *a0, u64 *a1, int wait);
98void vnic_dev_cmd_proxy_by_bdf_start(struct vnic_dev *vdev, u16 bdf);
99void vnic_dev_cmd_proxy_end(struct vnic_dev *vdev);
100int vnic_dev_fw_info(struct vnic_dev *vdev, 88int vnic_dev_fw_info(struct vnic_dev *vdev,
101 struct vnic_devcmd_fw_info **fw_info); 89 struct vnic_devcmd_fw_info **fw_info);
102int vnic_dev_hw_version(struct vnic_dev *vdev,
103 enum vnic_dev_hw_version *hw_ver);
104int vnic_dev_spec(struct vnic_dev *vdev, unsigned int offset, unsigned int size, 90int vnic_dev_spec(struct vnic_dev *vdev, unsigned int offset, unsigned int size,
105 void *value); 91 void *value);
106int vnic_dev_stats_clear(struct vnic_dev *vdev);
107int vnic_dev_stats_dump(struct vnic_dev *vdev, struct vnic_stats **stats); 92int vnic_dev_stats_dump(struct vnic_dev *vdev, struct vnic_stats **stats);
108int vnic_dev_hang_notify(struct vnic_dev *vdev); 93int vnic_dev_hang_notify(struct vnic_dev *vdev);
109int vnic_dev_packet_filter(struct vnic_dev *vdev, int directed, int multicast, 94int vnic_dev_packet_filter(struct vnic_dev *vdev, int directed, int multicast,
110 int broadcast, int promisc, int allmulti); 95 int broadcast, int promisc, int allmulti);
111int vnic_dev_packet_filter_all(struct vnic_dev *vdev, int directed,
112 int multicast, int broadcast, int promisc, int allmulti);
113int vnic_dev_add_addr(struct vnic_dev *vdev, u8 *addr); 96int vnic_dev_add_addr(struct vnic_dev *vdev, u8 *addr);
114int vnic_dev_del_addr(struct vnic_dev *vdev, u8 *addr); 97int vnic_dev_del_addr(struct vnic_dev *vdev, u8 *addr);
115int vnic_dev_mac_addr(struct vnic_dev *vdev, u8 *mac_addr); 98int vnic_dev_mac_addr(struct vnic_dev *vdev, u8 *mac_addr);
116int vnic_dev_raise_intr(struct vnic_dev *vdev, u16 intr);
117int vnic_dev_notify_setcmd(struct vnic_dev *vdev,
118 void *notify_addr, dma_addr_t notify_pa, u16 intr);
119int vnic_dev_notify_set(struct vnic_dev *vdev, u16 intr); 99int vnic_dev_notify_set(struct vnic_dev *vdev, u16 intr);
120int vnic_dev_notify_unsetcmd(struct vnic_dev *vdev);
121int vnic_dev_notify_unset(struct vnic_dev *vdev); 100int vnic_dev_notify_unset(struct vnic_dev *vdev);
122int vnic_dev_link_status(struct vnic_dev *vdev); 101int vnic_dev_link_status(struct vnic_dev *vdev);
123u32 vnic_dev_port_speed(struct vnic_dev *vdev); 102u32 vnic_dev_port_speed(struct vnic_dev *vdev);
124u32 vnic_dev_msg_lvl(struct vnic_dev *vdev); 103u32 vnic_dev_msg_lvl(struct vnic_dev *vdev);
125u32 vnic_dev_mtu(struct vnic_dev *vdev); 104u32 vnic_dev_mtu(struct vnic_dev *vdev);
126u32 vnic_dev_link_down_cnt(struct vnic_dev *vdev);
127u32 vnic_dev_notify_status(struct vnic_dev *vdev);
128u32 vnic_dev_uif(struct vnic_dev *vdev);
129int vnic_dev_close(struct vnic_dev *vdev); 105int vnic_dev_close(struct vnic_dev *vdev);
130int vnic_dev_enable(struct vnic_dev *vdev);
131int vnic_dev_enable_wait(struct vnic_dev *vdev); 106int vnic_dev_enable_wait(struct vnic_dev *vdev);
132int vnic_dev_disable(struct vnic_dev *vdev); 107int vnic_dev_disable(struct vnic_dev *vdev);
133int vnic_dev_open(struct vnic_dev *vdev, int arg); 108int vnic_dev_open(struct vnic_dev *vdev, int arg);
134int vnic_dev_open_done(struct vnic_dev *vdev, int *done); 109int vnic_dev_open_done(struct vnic_dev *vdev, int *done);
135int vnic_dev_init(struct vnic_dev *vdev, int arg); 110int vnic_dev_init(struct vnic_dev *vdev, int arg);
136int vnic_dev_init_done(struct vnic_dev *vdev, int *done, int *err);
137int vnic_dev_init_prov(struct vnic_dev *vdev, u8 *buf, u32 len);
138int vnic_dev_deinit(struct vnic_dev *vdev); 111int vnic_dev_deinit(struct vnic_dev *vdev);
139int vnic_dev_soft_reset(struct vnic_dev *vdev, int arg);
140int vnic_dev_soft_reset_done(struct vnic_dev *vdev, int *done);
141int vnic_dev_hang_reset(struct vnic_dev *vdev, int arg); 112int vnic_dev_hang_reset(struct vnic_dev *vdev, int arg);
142int vnic_dev_hang_reset_done(struct vnic_dev *vdev, int *done); 113int vnic_dev_hang_reset_done(struct vnic_dev *vdev, int *done);
143void vnic_dev_set_intr_mode(struct vnic_dev *vdev, 114void vnic_dev_set_intr_mode(struct vnic_dev *vdev,
@@ -149,5 +120,9 @@ int vnic_dev_set_ig_vlan_rewrite_mode(struct vnic_dev *vdev,
149struct vnic_dev *vnic_dev_register(struct vnic_dev *vdev, 120struct vnic_dev *vnic_dev_register(struct vnic_dev *vdev,
150 void *priv, struct pci_dev *pdev, struct vnic_dev_bar *bar, 121 void *priv, struct pci_dev *pdev, struct vnic_dev_bar *bar,
151 unsigned int num_bars); 122 unsigned int num_bars);
123int vnic_dev_init_prov2(struct vnic_dev *vdev, u8 *buf, u32 len);
124int vnic_dev_enable2(struct vnic_dev *vdev, int active);
125int vnic_dev_enable2_done(struct vnic_dev *vdev, int *status);
126int vnic_dev_deinit_done(struct vnic_dev *vdev, int *status);
152 127
153#endif /* _VNIC_DEV_H_ */ 128#endif /* _VNIC_DEV_H_ */
diff --git a/drivers/net/enic/vnic_devcmd.h b/drivers/net/enic/vnic_devcmd.h
index 20661755df6b..c5569bfb47ac 100644
--- a/drivers/net/enic/vnic_devcmd.h
+++ b/drivers/net/enic/vnic_devcmd.h
@@ -80,8 +80,34 @@
80enum vnic_devcmd_cmd { 80enum vnic_devcmd_cmd {
81 CMD_NONE = _CMDC(_CMD_DIR_NONE, _CMD_VTYPE_NONE, 0), 81 CMD_NONE = _CMDC(_CMD_DIR_NONE, _CMD_VTYPE_NONE, 0),
82 82
83 /* mcpu fw info in mem: (u64)a0=paddr to struct vnic_devcmd_fw_info */ 83 /*
84 CMD_MCPU_FW_INFO = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 1), 84 * mcpu fw info in mem:
85 * in:
86 * (u64)a0=paddr to struct vnic_devcmd_fw_info
87 * action:
88 * Fills in struct vnic_devcmd_fw_info (128 bytes)
89 * note:
90 * An old definition of CMD_MCPU_FW_INFO
91 */
92 CMD_MCPU_FW_INFO_OLD = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 1),
93
94 /*
95 * mcpu fw info in mem:
96 * in:
97 * (u64)a0=paddr to struct vnic_devcmd_fw_info
98 * (u16)a1=size of the structure
99 * out:
100 * (u16)a1=0 for in:a1 = 0,
101 * data size actually written for other values.
102 * action:
103 * Fills in first 128 bytes of vnic_devcmd_fw_info for in:a1 = 0,
104 * first in:a1 bytes for 0 < in:a1 <= 132,
105 * 132 bytes for other values of in:a1.
106 * note:
107 * CMD_MCPU_FW_INFO and CMD_MCPU_FW_INFO_OLD have the same enum 1
108 * for source compatibility.
109 */
110 CMD_MCPU_FW_INFO = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 1),
85 111
86 /* dev-specific block member: 112 /* dev-specific block member:
87 * in: (u16)a0=offset,(u8)a1=size 113 * in: (u16)a0=offset,(u8)a1=size
@@ -238,8 +264,65 @@ enum vnic_devcmd_cmd {
238 * out: (u32)a0=status of proxied cmd 264 * out: (u32)a0=status of proxied cmd
239 * a1-a15=out args of proxied cmd */ 265 * a1-a15=out args of proxied cmd */
240 CMD_PROXY_BY_BDF = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 42), 266 CMD_PROXY_BY_BDF = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 42),
267
268 /*
269 * As for BY_BDF except a0 is index of hvnlink subordinate vnic
270 * or SR-IOV virtual vnic
271 */
272 CMD_PROXY_BY_INDEX = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 43),
273
274 /*
275 * For HPP toggle:
276 * adapter-info-get
277 * in: (u64)a0=phsical address of buffer passed in from caller.
278 * (u16)a1=size of buffer specified in a0.
279 * out: (u64)a0=phsical address of buffer passed in from caller.
280 * (u16)a1=actual bytes from VIF-CONFIG-INFO TLV, or
281 * 0 if no VIF-CONFIG-INFO TLV was ever received. */
282 CMD_CONFIG_INFO_GET = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 44),
283
284 /* init_prov_info2:
285 * Variant of CMD_INIT_PROV_INFO, where it will not try to enable
286 * the vnic until CMD_ENABLE2 is issued.
287 * (u64)a0=paddr of vnic_devcmd_provinfo
288 * (u32)a1=sizeof provision info */
289 CMD_INIT_PROV_INFO2 = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 47),
290
291 /* enable2:
292 * (u32)a0=0 ==> standby
293 * =CMD_ENABLE2_ACTIVE ==> active
294 */
295 CMD_ENABLE2 = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 48),
296
297 /*
298 * cmd_status:
299 * Returns the status of the specified command
300 * Input:
301 * a0 = command for which status is being queried.
302 * Possible values are:
303 * CMD_SOFT_RESET
304 * CMD_HANG_RESET
305 * CMD_OPEN
306 * CMD_INIT
307 * CMD_INIT_PROV_INFO
308 * CMD_DEINIT
309 * CMD_INIT_PROV_INFO2
310 * CMD_ENABLE2
311 * Output:
312 * if status == STAT_ERROR
313 * a0 = ERR_ENOTSUPPORTED - status for command in a0 is
314 * not supported
315 * if status == STAT_NONE
316 * a0 = status of the devcmd specified in a0 as follows.
317 * ERR_SUCCESS - command in a0 completed successfully
318 * ERR_EINPROGRESS - command in a0 is still in progress
319 */
320 CMD_STATUS = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 49),
241}; 321};
242 322
323/* CMD_ENABLE2 flags */
324#define CMD_ENABLE2_ACTIVE 0x1
325
243/* flags for CMD_OPEN */ 326/* flags for CMD_OPEN */
244#define CMD_OPENF_OPROM 0x1 /* open coming from option rom */ 327#define CMD_OPENF_OPROM 0x1 /* open coming from option rom */
245 328
@@ -277,13 +360,23 @@ enum vnic_devcmd_error {
277 ERR_ETIMEDOUT = 8, 360 ERR_ETIMEDOUT = 8,
278 ERR_ELINKDOWN = 9, 361 ERR_ELINKDOWN = 9,
279 ERR_EMAXRES = 10, 362 ERR_EMAXRES = 10,
363 ERR_ENOTSUPPORTED = 11,
364 ERR_EINPROGRESS = 12,
280}; 365};
281 366
367/*
368 * note: hw_version and asic_rev refer to the same thing,
369 * but have different formats. hw_version is
370 * a 32-byte string (e.g. "A2") and asic_rev is
371 * a 16-bit integer (e.g. 0xA2).
372 */
282struct vnic_devcmd_fw_info { 373struct vnic_devcmd_fw_info {
283 char fw_version[32]; 374 char fw_version[32];
284 char fw_build[32]; 375 char fw_build[32];
285 char hw_version[32]; 376 char hw_version[32];
286 char hw_serial_number[32]; 377 char hw_serial_number[32];
378 u16 asic_type;
379 u16 asic_rev;
287}; 380};
288 381
289struct vnic_devcmd_notify { 382struct vnic_devcmd_notify {
diff --git a/drivers/net/enic/vnic_enet.h b/drivers/net/enic/vnic_enet.h
index 3b3291248956..e8740e3704e4 100644
--- a/drivers/net/enic/vnic_enet.h
+++ b/drivers/net/enic/vnic_enet.h
@@ -30,7 +30,7 @@ struct vnic_enet_config {
30 u32 wq_desc_count; 30 u32 wq_desc_count;
31 u32 rq_desc_count; 31 u32 rq_desc_count;
32 u16 mtu; 32 u16 mtu;
33 u16 intr_timer; 33 u16 intr_timer_deprecated;
34 u8 intr_timer_type; 34 u8 intr_timer_type;
35 u8 intr_mode; 35 u8 intr_mode;
36 char devname[16]; 36 char devname[16];
diff --git a/drivers/net/enic/vnic_intr.c b/drivers/net/enic/vnic_intr.c
index 52ab61af2750..3873771d75cc 100644
--- a/drivers/net/enic/vnic_intr.c
+++ b/drivers/net/enic/vnic_intr.c
@@ -65,8 +65,3 @@ void vnic_intr_clean(struct vnic_intr *intr)
65{ 65{
66 iowrite32(0, &intr->ctrl->int_credits); 66 iowrite32(0, &intr->ctrl->int_credits);
67} 67}
68
69void vnic_intr_raise(struct vnic_intr *intr)
70{
71 vnic_dev_raise_intr(intr->vdev, (u16)intr->index);
72}
diff --git a/drivers/net/enic/vnic_resource.h b/drivers/net/enic/vnic_resource.h
index 810287beff14..e0a73f1ca6f4 100644
--- a/drivers/net/enic/vnic_resource.h
+++ b/drivers/net/enic/vnic_resource.h
@@ -22,6 +22,11 @@
22 22
23#define VNIC_RES_MAGIC 0x766E6963L /* 'vnic' */ 23#define VNIC_RES_MAGIC 0x766E6963L /* 'vnic' */
24#define VNIC_RES_VERSION 0x00000000L 24#define VNIC_RES_VERSION 0x00000000L
25#define MGMTVNIC_MAGIC 0x544d474dL /* 'MGMT' */
26#define MGMTVNIC_VERSION 0x00000000L
27
28/* The MAC address assigned to the CFG vNIC is fixed. */
29#define MGMTVNIC_MAC { 0x02, 0x00, 0x54, 0x4d, 0x47, 0x4d }
25 30
26/* vNIC resource types */ 31/* vNIC resource types */
27enum vnic_res_type { 32enum vnic_res_type {
@@ -52,6 +57,14 @@ struct vnic_resource_header {
52 u32 version; 57 u32 version;
53}; 58};
54 59
60struct mgmt_barmap_hdr {
61 u32 magic; /* magic number */
62 u32 version; /* header format version */
63 u16 lif; /* loopback lif for mgmt frames */
64 u16 pci_slot; /* installed pci slot */
65 char serial[16]; /* card serial number */
66};
67
55struct vnic_resource { 68struct vnic_resource {
56 u8 type; 69 u8 type;
57 u8 bar; 70 u8 bar;
diff --git a/drivers/net/enic/vnic_rq.c b/drivers/net/enic/vnic_rq.c
index dbb2aca258b9..34105e0951a5 100644
--- a/drivers/net/enic/vnic_rq.c
+++ b/drivers/net/enic/vnic_rq.c
@@ -77,8 +77,10 @@ void vnic_rq_free(struct vnic_rq *rq)
77 vnic_dev_free_desc_ring(vdev, &rq->ring); 77 vnic_dev_free_desc_ring(vdev, &rq->ring);
78 78
79 for (i = 0; i < VNIC_RQ_BUF_BLKS_MAX; i++) { 79 for (i = 0; i < VNIC_RQ_BUF_BLKS_MAX; i++) {
80 kfree(rq->bufs[i]); 80 if (rq->bufs[i]) {
81 rq->bufs[i] = NULL; 81 kfree(rq->bufs[i]);
82 rq->bufs[i] = NULL;
83 }
82 } 84 }
83 85
84 rq->ctrl = NULL; 86 rq->ctrl = NULL;
@@ -113,7 +115,7 @@ int vnic_rq_alloc(struct vnic_dev *vdev, struct vnic_rq *rq, unsigned int index,
113 return 0; 115 return 0;
114} 116}
115 117
116void vnic_rq_init_start(struct vnic_rq *rq, unsigned int cq_index, 118static void vnic_rq_init_start(struct vnic_rq *rq, unsigned int cq_index,
117 unsigned int fetch_index, unsigned int posted_index, 119 unsigned int fetch_index, unsigned int posted_index,
118 unsigned int error_interrupt_enable, 120 unsigned int error_interrupt_enable,
119 unsigned int error_interrupt_offset) 121 unsigned int error_interrupt_offset)
diff --git a/drivers/net/enic/vnic_rq.h b/drivers/net/enic/vnic_rq.h
index 2dc48f91abf7..2056586f4d4b 100644
--- a/drivers/net/enic/vnic_rq.h
+++ b/drivers/net/enic/vnic_rq.h
@@ -141,11 +141,6 @@ static inline void vnic_rq_post(struct vnic_rq *rq,
141 } 141 }
142} 142}
143 143
144static inline int vnic_rq_posting_soon(struct vnic_rq *rq)
145{
146 return ((rq->to_use->index & VNIC_RQ_RETURN_RATE) == 0);
147}
148
149static inline void vnic_rq_return_descs(struct vnic_rq *rq, unsigned int count) 144static inline void vnic_rq_return_descs(struct vnic_rq *rq, unsigned int count)
150{ 145{
151 rq->ring.desc_avail += count; 146 rq->ring.desc_avail += count;
@@ -202,10 +197,6 @@ static inline int vnic_rq_fill(struct vnic_rq *rq,
202void vnic_rq_free(struct vnic_rq *rq); 197void vnic_rq_free(struct vnic_rq *rq);
203int vnic_rq_alloc(struct vnic_dev *vdev, struct vnic_rq *rq, unsigned int index, 198int vnic_rq_alloc(struct vnic_dev *vdev, struct vnic_rq *rq, unsigned int index,
204 unsigned int desc_count, unsigned int desc_size); 199 unsigned int desc_count, unsigned int desc_size);
205void vnic_rq_init_start(struct vnic_rq *rq, unsigned int cq_index,
206 unsigned int fetch_index, unsigned int posted_index,
207 unsigned int error_interrupt_enable,
208 unsigned int error_interrupt_offset);
209void vnic_rq_init(struct vnic_rq *rq, unsigned int cq_index, 200void vnic_rq_init(struct vnic_rq *rq, unsigned int cq_index,
210 unsigned int error_interrupt_enable, 201 unsigned int error_interrupt_enable,
211 unsigned int error_interrupt_offset); 202 unsigned int error_interrupt_offset);
diff --git a/drivers/net/enic/vnic_rss.h b/drivers/net/enic/vnic_rss.h
index f62d18719629..fa421baf45b8 100644
--- a/drivers/net/enic/vnic_rss.h
+++ b/drivers/net/enic/vnic_rss.h
@@ -37,9 +37,4 @@ union vnic_rss_cpu {
37 u64 raw[32]; 37 u64 raw[32];
38}; 38};
39 39
40void vnic_set_rss_key(union vnic_rss_key *rss_key, u8 *key);
41void vnic_set_rss_cpu(union vnic_rss_cpu *rss_cpu, u8 *cpu);
42void vnic_get_rss_key(union vnic_rss_key *rss_key, u8 *key);
43void vnic_get_rss_cpu(union vnic_rss_cpu *rss_cpu, u8 *cpu);
44
45#endif /* _VNIC_RSS_H_ */ 40#endif /* _VNIC_RSS_H_ */
diff --git a/drivers/net/enic/vnic_vic.c b/drivers/net/enic/vnic_vic.c
index 197c9d24af82..24ef8cd40545 100644
--- a/drivers/net/enic/vnic_vic.c
+++ b/drivers/net/enic/vnic_vic.c
@@ -23,7 +23,8 @@
23 23
24#include "vnic_vic.h" 24#include "vnic_vic.h"
25 25
26struct vic_provinfo *vic_provinfo_alloc(gfp_t flags, u8 *oui, u8 type) 26struct vic_provinfo *vic_provinfo_alloc(gfp_t flags, const u8 *oui,
27 const u8 type)
27{ 28{
28 struct vic_provinfo *vp; 29 struct vic_provinfo *vp;
29 30
@@ -47,15 +48,15 @@ void vic_provinfo_free(struct vic_provinfo *vp)
47} 48}
48 49
49int vic_provinfo_add_tlv(struct vic_provinfo *vp, u16 type, u16 length, 50int vic_provinfo_add_tlv(struct vic_provinfo *vp, u16 type, u16 length,
50 void *value) 51 const void *value)
51{ 52{
52 struct vic_provinfo_tlv *tlv; 53 struct vic_provinfo_tlv *tlv;
53 54
54 if (!vp || !value) 55 if (!vp || !value)
55 return -EINVAL; 56 return -EINVAL;
56 57
57 if (ntohl(vp->length) + sizeof(*tlv) + length > 58 if (ntohl(vp->length) + offsetof(struct vic_provinfo_tlv, value) +
58 VIC_PROVINFO_MAX_TLV_DATA) 59 length > VIC_PROVINFO_MAX_TLV_DATA)
59 return -ENOMEM; 60 return -ENOMEM;
60 61
61 tlv = (struct vic_provinfo_tlv *)((u8 *)vp->tlv + 62 tlv = (struct vic_provinfo_tlv *)((u8 *)vp->tlv +
@@ -66,7 +67,8 @@ int vic_provinfo_add_tlv(struct vic_provinfo *vp, u16 type, u16 length,
66 memcpy(tlv->value, value, length); 67 memcpy(tlv->value, value, length);
67 68
68 vp->num_tlvs = htonl(ntohl(vp->num_tlvs) + 1); 69 vp->num_tlvs = htonl(ntohl(vp->num_tlvs) + 1);
69 vp->length = htonl(ntohl(vp->length) + sizeof(*tlv) + length); 70 vp->length = htonl(ntohl(vp->length) +
71 offsetof(struct vic_provinfo_tlv, value) + length);
70 72
71 return 0; 73 return 0;
72} 74}
diff --git a/drivers/net/enic/vnic_vic.h b/drivers/net/enic/vnic_vic.h
index 7e46e5e8600f..9ef81f148351 100644
--- a/drivers/net/enic/vnic_vic.h
+++ b/drivers/net/enic/vnic_vic.h
@@ -24,14 +24,30 @@
24/* Note: String field lengths include null char */ 24/* Note: String field lengths include null char */
25 25
26#define VIC_PROVINFO_CISCO_OUI { 0x00, 0x00, 0x0c } 26#define VIC_PROVINFO_CISCO_OUI { 0x00, 0x00, 0x0c }
27#define VIC_PROVINFO_LINUX_TYPE 0x2 27#define VIC_PROVINFO_GENERIC_TYPE 0x4
28 28
29enum vic_linux_prov_tlv_type { 29enum vic_generic_prov_tlv_type {
30 VIC_LINUX_PROV_TLV_PORT_PROFILE_NAME_STR = 0, 30 VIC_GENERIC_PROV_TLV_PORT_PROFILE_NAME_STR = 0,
31 VIC_LINUX_PROV_TLV_CLIENT_MAC_ADDR = 1, /* u8[6] */ 31 VIC_GENERIC_PROV_TLV_CLIENT_MAC_ADDR = 1,
32 VIC_LINUX_PROV_TLV_CLIENT_NAME_STR = 2, 32 VIC_GENERIC_PROV_TLV_CLIENT_NAME_STR = 2,
33 VIC_LINUX_PROV_TLV_HOST_UUID_STR = 8, 33 VIC_GENERIC_PROV_TLV_CLUSTER_PORT_NAME_STR = 3,
34 VIC_LINUX_PROV_TLV_CLIENT_UUID_STR = 9, 34 VIC_GENERIC_PROV_TLV_CLUSTER_PORT_UUID_STR = 4,
35 VIC_GENERIC_PROV_TLV_CLUSTER_UUID_STR = 5,
36 VIC_GENERIC_PROV_TLV_CLUSTER_NAME_STR = 7,
37 VIC_GENERIC_PROV_TLV_HOST_UUID_STR = 8,
38 VIC_GENERIC_PROV_TLV_CLIENT_UUID_STR = 9,
39 VIC_GENERIC_PROV_TLV_INCARNATION_NUMBER = 10,
40 VIC_GENERIC_PROV_TLV_OS_TYPE = 11,
41 VIC_GENERIC_PROV_TLV_OS_VENDOR = 12,
42 VIC_GENERIC_PROV_TLV_CLIENT_TYPE = 15,
43};
44
45enum vic_generic_prov_os_type {
46 VIC_GENERIC_PROV_OS_TYPE_UNKNOWN = 0,
47 VIC_GENERIC_PROV_OS_TYPE_ESX = 1,
48 VIC_GENERIC_PROV_OS_TYPE_LINUX = 2,
49 VIC_GENERIC_PROV_OS_TYPE_WINDOWS = 3,
50 VIC_GENERIC_PROV_OS_TYPE_SOLARIS = 4,
35}; 51};
36 52
37struct vic_provinfo { 53struct vic_provinfo {
@@ -46,14 +62,22 @@ struct vic_provinfo {
46 } tlv[0]; 62 } tlv[0];
47} __packed; 63} __packed;
48 64
65#define VIC_PROVINFO_ADD_TLV(vp, tlvtype, tlvlen, data) \
66 do { \
67 err = vic_provinfo_add_tlv(vp, tlvtype, tlvlen, data); \
68 if (err) \
69 goto add_tlv_failure; \
70 } while (0)
71
49#define VIC_PROVINFO_MAX_DATA 1385 72#define VIC_PROVINFO_MAX_DATA 1385
50#define VIC_PROVINFO_MAX_TLV_DATA (VIC_PROVINFO_MAX_DATA - \ 73#define VIC_PROVINFO_MAX_TLV_DATA (VIC_PROVINFO_MAX_DATA - \
51 sizeof(struct vic_provinfo)) 74 sizeof(struct vic_provinfo))
52 75
53struct vic_provinfo *vic_provinfo_alloc(gfp_t flags, u8 *oui, u8 type); 76struct vic_provinfo *vic_provinfo_alloc(gfp_t flags, const u8 *oui,
77 const u8 type);
54void vic_provinfo_free(struct vic_provinfo *vp); 78void vic_provinfo_free(struct vic_provinfo *vp);
55int vic_provinfo_add_tlv(struct vic_provinfo *vp, u16 type, u16 length, 79int vic_provinfo_add_tlv(struct vic_provinfo *vp, u16 type, u16 length,
56 void *value); 80 const void *value);
57size_t vic_provinfo_size(struct vic_provinfo *vp); 81size_t vic_provinfo_size(struct vic_provinfo *vp);
58 82
59#endif /* _VNIC_VIC_H_ */ 83#endif /* _VNIC_VIC_H_ */
diff --git a/drivers/net/enic/vnic_wq.c b/drivers/net/enic/vnic_wq.c
index 122e33bcc578..df61bd932ea6 100644
--- a/drivers/net/enic/vnic_wq.c
+++ b/drivers/net/enic/vnic_wq.c
@@ -77,8 +77,10 @@ void vnic_wq_free(struct vnic_wq *wq)
77 vnic_dev_free_desc_ring(vdev, &wq->ring); 77 vnic_dev_free_desc_ring(vdev, &wq->ring);
78 78
79 for (i = 0; i < VNIC_WQ_BUF_BLKS_MAX; i++) { 79 for (i = 0; i < VNIC_WQ_BUF_BLKS_MAX; i++) {
80 kfree(wq->bufs[i]); 80 if (wq->bufs[i]) {
81 wq->bufs[i] = NULL; 81 kfree(wq->bufs[i]);
82 wq->bufs[i] = NULL;
83 }
82 } 84 }
83 85
84 wq->ctrl = NULL; 86 wq->ctrl = NULL;
@@ -113,7 +115,7 @@ int vnic_wq_alloc(struct vnic_dev *vdev, struct vnic_wq *wq, unsigned int index,
113 return 0; 115 return 0;
114} 116}
115 117
116void vnic_wq_init_start(struct vnic_wq *wq, unsigned int cq_index, 118static void vnic_wq_init_start(struct vnic_wq *wq, unsigned int cq_index,
117 unsigned int fetch_index, unsigned int posted_index, 119 unsigned int fetch_index, unsigned int posted_index,
118 unsigned int error_interrupt_enable, 120 unsigned int error_interrupt_enable,
119 unsigned int error_interrupt_offset) 121 unsigned int error_interrupt_offset)
diff --git a/drivers/net/enic/vnic_wq.h b/drivers/net/enic/vnic_wq.h
index 94ac4621acc5..7dd937ac11c2 100644
--- a/drivers/net/enic/vnic_wq.h
+++ b/drivers/net/enic/vnic_wq.h
@@ -153,10 +153,6 @@ static inline void vnic_wq_service(struct vnic_wq *wq,
153void vnic_wq_free(struct vnic_wq *wq); 153void vnic_wq_free(struct vnic_wq *wq);
154int vnic_wq_alloc(struct vnic_dev *vdev, struct vnic_wq *wq, unsigned int index, 154int vnic_wq_alloc(struct vnic_dev *vdev, struct vnic_wq *wq, unsigned int index,
155 unsigned int desc_count, unsigned int desc_size); 155 unsigned int desc_count, unsigned int desc_size);
156void vnic_wq_init_start(struct vnic_wq *wq, unsigned int cq_index,
157 unsigned int fetch_index, unsigned int posted_index,
158 unsigned int error_interrupt_enable,
159 unsigned int error_interrupt_offset);
160void vnic_wq_init(struct vnic_wq *wq, unsigned int cq_index, 156void vnic_wq_init(struct vnic_wq *wq, unsigned int cq_index,
161 unsigned int error_interrupt_enable, 157 unsigned int error_interrupt_enable,
162 unsigned int error_interrupt_offset); 158 unsigned int error_interrupt_offset);
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-03 14:17:38 -0400