]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branches 'for-4.4/upstream-fixes', 'for-4.5/async-suspend', 'for-4.5/container...
[mirror_ubuntu-artful-kernel.git] / drivers / net / ethernet / qlogic / qlcnic / qlcnic_main.c
CommitLineData
af19b491 1/*
40839129 2 * QLogic qlcnic NIC Driver
577ae39d 3 * Copyright (c) 2009-2013 QLogic Corporation
af19b491 4 *
40839129 5 * See LICENSE.qlcnic for copyright and licensing details.
af19b491
AKS		 6 */
7
8#include <linux/vmalloc.h>
9#include <linux/interrupt.h>
7e56cac4 10#include <linux/swab.h>
af19b491 11#include <linux/dma-mapping.h>
13159183 12#include <linux/if_vlan.h>
af19b491
AKS		 13#include <net/ip.h>
14#include <linux/ipv6.h>
15#include <linux/inetdevice.h>
451724c8 16#include <linux/aer.h>
f94bc1e7 17#include <linux/log2.h>
47caf255 18#include <linux/pci.h>
7f1f6056 19#ifdef CONFIG_QLCNIC_VXLAN
2b3d7b75 20#include <net/vxlan.h>
7f1f6056 21#endif
af19b491 22
a930a463
HP		 23#include "qlcnic.h"
24#include "qlcnic_sriov.h"
25#include "qlcnic_hw.h"
26
7f9a0c34 27MODULE_DESCRIPTION("QLogic 1/10 GbE Converged/Intelligent Ethernet Driver");
af19b491
AKS		 28MODULE_LICENSE("GPL");
29MODULE_VERSION(QLCNIC_LINUX_VERSIONID);
30MODULE_FIRMWARE(QLCNIC_UNIFIED_ROMIMAGE_NAME);
31
32char qlcnic_driver_name[] = "qlcnic";
7f9a0c34
SV		 33static const char qlcnic_driver_string[] = "QLogic 1/10 GbE "
34 "Converged/Intelligent Ethernet Driver v" QLCNIC_LINUX_VERSIONID;
af19b491 35
b5e5492c 36static int qlcnic_mac_learn;
b11a25aa 37module_param(qlcnic_mac_learn, int, 0444);
fe1adc6b
JK		 38MODULE_PARM_DESC(qlcnic_mac_learn,
39 "Mac Filter (0=learning is disabled, 1=Driver learning is enabled, 2=FDB learning is enabled)");
b5e5492c 40
629263ac 41int qlcnic_use_msi = 1;
9fd13331 42MODULE_PARM_DESC(use_msi, "MSI interrupt (0=disabled, 1=enabled)");
099f7aa7 43module_param_named(use_msi, qlcnic_use_msi, int, 0444);
af19b491 44
629263ac 45int qlcnic_use_msi_x = 1;
9fd13331 46MODULE_PARM_DESC(use_msi_x, "MSI-X interrupt (0=disabled, 1=enabled)");
099f7aa7 47module_param_named(use_msi_x, qlcnic_use_msi_x, int, 0444);
af19b491 48
629263ac 49int qlcnic_auto_fw_reset = 1;
9fd13331 50MODULE_PARM_DESC(auto_fw_reset, "Auto firmware reset (0=disabled, 1=enabled)");
099f7aa7 51module_param_named(auto_fw_reset, qlcnic_auto_fw_reset, int, 0644);
af19b491 52
629263ac 53int qlcnic_load_fw_file;
3ced0a88 54MODULE_PARM_DESC(load_fw_file, "Load firmware from (0=flash, 1=file, 2=POST in fast mode, 3= POST in medium mode, 4=POST in slow mode)");
099f7aa7 55module_param_named(load_fw_file, qlcnic_load_fw_file, int, 0444);
4d5bdb38 56
1dd06ae8 57static int qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
6bb58bb0 58static void qlcnic_remove(struct pci_dev *pdev);
af19b491
AKS		 59static int qlcnic_open(struct net_device *netdev);
60static int qlcnic_close(struct net_device *netdev);
af19b491 61static void qlcnic_tx_timeout(struct net_device *netdev);
af19b491
AKS		 62static void qlcnic_attach_work(struct work_struct *work);
63static void qlcnic_fwinit_work(struct work_struct *work);
af19b491
AKS		 64#ifdef CONFIG_NET_POLL_CONTROLLER
65static void qlcnic_poll_controller(struct net_device *netdev);
66#endif
67
6df900e9 68static void qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding);
af19b491
AKS		 69static int qlcnic_can_start_firmware(struct qlcnic_adapter *adapter);
70
7eb9855d 71static irqreturn_t qlcnic_tmp_intr(int irq, void *data);
af19b491
AKS		 72static irqreturn_t qlcnic_intr(int irq, void *data);
73static irqreturn_t qlcnic_msi_intr(int irq, void *data);
74static irqreturn_t qlcnic_msix_intr(int irq, void *data);
13159183 75static irqreturn_t qlcnic_msix_tx_intr(int irq, void *data);
af19b491
AKS		 76
77static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev);
9f26f547
AC		 78static int qlcnic_start_firmware(struct qlcnic_adapter *);
79
b5e5492c 80static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter);
9f26f547 81static void qlcnic_dev_set_npar_ready(struct qlcnic_adapter *);
9f26f547 82static int qlcnicvf_start_firmware(struct qlcnic_adapter *);
80d5c368
PM		 83static int qlcnic_vlan_rx_add(struct net_device *, __be16, u16);
84static int qlcnic_vlan_rx_del(struct net_device *, __be16, u16);
b9796a14 85
21041400 86static int qlcnic_82xx_setup_intr(struct qlcnic_adapter *);
87static void qlcnic_82xx_dev_request_reset(struct qlcnic_adapter *, u32);
88static irqreturn_t qlcnic_82xx_clear_legacy_intr(struct qlcnic_adapter *);
89static pci_ers_result_t qlcnic_82xx_io_slot_reset(struct pci_dev *);
90static int qlcnic_82xx_start_firmware(struct qlcnic_adapter *);
91static void qlcnic_82xx_io_resume(struct pci_dev *);
92static void qlcnic_82xx_set_mac_filter_count(struct qlcnic_adapter *);
93static pci_ers_result_t qlcnic_82xx_io_error_detected(struct pci_dev *,
94 pci_channel_state_t);
13159183
SC		 95static u32 qlcnic_vlan_tx_check(struct qlcnic_adapter *adapter)
96{
97 struct qlcnic_hardware_context *ahw = adapter->ahw;
98
99 if (adapter->pdev->device == PCI_DEVICE_ID_QLOGIC_QLE824X)
100 return ahw->capabilities & QLCNIC_FW_CAPABILITY_FVLANTX;
101 else
102 return 1;
103}
104
af19b491
AKS		 105/* PCI Device ID Table */
106#define ENTRY(device) \
107 {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, (device)), \
108 .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
109
9baa3c34 110static const struct pci_device_id qlcnic_pci_tbl[] = {
af19b491 111 ENTRY(PCI_DEVICE_ID_QLOGIC_QLE824X),
13159183 112 ENTRY(PCI_DEVICE_ID_QLOGIC_QLE834X),
f8468331 113 ENTRY(PCI_DEVICE_ID_QLOGIC_VF_QLE834X),
da286a6f
SS		 114 ENTRY(PCI_DEVICE_ID_QLOGIC_QLE8830),
115 ENTRY(PCI_DEVICE_ID_QLOGIC_VF_QLE8C30),
15ca140f
MC		 116 ENTRY(PCI_DEVICE_ID_QLOGIC_QLE844X),
117 ENTRY(PCI_DEVICE_ID_QLOGIC_VF_QLE844X),
af19b491
AKS		 118 {0,}
119};
120
121MODULE_DEVICE_TABLE(pci, qlcnic_pci_tbl);
122
123
5ad6ff9d 124inline void qlcnic_update_cmd_producer(struct qlcnic_host_tx_ring *tx_ring)
af19b491
AKS		 125{
126 writel(tx_ring->producer, tx_ring->crb_cmd_producer);
af19b491
AKS		 127}
128
129static const u32 msi_tgt_status[8] = {
130 ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
131 ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3,
132 ISR_INT_TARGET_STATUS_F4, ISR_INT_TARGET_STATUS_F5,
133 ISR_INT_TARGET_STATUS_F6, ISR_INT_TARGET_STATUS_F7
134};
135
7e2cf4fe
SC		 136static const u32 qlcnic_reg_tbl[] = {
137 0x1B20A8, /* PEG_HALT_STAT1 */
138 0x1B20AC, /* PEG_HALT_STAT2 */
139 0x1B20B0, /* FW_HEARTBEAT */
140 0x1B2100, /* LOCK ID */
141 0x1B2128, /* FW_CAPABILITIES */
142 0x1B2138, /* drv active */
143 0x1B2140, /* dev state */
144 0x1B2144, /* drv state */
145 0x1B2148, /* drv scratch */
146 0x1B214C, /* dev partition info */
147 0x1B2174, /* drv idc ver */
148 0x1B2150, /* fw version major */
149 0x1B2154, /* fw version minor */
150 0x1B2158, /* fw version sub */
151 0x1B219C, /* npar state */
152 0x1B21FC, /* FW_IMG_VALID */
153 0x1B2250, /* CMD_PEG_STATE */
154 0x1B233C, /* RCV_PEG_STATE */
155 0x1B23B4, /* ASIC TEMP */
156 0x1B216C, /* FW api */
157 0x1B2170, /* drv op mode */
158 0x13C010, /* flash lock */
159 0x13C014, /* flash unlock */
160};
161
22999798 162static const struct qlcnic_board_info qlcnic_boards[] = {
15ca140f
MC		 163 { PCI_VENDOR_ID_QLOGIC,
164 PCI_DEVICE_ID_QLOGIC_QLE844X,
165 0x0,
166 0x0,
167 "8400 series 10GbE Converged Network Adapter (TCP/IP Networking)" },
e386cd4a
HM		 168 { PCI_VENDOR_ID_QLOGIC,
169 PCI_DEVICE_ID_QLOGIC_QLE834X,
170 PCI_VENDOR_ID_QLOGIC,
171 0x24e,
172 "8300 Series Dual Port 10GbE Converged Network Adapter "
173 "(TCP/IP Networking)" },
174 { PCI_VENDOR_ID_QLOGIC,
175 PCI_DEVICE_ID_QLOGIC_QLE834X,
176 PCI_VENDOR_ID_QLOGIC,
177 0x243,
178 "8300 Series Single Port 10GbE Converged Network Adapter "
179 "(TCP/IP Networking)" },
180 { PCI_VENDOR_ID_QLOGIC,
181 PCI_DEVICE_ID_QLOGIC_QLE834X,
182 PCI_VENDOR_ID_QLOGIC,
183 0x24a,
184 "8300 Series Dual Port 10GbE Converged Network Adapter "
185 "(TCP/IP Networking)" },
186 { PCI_VENDOR_ID_QLOGIC,
187 PCI_DEVICE_ID_QLOGIC_QLE834X,
188 PCI_VENDOR_ID_QLOGIC,
189 0x246,
190 "8300 Series Dual Port 10GbE Converged Network Adapter "
191 "(TCP/IP Networking)" },
192 { PCI_VENDOR_ID_QLOGIC,
193 PCI_DEVICE_ID_QLOGIC_QLE834X,
194 PCI_VENDOR_ID_QLOGIC,
195 0x252,
196 "8300 Series Dual Port 10GbE Converged Network Adapter "
197 "(TCP/IP Networking)" },
198 { PCI_VENDOR_ID_QLOGIC,
199 PCI_DEVICE_ID_QLOGIC_QLE834X,
200 PCI_VENDOR_ID_QLOGIC,
201 0x26e,
202 "8300 Series Dual Port 10GbE Converged Network Adapter "
203 "(TCP/IP Networking)" },
204 { PCI_VENDOR_ID_QLOGIC,
205 PCI_DEVICE_ID_QLOGIC_QLE834X,
206 PCI_VENDOR_ID_QLOGIC,
207 0x260,
208 "8300 Series Dual Port 10GbE Converged Network Adapter "
209 "(TCP/IP Networking)" },
210 { PCI_VENDOR_ID_QLOGIC,
211 PCI_DEVICE_ID_QLOGIC_QLE834X,
212 PCI_VENDOR_ID_QLOGIC,
213 0x266,
214 "8300 Series Single Port 10GbE Converged Network Adapter "
215 "(TCP/IP Networking)" },
216 { PCI_VENDOR_ID_QLOGIC,
217 PCI_DEVICE_ID_QLOGIC_QLE834X,
218 PCI_VENDOR_ID_QLOGIC,
219 0x269,
220 "8300 Series Dual Port 10GbE Converged Network Adapter "
221 "(TCP/IP Networking)" },
222 { PCI_VENDOR_ID_QLOGIC,
223 PCI_DEVICE_ID_QLOGIC_QLE834X,
224 PCI_VENDOR_ID_QLOGIC,
225 0x271,
226 "8300 Series Dual Port 10GbE Converged Network Adapter "
227 "(TCP/IP Networking)" },
228 { PCI_VENDOR_ID_QLOGIC,
229 PCI_DEVICE_ID_QLOGIC_QLE834X,
230 0x0, 0x0, "8300 Series 1/10GbE Controller" },
40e2b8ed
SS		 231 { PCI_VENDOR_ID_QLOGIC,
232 PCI_DEVICE_ID_QLOGIC_QLE8830,
233 0x0,
234 0x0,
235 "8830 Series 1/10GbE Controller" },
e386cd4a
HM		 236 { PCI_VENDOR_ID_QLOGIC,
237 PCI_DEVICE_ID_QLOGIC_QLE824X,
238 PCI_VENDOR_ID_QLOGIC,
239 0x203,
240 "8200 Series Single Port 10GbE Converged Network Adapter"
241 "(TCP/IP Networking)" },
242 { PCI_VENDOR_ID_QLOGIC,
243 PCI_DEVICE_ID_QLOGIC_QLE824X,
244 PCI_VENDOR_ID_QLOGIC,
245 0x207,
246 "8200 Series Dual Port 10GbE Converged Network Adapter"
247 "(TCP/IP Networking)" },
248 { PCI_VENDOR_ID_QLOGIC,
249 PCI_DEVICE_ID_QLOGIC_QLE824X,
250 PCI_VENDOR_ID_QLOGIC,
251 0x20b,
252 "3200 Series Dual Port 10Gb Intelligent Ethernet Adapter" },
253 { PCI_VENDOR_ID_QLOGIC,
254 PCI_DEVICE_ID_QLOGIC_QLE824X,
255 PCI_VENDOR_ID_QLOGIC,
256 0x20c,
257 "3200 Series Quad Port 1Gb Intelligent Ethernet Adapter" },
258 { PCI_VENDOR_ID_QLOGIC,
259 PCI_DEVICE_ID_QLOGIC_QLE824X,
260 PCI_VENDOR_ID_QLOGIC,
261 0x20f,
262 "3200 Series Single Port 10Gb Intelligent Ethernet Adapter" },
263 { PCI_VENDOR_ID_QLOGIC,
264 PCI_DEVICE_ID_QLOGIC_QLE824X,
265 0x103c, 0x3733,
266 "NC523SFP 10Gb 2-port Server Adapter" },
267 { PCI_VENDOR_ID_QLOGIC,
268 PCI_DEVICE_ID_QLOGIC_QLE824X,
269 0x103c, 0x3346,
270 "CN1000Q Dual Port Converged Network Adapter" },
271 { PCI_VENDOR_ID_QLOGIC,
272 PCI_DEVICE_ID_QLOGIC_QLE824X,
273 PCI_VENDOR_ID_QLOGIC,
274 0x210,
275 "QME8242-k 10GbE Dual Port Mezzanine Card" },
276 { PCI_VENDOR_ID_QLOGIC,
277 PCI_DEVICE_ID_QLOGIC_QLE824X,
278 0x0, 0x0, "cLOM8214 1/10GbE Controller" },
22999798
SC		 279};
280
281#define NUM_SUPPORTED_BOARDS ARRAY_SIZE(qlcnic_boards)
282
af19b491
AKS		 283static const
284struct qlcnic_legacy_intr_set legacy_intr[] = QLCNIC_LEGACY_INTR_CONFIG;
285
c70001a9 286int qlcnic_alloc_sds_rings(struct qlcnic_recv_context *recv_ctx, int count)
af19b491
AKS		 287{
288 int size = sizeof(struct qlcnic_host_sds_ring) * count;
289
290 recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
291
807540ba 292 return recv_ctx->sds_rings == NULL;
af19b491
AKS		 293}
294
c70001a9 295void qlcnic_free_sds_rings(struct qlcnic_recv_context *recv_ctx)
af19b491 296{
7061b2bd 297 kfree(recv_ctx->sds_rings);
af19b491
AKS		 298 recv_ctx->sds_rings = NULL;
299}
300
f8468331 301int qlcnic_read_mac_addr(struct qlcnic_adapter *adapter)
af19b491 302{
af19b491
AKS		 303 struct net_device *netdev = adapter->netdev;
304 struct pci_dev *pdev = adapter->pdev;
07a251c8
SS		 305 u8 mac_addr[ETH_ALEN];
306 int ret;
af19b491 307
07a251c8
SS		 308 ret = qlcnic_get_mac_address(adapter, mac_addr,
309 adapter->ahw->pci_func);
310 if (ret)
311 return ret;
af19b491 312
2e9d722d 313 memcpy(netdev->dev_addr, mac_addr, ETH_ALEN);
af19b491
AKS		 314 memcpy(adapter->mac_addr, netdev->dev_addr, netdev->addr_len);
315
316 /* set station address */
317
aaeb6cdf 318 if (!is_valid_ether_addr(netdev->dev_addr))
af19b491
AKS		 319 dev_warn(&pdev->dev, "Bad MAC address %pM.\n",
320 netdev->dev_addr);
321
322 return 0;
323}
324
cffe52f3
MC		 325static void qlcnic_delete_adapter_mac(struct qlcnic_adapter *adapter)
326{
154d0c81 327 struct qlcnic_mac_vlan_list *cur;
cffe52f3
MC		 328 struct list_head *head;
329
330 list_for_each(head, &adapter->mac_list) {
154d0c81 331 cur = list_entry(head, struct qlcnic_mac_vlan_list, list);
6878f79a 332 if (ether_addr_equal_unaligned(adapter->mac_addr, cur->mac_addr)) {
cffe52f3
MC		 333 qlcnic_sre_macaddr_change(adapter, cur->mac_addr,
334 0, QLCNIC_MAC_DEL);
335 list_del(&cur->list);
336 kfree(cur);
337 return;
338 }
339 }
340}
341
af19b491
AKS		 342static int qlcnic_set_mac(struct net_device *netdev, void *p)
343{
344 struct qlcnic_adapter *adapter = netdev_priv(netdev);
345 struct sockaddr *addr = p;
346
7cb03b23
RB		 347 if (qlcnic_sriov_vf_check(adapter))
348 return -EINVAL;
349
7373373d
RB		 350 if ((adapter->flags & QLCNIC_MAC_OVERRIDE_DISABLED))
351 return -EOPNOTSUPP;
352
af19b491 353 if (!is_valid_ether_addr(addr->sa_data))
13159183 354 return -EINVAL;
af19b491 355
e824de8a
JW		 356 if (ether_addr_equal_unaligned(adapter->mac_addr, addr->sa_data) &&
357 ether_addr_equal_unaligned(netdev->dev_addr, addr->sa_data))
cffe52f3
MC		 358 return 0;
359
8a15ad1f 360 if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
af19b491
AKS		 361 netif_device_detach(netdev);
362 qlcnic_napi_disable(adapter);
363 }
364
cffe52f3 365 qlcnic_delete_adapter_mac(adapter);
af19b491
AKS		 366 memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
367 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
368 qlcnic_set_multi(adapter->netdev);
369
8a15ad1f 370 if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
af19b491
AKS		 371 netif_device_attach(netdev);
372 qlcnic_napi_enable(adapter);
373 }
374 return 0;
375}
376
1690be63 377static int qlcnic_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
f6f6424b
JP		 378 struct net_device *netdev,
379 const unsigned char *addr, u16 vid)
fe1adc6b
JK		 380{
381 struct qlcnic_adapter *adapter = netdev_priv(netdev);
382 int err = -EOPNOTSUPP;
383
3e5c112f 384 if (!adapter->fdb_mac_learn)
f6f6424b 385 return ndo_dflt_fdb_del(ndm, tb, netdev, addr, vid);
fe1adc6b 386
d747c333
RB		 387 if ((adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
388 qlcnic_sriov_check(adapter)) {
52e493d0
JK		 389 if (is_unicast_ether_addr(addr)) {
390 err = dev_uc_del(netdev, addr);
391 if (!err)
392 err = qlcnic_nic_del_mac(adapter, addr);
393 } else if (is_multicast_ether_addr(addr)) {
fe1adc6b 394 err = dev_mc_del(netdev, addr);
52e493d0 395 } else {
fe1adc6b 396 err = -EINVAL;
52e493d0 397 }
fe1adc6b
JK		 398 }
399 return err;
400}
401
402static int qlcnic_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
403 struct net_device *netdev,
f6f6424b 404 const unsigned char *addr, u16 vid, u16 flags)
fe1adc6b
JK		 405{
406 struct qlcnic_adapter *adapter = netdev_priv(netdev);
407 int err = 0;
408
3e5c112f 409 if (!adapter->fdb_mac_learn)
f6f6424b 410 return ndo_dflt_fdb_add(ndm, tb, netdev, addr, vid, flags);
fe1adc6b 411
d747c333
RB		 412 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED) &&
413 !qlcnic_sriov_check(adapter)) {
fe1adc6b
JK		 414 pr_info("%s: FDB e-switch is not enabled\n", __func__);
415 return -EOPNOTSUPP;
416 }
417
418 if (ether_addr_equal(addr, adapter->mac_addr))
419 return err;
420
52e493d0
JK		 421 if (is_unicast_ether_addr(addr)) {
422 if (netdev_uc_count(netdev) < adapter->ahw->max_uc_count)
423 err = dev_uc_add_excl(netdev, addr);
424 else
425 err = -ENOMEM;
426 } else if (is_multicast_ether_addr(addr)) {
fe1adc6b 427 err = dev_mc_add_excl(netdev, addr);
52e493d0 428 } else {
fe1adc6b 429 err = -EINVAL;
52e493d0 430 }
fe1adc6b
JK		 431
432 return err;
433}
434
435static int qlcnic_fdb_dump(struct sk_buff *skb, struct netlink_callback *ncb,
5d5eacb3
JHS		 436 struct net_device *netdev,
437 struct net_device *filter_dev, int idx)
fe1adc6b
JK		 438{
439 struct qlcnic_adapter *adapter = netdev_priv(netdev);
440
3e5c112f 441 if (!adapter->fdb_mac_learn)
5d5eacb3 442 return ndo_dflt_fdb_dump(skb, ncb, netdev, filter_dev, idx);
fe1adc6b 443
d747c333
RB		 444 if ((adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
445 qlcnic_sriov_check(adapter))
5d5eacb3 446 idx = ndo_dflt_fdb_dump(skb, ncb, netdev, filter_dev, idx);
fe1adc6b
JK		 447
448 return idx;
449}
450
7e2cf4fe
SC		 451static void qlcnic_82xx_cancel_idc_work(struct qlcnic_adapter *adapter)
452{
453 while (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
454 usleep_range(10000, 11000);
455
66451615
SC		 456 if (!adapter->fw_work.work.func)
457 return;
458
7e2cf4fe
SC		 459 cancel_delayed_work_sync(&adapter->fw_work);
460}
461
07a251c8 462static int qlcnic_get_phys_port_id(struct net_device *netdev,
02637fce 463 struct netdev_phys_item_id *ppid)
07a251c8
SS		 464{
465 struct qlcnic_adapter *adapter = netdev_priv(netdev);
466 struct qlcnic_hardware_context *ahw = adapter->ahw;
467
468 if (!(adapter->flags & QLCNIC_HAS_PHYS_PORT_ID))
469 return -EOPNOTSUPP;
470
471 ppid->id_len = sizeof(ahw->phys_port_id);
472 memcpy(ppid->id, ahw->phys_port_id, ppid->id_len);
473
474 return 0;
475}
476
7f1f6056 477#ifdef CONFIG_QLCNIC_VXLAN
2b3d7b75
SS		 478static void qlcnic_add_vxlan_port(struct net_device *netdev,
479 sa_family_t sa_family, __be16 port)
480{
481 struct qlcnic_adapter *adapter = netdev_priv(netdev);
482 struct qlcnic_hardware_context *ahw = adapter->ahw;
483
484 /* Adapter supports only one VXLAN port. Use very first port
485 * for enabling offload
486 */
378fddc2 487 if (!qlcnic_encap_rx_offload(adapter))
2b3d7b75 488 return;
378fddc2
JB		 489 if (!ahw->vxlan_port_count) {
490 ahw->vxlan_port_count = 1;
491 ahw->vxlan_port = ntohs(port);
492 adapter->flags |= QLCNIC_ADD_VXLAN_PORT;
493 return;
494 }
495 if (ahw->vxlan_port == ntohs(port))
496 ahw->vxlan_port_count++;
2b3d7b75 497
2b3d7b75
SS		 498}
499
500static void qlcnic_del_vxlan_port(struct net_device *netdev,
501 sa_family_t sa_family, __be16 port)
502{
503 struct qlcnic_adapter *adapter = netdev_priv(netdev);
504 struct qlcnic_hardware_context *ahw = adapter->ahw;
505
378fddc2 506 if (!qlcnic_encap_rx_offload(adapter) || !ahw->vxlan_port_count ||
2b3d7b75
SS		 507 (ahw->vxlan_port != ntohs(port)))
508 return;
509
378fddc2
JB		 510 ahw->vxlan_port_count--;
511 if (!ahw->vxlan_port_count)
512 adapter->flags |= QLCNIC_DEL_VXLAN_PORT;
2b3d7b75 513}
795a05c1 514
5f35227e
JG		 515static netdev_features_t qlcnic_features_check(struct sk_buff *skb,
516 struct net_device *dev,
517 netdev_features_t features)
795a05c1 518{
8cb65d00 519 features = vlan_features_check(skb, features);
5f35227e 520 return vxlan_features_check(skb, features);
795a05c1 521}
7f1f6056 522#endif
2b3d7b75 523
af19b491
AKS		 524static const struct net_device_ops qlcnic_netdev_ops = {
525 .ndo_open = qlcnic_open,
526 .ndo_stop = qlcnic_close,
527 .ndo_start_xmit = qlcnic_xmit_frame,
528 .ndo_get_stats = qlcnic_get_stats,
529 .ndo_validate_addr = eth_validate_addr,
afc4b13d 530 .ndo_set_rx_mode = qlcnic_set_multi,
af19b491
AKS		 531 .ndo_set_mac_address = qlcnic_set_mac,
532 .ndo_change_mtu = qlcnic_change_mtu,
135d84a9
MM		 533 .ndo_fix_features = qlcnic_fix_features,
534 .ndo_set_features = qlcnic_set_features,
af19b491 535 .ndo_tx_timeout = qlcnic_tx_timeout,
b9796a14
AC		 536 .ndo_vlan_rx_add_vid = qlcnic_vlan_rx_add,
537 .ndo_vlan_rx_kill_vid = qlcnic_vlan_rx_del,
fe1adc6b
JK		 538 .ndo_fdb_add = qlcnic_fdb_add,
539 .ndo_fdb_del = qlcnic_fdb_del,
540 .ndo_fdb_dump = qlcnic_fdb_dump,
07a251c8 541 .ndo_get_phys_port_id = qlcnic_get_phys_port_id,
7f1f6056 542#ifdef CONFIG_QLCNIC_VXLAN
2b3d7b75
SS		 543 .ndo_add_vxlan_port = qlcnic_add_vxlan_port,
544 .ndo_del_vxlan_port = qlcnic_del_vxlan_port,
5f35227e 545 .ndo_features_check = qlcnic_features_check,
7f1f6056 546#endif
af19b491
AKS		 547#ifdef CONFIG_NET_POLL_CONTROLLER
548 .ndo_poll_controller = qlcnic_poll_controller,
549#endif
4000e7a7
RB		 550#ifdef CONFIG_QLCNIC_SRIOV
551 .ndo_set_vf_mac = qlcnic_sriov_set_vf_mac,
ed616689 552 .ndo_set_vf_rate = qlcnic_sriov_set_vf_tx_rate,
4000e7a7 553 .ndo_get_vf_config = qlcnic_sriov_get_vf_config,
91b7282b 554 .ndo_set_vf_vlan = qlcnic_sriov_set_vf_vlan,
a80be5a5 555 .ndo_set_vf_spoofchk = qlcnic_sriov_set_vf_spoofchk,
4000e7a7 556#endif
af19b491
AKS		 557};
558
b43e5ee7
SC		 559static const struct net_device_ops qlcnic_netdev_failed_ops = {
560 .ndo_open = qlcnic_open,
561};
562
2e9d722d 563static struct qlcnic_nic_template qlcnic_ops = {
7e2cf4fe
SC		 564 .config_bridged_mode = qlcnic_config_bridged_mode,
565 .config_led = qlcnic_82xx_config_led,
566 .start_firmware = qlcnic_82xx_start_firmware,
567 .request_reset = qlcnic_82xx_dev_request_reset,
568 .cancel_idc_work = qlcnic_82xx_cancel_idc_work,
569 .napi_add = qlcnic_82xx_napi_add,
4be41e92 570 .napi_del = qlcnic_82xx_napi_del,
7e2cf4fe 571 .config_ipaddr = qlcnic_82xx_config_ipaddr,
486a5bc7
RB		 572 .shutdown = qlcnic_82xx_shutdown,
573 .resume = qlcnic_82xx_resume,
7e2cf4fe
SC		 574 .clear_legacy_intr = qlcnic_82xx_clear_legacy_intr,
575};
576
577struct qlcnic_nic_template qlcnic_vf_ops = {
578 .config_bridged_mode = qlcnicvf_config_bridged_mode,
579 .config_led = qlcnicvf_config_led,
580 .start_firmware = qlcnicvf_start_firmware
9f26f547
AC		 581};
582
7e2cf4fe
SC		 583static struct qlcnic_hardware_ops qlcnic_hw_ops = {
584 .read_crb = qlcnic_82xx_read_crb,
585 .write_crb = qlcnic_82xx_write_crb,
586 .read_reg = qlcnic_82xx_hw_read_wx_2M,
587 .write_reg = qlcnic_82xx_hw_write_wx_2M,
588 .get_mac_address = qlcnic_82xx_get_mac_address,
589 .setup_intr = qlcnic_82xx_setup_intr,
590 .alloc_mbx_args = qlcnic_82xx_alloc_mbx_args,
591 .mbx_cmd = qlcnic_82xx_issue_cmd,
592 .get_func_no = qlcnic_82xx_get_func_no,
593 .api_lock = qlcnic_82xx_api_lock,
594 .api_unlock = qlcnic_82xx_api_unlock,
595 .add_sysfs = qlcnic_82xx_add_sysfs,
596 .remove_sysfs = qlcnic_82xx_remove_sysfs,
597 .process_lb_rcv_ring_diag = qlcnic_82xx_process_rcv_ring_diag,
598 .create_rx_ctx = qlcnic_82xx_fw_cmd_create_rx_ctx,
599 .create_tx_ctx = qlcnic_82xx_fw_cmd_create_tx_ctx,
7cb03b23
RB		 600 .del_rx_ctx = qlcnic_82xx_fw_cmd_del_rx_ctx,
601 .del_tx_ctx = qlcnic_82xx_fw_cmd_del_tx_ctx,
7e2cf4fe
SC		 602 .setup_link_event = qlcnic_82xx_linkevent_request,
603 .get_nic_info = qlcnic_82xx_get_nic_info,
604 .get_pci_info = qlcnic_82xx_get_pci_info,
605 .set_nic_info = qlcnic_82xx_set_nic_info,
606 .change_macvlan = qlcnic_82xx_sre_macaddr_change,
607 .napi_enable = qlcnic_82xx_napi_enable,
608 .napi_disable = qlcnic_82xx_napi_disable,
609 .config_intr_coal = qlcnic_82xx_config_intr_coalesce,
610 .config_rss = qlcnic_82xx_config_rss,
611 .config_hw_lro = qlcnic_82xx_config_hw_lro,
612 .config_loopback = qlcnic_82xx_set_lb_mode,
613 .clear_loopback = qlcnic_82xx_clear_lb_mode,
614 .config_promisc_mode = qlcnic_82xx_nic_set_promisc,
615 .change_l2_filter = qlcnic_82xx_change_filter,
616 .get_board_info = qlcnic_82xx_get_board_info,
52e493d0 617 .set_mac_filter_count = qlcnic_82xx_set_mac_filter_count,
91b7282b 618 .free_mac_list = qlcnic_82xx_free_mac_list,
07a251c8 619 .read_phys_port_id = qlcnic_82xx_read_phys_port_id,
4460f2e8
PP		 620 .io_error_detected = qlcnic_82xx_io_error_detected,
621 .io_slot_reset = qlcnic_82xx_io_slot_reset,
622 .io_resume = qlcnic_82xx_io_resume,
a0431589 623 .get_beacon_state = qlcnic_82xx_get_beacon_state,
2cc5752e
M		 624 .enable_sds_intr = qlcnic_82xx_enable_sds_intr,
625 .disable_sds_intr = qlcnic_82xx_disable_sds_intr,
626 .enable_tx_intr = qlcnic_82xx_enable_tx_intr,
627 .disable_tx_intr = qlcnic_82xx_disable_tx_intr,
225837a0
SS		 628 .get_saved_state = qlcnic_82xx_get_saved_state,
629 .set_saved_state = qlcnic_82xx_set_saved_state,
630 .cache_tmpl_hdr_values = qlcnic_82xx_cache_tmpl_hdr_values,
631 .get_cap_size = qlcnic_82xx_get_cap_size,
632 .set_sys_info = qlcnic_82xx_set_sys_info,
633 .store_cap_mask = qlcnic_82xx_store_cap_mask,
2e9d722d
AC		 634};
635
34e8c406 636static int qlcnic_check_multi_tx_capability(struct qlcnic_adapter *adapter)
012ec812
HM		 637{
638 struct qlcnic_hardware_context *ahw = adapter->ahw;
012ec812 639
34e8c406 640 if (qlcnic_82xx_check(adapter) &&
012ec812 641 (ahw->extra_capability[0] & QLCNIC_FW_CAPABILITY_2_MULTI_TX)) {
34e8c406
HM		 642 test_and_set_bit(__QLCNIC_MULTI_TX_UNIQUE, &adapter->state);
643 return 0;
012ec812 644 } else {
34e8c406 645 return 1;
012ec812
HM		 646 }
647}
648
34e8c406
HM		 649static int qlcnic_max_rings(struct qlcnic_adapter *adapter, u8 ring_cnt,
650 int queue_type)
651{
652 int num_rings, max_rings = QLCNIC_MAX_SDS_RINGS;
653
654 if (queue_type == QLCNIC_RX_QUEUE)
655 max_rings = adapter->max_sds_rings;
656 else if (queue_type == QLCNIC_TX_QUEUE)
657 max_rings = adapter->max_tx_rings;
658
659 num_rings = rounddown_pow_of_two(min_t(int, num_online_cpus(),
660 max_rings));
661
662 if (ring_cnt > num_rings)
663 return num_rings;
664 else
665 return ring_cnt;
666}
667
668void qlcnic_set_tx_ring_count(struct qlcnic_adapter *adapter, u8 tx_cnt)
669{
670 /* 83xx adapter does not have max_tx_rings intialized in probe */
671 if (adapter->max_tx_rings)
672 adapter->drv_tx_rings = qlcnic_max_rings(adapter, tx_cnt,
673 QLCNIC_TX_QUEUE);
674 else
675 adapter->drv_tx_rings = tx_cnt;
34e8c406
HM		 676}
677
678void qlcnic_set_sds_ring_count(struct qlcnic_adapter *adapter, u8 rx_cnt)
679{
680 /* 83xx adapter does not have max_sds_rings intialized in probe */
681 if (adapter->max_sds_rings)
682 adapter->drv_sds_rings = qlcnic_max_rings(adapter, rx_cnt,
683 QLCNIC_RX_QUEUE);
684 else
685 adapter->drv_sds_rings = rx_cnt;
34e8c406
HM		 686}
687
cb9327d5 688int qlcnic_setup_tss_rss_intr(struct qlcnic_adapter *adapter)
af19b491 689{
af19b491 690 struct pci_dev *pdev = adapter->pdev;
cb9327d5
HM		 691 int num_msix = 0, err = 0, vector;
692
693 adapter->flags &= ~QLCNIC_TSS_RSS;
694
695 if (adapter->drv_tss_rings > 0)
696 num_msix += adapter->drv_tss_rings;
697 else
698 num_msix += adapter->drv_tx_rings;
699
8564ae09 700 if (adapter->drv_rss_rings > 0)
cb9327d5
HM		 701 num_msix += adapter->drv_rss_rings;
702 else
703 num_msix += adapter->drv_sds_rings;
704
705 if (qlcnic_83xx_check(adapter))
706 num_msix += 1;
707
708 if (!adapter->msix_entries) {
709 adapter->msix_entries = kcalloc(num_msix,
710 sizeof(struct msix_entry),
711 GFP_KERNEL);
712 if (!adapter->msix_entries)
713 return -ENOMEM;
714 }
715
cb9327d5
HM		 716 for (vector = 0; vector < num_msix; vector++)
717 adapter->msix_entries[vector].entry = vector;
718
8564ae09 719restore:
f7167750
AG		 720 err = pci_enable_msix_exact(pdev, adapter->msix_entries, num_msix);
721 if (err == -ENOSPC) {
8564ae09 722 if (!adapter->drv_tss_rings && !adapter->drv_rss_rings)
f7167750 723 return err;
da6c8063 724
cb9327d5
HM		 725 netdev_info(adapter->netdev,
726 "Unable to allocate %d MSI-X vectors, Available vectors %d\n",
727 num_msix, err);
728
729 num_msix = adapter->drv_tx_rings + adapter->drv_sds_rings;
730
731 /* Set rings to 0 so we can restore original TSS/RSS count */
732 adapter->drv_tss_rings = 0;
733 adapter->drv_rss_rings = 0;
734
735 if (qlcnic_83xx_check(adapter))
736 num_msix += 1;
737
738 netdev_info(adapter->netdev,
739 "Restoring %d Tx, %d SDS rings for total %d vectors.\n",
740 adapter->drv_tx_rings, adapter->drv_sds_rings,
741 num_msix);
cb9327d5 742
8564ae09
AG		 743 goto restore;
744 } else if (err < 0) {
745 return err;
da6c8063 746 }
13159183 747
8564ae09
AG		 748 adapter->ahw->num_msix = num_msix;
749 if (adapter->drv_tss_rings > 0)
750 adapter->drv_tx_rings = adapter->drv_tss_rings;
751
752 if (adapter->drv_rss_rings > 0)
753 adapter->drv_sds_rings = adapter->drv_rss_rings;
754
755 return 0;
cb9327d5
HM		 756}
757
758int qlcnic_enable_msix(struct qlcnic_adapter *adapter, u32 num_msix)
759{
760 struct pci_dev *pdev = adapter->pdev;
74a1fa45 761 int err, vector;
cb9327d5 762
13159183
SC		 763 if (!adapter->msix_entries) {
764 adapter->msix_entries = kcalloc(num_msix,
765 sizeof(struct msix_entry),
766 GFP_KERNEL);
b2adaca9 767 if (!adapter->msix_entries)
13159183 768 return -ENOMEM;
13159183 769 }
af19b491 770
af19b491 771 adapter->flags &= ~(QLCNIC_MSI_ENABLED | QLCNIC_MSIX_ENABLED);
af19b491 772
79788450 773 if (adapter->ahw->msix_supported) {
cb9327d5
HM		 774enable_msix:
775 for (vector = 0; vector < num_msix; vector++)
776 adapter->msix_entries[vector].entry = vector;
777
9732ec06
AG		 778 err = pci_enable_msix_range(pdev,
779 adapter->msix_entries, 1, num_msix);
780
781 if (err == num_msix) {
af19b491 782 adapter->flags |= QLCNIC_MSIX_ENABLED;
cb9327d5 783 adapter->ahw->num_msix = num_msix;
af19b491 784 dev_info(&pdev->dev, "using msi-x interrupts\n");
74a1fa45 785 return 0;
13159183 786 } else if (err > 0) {
9732ec06
AG		 787 pci_disable_msix(pdev);
788
13159183 789 dev_info(&pdev->dev,
cb9327d5
HM		 790 "Unable to allocate %d MSI-X vectors, Available vectors %d\n",
791 num_msix, err);
792
793 if (qlcnic_82xx_check(adapter)) {
13159183 794 num_msix = rounddown_pow_of_two(err);
cb9327d5 795 if (err < QLCNIC_82XX_MINIMUM_VECTOR)
74a1fa45 796 return -ENOSPC;
13159183 797 } else {
cb9327d5
HM		 798 num_msix = rounddown_pow_of_two(err - 1);
799 num_msix += 1;
800 if (err < QLCNIC_83XX_MINIMUM_VECTOR)
74a1fa45 801 return -ENOSPC;
cb9327d5
HM		 802 }
803
804 if (qlcnic_82xx_check(adapter) &&
805 !qlcnic_check_multi_tx(adapter)) {
806 adapter->drv_sds_rings = num_msix;
807 adapter->drv_tx_rings = QLCNIC_SINGLE_RING;
808 } else {
809 /* Distribute vectors equally */
810 adapter->drv_tx_rings = num_msix / 2;
811 adapter->drv_sds_rings = adapter->drv_tx_rings;
13159183
SC		 812 }
813
814 if (num_msix) {
815 dev_info(&pdev->dev,
dce056cb 816 "Trying to allocate %d MSI-X interrupt vectors\n",
13159183 817 num_msix);
f94bc1e7 818 goto enable_msix;
13159183
SC		 819 }
820 } else {
dce056cb 821 dev_info(&pdev->dev,
cb9327d5
HM		 822 "Unable to allocate %d MSI-X vectors, err=%d\n",
823 num_msix, err);
824 return err;
f94bc1e7
SC		 825 }
826 }
13159183 827
74a1fa45 828 return -EIO;
f94bc1e7 829}
af19b491 830
cb9327d5
HM		 831static int qlcnic_82xx_calculate_msix_vector(struct qlcnic_adapter *adapter)
832{
833 int num_msix;
834
835 num_msix = adapter->drv_sds_rings;
836
837 if (qlcnic_check_multi_tx(adapter))
838 num_msix += adapter->drv_tx_rings;
839 else
840 num_msix += QLCNIC_SINGLE_RING;
841
842 return num_msix;
843}
844
9a97e705 845static int qlcnic_enable_msi_legacy(struct qlcnic_adapter *adapter)
f94bc1e7 846{
9a97e705 847 int err = 0;
15087c2b 848 u32 offset, mask_reg;
f94bc1e7 849 const struct qlcnic_legacy_intr_set *legacy_intrp;
15087c2b 850 struct qlcnic_hardware_context *ahw = adapter->ahw;
f94bc1e7 851 struct pci_dev *pdev = adapter->pdev;
af19b491 852
099f7aa7 853 if (qlcnic_use_msi && !pci_enable_msi(pdev)) {
af19b491 854 adapter->flags |= QLCNIC_MSI_ENABLED;
15087c2b
SC		 855 offset = msi_tgt_status[adapter->ahw->pci_func];
856 adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter->ahw,
857 offset);
af19b491
AKS		 858 dev_info(&pdev->dev, "using msi interrupts\n");
859 adapter->msix_entries[0].vector = pdev->irq;
9a97e705 860 return err;
af19b491 861 }
012ec812 862
9a97e705
M		 863 if (qlcnic_use_msi || qlcnic_use_msi_x)
864 return -EOPNOTSUPP;
af19b491 865
f94bc1e7 866 legacy_intrp = &legacy_intr[adapter->ahw->pci_func];
79788450 867 adapter->ahw->int_vec_bit = legacy_intrp->int_vec_bit;
15087c2b
SC		 868 offset = legacy_intrp->tgt_status_reg;
869 adapter->tgt_status_reg = qlcnic_get_ioaddr(ahw, offset);
870 mask_reg = legacy_intrp->tgt_mask_reg;
871 adapter->tgt_mask_reg = qlcnic_get_ioaddr(ahw, mask_reg);
872 adapter->isr_int_vec = qlcnic_get_ioaddr(ahw, ISR_INT_VECTOR);
873 adapter->crb_int_state_reg = qlcnic_get_ioaddr(ahw, ISR_INT_STATE_REG);
af19b491
AKS		 874 dev_info(&pdev->dev, "using legacy interrupts\n");
875 adapter->msix_entries[0].vector = pdev->irq;
9a97e705 876 return err;
af19b491
AKS		 877}
878
21041400 879static int qlcnic_82xx_setup_intr(struct qlcnic_adapter *adapter)
f94bc1e7 880{
9a97e705 881 int num_msix, err = 0;
f94bc1e7 882
cb9327d5
HM		 883 if (adapter->flags & QLCNIC_TSS_RSS) {
884 err = qlcnic_setup_tss_rss_intr(adapter);
885 if (err < 0)
886 return err;
887 num_msix = adapter->ahw->num_msix;
888 } else {
889 num_msix = qlcnic_82xx_calculate_msix_vector(adapter);
f94bc1e7 890
cb9327d5
HM		 891 err = qlcnic_enable_msix(adapter, num_msix);
892 if (err == -ENOMEM)
893 return err;
f94bc1e7 894
cb9327d5
HM		 895 if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
896 qlcnic_disable_multi_tx(adapter);
42beb3f2 897 adapter->drv_sds_rings = QLCNIC_SINGLE_RING;
012ec812 898
cb9327d5 899 err = qlcnic_enable_msi_legacy(adapter);
fc49beae 900 if (err)
cb9327d5
HM		 901 return err;
902 }
012ec812
HM		 903 }
904
905 return 0;
906}
907
908int qlcnic_82xx_mq_intrpt(struct qlcnic_adapter *adapter, int op_type)
909{
910 struct qlcnic_hardware_context *ahw = adapter->ahw;
911 int err, i;
912
913 if (qlcnic_check_multi_tx(adapter) &&
c2c5e3a0 914 !ahw->diag_test &&
012ec812
HM		 915 (adapter->flags & QLCNIC_MSIX_ENABLED)) {
916 ahw->intr_tbl = vzalloc(ahw->num_msix *
917 sizeof(struct qlcnic_intrpt_config));
918 if (!ahw->intr_tbl)
919 return -ENOMEM;
920
921 for (i = 0; i < ahw->num_msix; i++) {
922 ahw->intr_tbl[i].type = QLCNIC_INTRPT_MSIX;
923 ahw->intr_tbl[i].id = i;
924 ahw->intr_tbl[i].src = 0;
925 }
926
927 err = qlcnic_82xx_config_intrpt(adapter, 1);
928 if (err)
929 dev_err(&adapter->pdev->dev,
930 "Failed to configure Interrupt for %d vector\n",
931 ahw->num_msix);
9a97e705 932 return err;
012ec812 933 }
9a97e705 934
012ec812 935 return 0;
f94bc1e7 936}
13159183 937
319ecf12 938void qlcnic_teardown_intr(struct qlcnic_adapter *adapter)
af19b491
AKS		 939{
940 if (adapter->flags & QLCNIC_MSIX_ENABLED)
941 pci_disable_msix(adapter->pdev);
942 if (adapter->flags & QLCNIC_MSI_ENABLED)
943 pci_disable_msi(adapter->pdev);
13159183
SC		 944
945 kfree(adapter->msix_entries);
946 adapter->msix_entries = NULL;
947
948 if (adapter->ahw->intr_tbl) {
949 vfree(adapter->ahw->intr_tbl);
950 adapter->ahw->intr_tbl = NULL;
951 }
af19b491
AKS		 952}
953
f1a094a8 954static void qlcnic_cleanup_pci_map(struct qlcnic_hardware_context *ahw)
af19b491 955{
f1a094a8
RB		 956 if (ahw->pci_base0 != NULL)
957 iounmap(ahw->pci_base0);
af19b491
AKS		 958}
959
7e2cf4fe
SC		 960static int qlcnic_get_act_pci_func(struct qlcnic_adapter *adapter)
961{
2f514c52 962 struct qlcnic_hardware_context *ahw = adapter->ahw;
7e2cf4fe
SC		 963 struct qlcnic_pci_info *pci_info;
964 int ret;
965
966 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
2f514c52 967 switch (ahw->port_type) {
7e2cf4fe 968 case QLCNIC_GBE:
2f514c52 969 ahw->total_nic_func = QLCNIC_NIU_MAX_GBE_PORTS;
7e2cf4fe
SC		 970 break;
971 case QLCNIC_XGBE:
2f514c52 972 ahw->total_nic_func = QLCNIC_NIU_MAX_XG_PORTS;
7e2cf4fe
SC		 973 break;
974 }
975 return 0;
976 }
977
2f514c52 978 if (ahw->op_mode == QLCNIC_MGMT_FUNC)
7e2cf4fe
SC		 979 return 0;
980
2f514c52 981 pci_info = kcalloc(ahw->max_vnic_func, sizeof(*pci_info), GFP_KERNEL);
7e2cf4fe
SC		 982 if (!pci_info)
983 return -ENOMEM;
984
985 ret = qlcnic_get_pci_info(adapter, pci_info);
986 kfree(pci_info);
987 return ret;
988}
d71170fb 989
35dafcb0
SC		 990static bool qlcnic_port_eswitch_cfg_capability(struct qlcnic_adapter *adapter)
991{
992 bool ret = false;
993
994 if (qlcnic_84xx_check(adapter)) {
995 ret = true;
996 } else if (qlcnic_83xx_check(adapter)) {
997 if (adapter->ahw->extra_capability[0] &
998 QLCNIC_FW_CAPABILITY_2_PER_PORT_ESWITCH_CFG)
999 ret = true;
1000 else
1001 ret = false;
1002 }
1003
1004 return ret;
1005}
1006
d71170fb 1007int qlcnic_init_pci_info(struct qlcnic_adapter *adapter)
346fe763 1008{
2f514c52 1009 struct qlcnic_hardware_context *ahw = adapter->ahw;
e88db3bd 1010 struct qlcnic_pci_info *pci_info;
4c776aad 1011 int i, id = 0, ret = 0, j = 0;
bff57d8e 1012 u16 act_pci_func;
346fe763
RB		 1013 u8 pfn;
1014
2f514c52 1015 pci_info = kcalloc(ahw->max_vnic_func, sizeof(*pci_info), GFP_KERNEL);
e88db3bd
DC		 1016 if (!pci_info)
1017 return -ENOMEM;
1018
bff57d8e
SC		 1019 ret = qlcnic_get_pci_info(adapter, pci_info);
1020 if (ret)
1021 goto err_pci_info;
1022
2f514c52 1023 act_pci_func = ahw->total_nic_func;
bff57d8e 1024
ca315ac2 1025 adapter->npars = kzalloc(sizeof(struct qlcnic_npar_info) *
bff57d8e 1026 act_pci_func, GFP_KERNEL);
e88db3bd 1027 if (!adapter->npars) {
900853a4 1028 ret = -ENOMEM;
e88db3bd
DC		 1029 goto err_pci_info;
1030 }
346fe763 1031
ca315ac2 1032 adapter->eswitch = kzalloc(sizeof(struct qlcnic_eswitch) *
346fe763
RB		 1033 QLCNIC_NIU_MAX_XG_PORTS, GFP_KERNEL);
1034 if (!adapter->eswitch) {
900853a4 1035 ret = -ENOMEM;
ca315ac2 1036 goto err_npars;
346fe763
RB		 1037 }
1038
2f514c52 1039 for (i = 0; i < ahw->max_vnic_func; i++) {
ca315ac2 1040 pfn = pci_info[i].id;
bff57d8e 1041
2f514c52 1042 if (pfn >= ahw->max_vnic_func) {
d7a32b6e 1043 ret = -EINVAL;
c65762fc
SC		 1044 dev_err(&adapter->pdev->dev, "%s: Invalid function 0x%x, max 0x%x\n",
1045 __func__, pfn, ahw->max_vnic_func);
f848d6dd
SC		 1046 goto err_eswitch;
1047 }
bff57d8e
SC		 1048
1049 if (!pci_info[i].active ||
1050 (pci_info[i].type != QLCNIC_TYPE_NIC))
1051 continue;
1052
35dafcb0 1053 if (qlcnic_port_eswitch_cfg_capability(adapter)) {
4c776aad
SC		 1054 if (!qlcnic_83xx_set_port_eswitch_status(adapter, pfn,
1055 &id))
35dafcb0
SC		 1056 adapter->npars[j].eswitch_status = true;
1057 else
1058 continue;
1059 } else {
1060 adapter->npars[j].eswitch_status = true;
1061 }
1062
bff57d8e
SC		 1063 adapter->npars[j].pci_func = pfn;
1064 adapter->npars[j].active = (u8)pci_info[i].active;
1065 adapter->npars[j].type = (u8)pci_info[i].type;
1066 adapter->npars[j].phy_port = (u8)pci_info[i].default_port;
1067 adapter->npars[j].min_bw = pci_info[i].tx_min_bw;
1068 adapter->npars[j].max_bw = pci_info[i].tx_max_bw;
35dafcb0 1069
9e630955 1070 memcpy(&adapter->npars[j].mac, &pci_info[i].mac, ETH_ALEN);
bff57d8e 1071 j++;
346fe763
RB		 1072 }
1073
4c776aad
SC		 1074 /* Update eSwitch status for adapters without per port eSwitch
1075 * configuration capability
1076 */
1077 if (!qlcnic_port_eswitch_cfg_capability(adapter)) {
35dafcb0
SC		 1078 for (i = 0; i < QLCNIC_NIU_MAX_XG_PORTS; i++)
1079 adapter->eswitch[i].flags |= QLCNIC_SWITCH_ENABLE;
13159183 1080 }
ca315ac2 1081
e88db3bd 1082 kfree(pci_info);
ca315ac2
DC		 1083 return 0;
1084
1085err_eswitch:
346fe763
RB		 1086 kfree(adapter->eswitch);
1087 adapter->eswitch = NULL;
ca315ac2 1088err_npars:
346fe763 1089 kfree(adapter->npars);
ca315ac2 1090 adapter->npars = NULL;
e88db3bd
DC		 1091err_pci_info:
1092 kfree(pci_info);
346fe763
RB		 1093
1094 return ret;
1095}
1096
2e9d722d
AC		 1097static int
1098qlcnic_set_function_modes(struct qlcnic_adapter *adapter)
1099{
1100 u8 id;
7e8fd003 1101 int ret;
2e9d722d 1102 u32 data = QLCNIC_MGMT_FUNC;
bff57d8e 1103 struct qlcnic_hardware_context *ahw = adapter->ahw;
2e9d722d 1104
2e9d722d
AC		 1105 ret = qlcnic_api_lock(adapter);
1106 if (ret)
1107 goto err_lock;
2e9d722d 1108
7e8fd003
SS		 1109 id = ahw->pci_func;
1110 data = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
1111 data = (data & ~QLC_DEV_SET_DRV(0xf, id)) |
1112 QLC_DEV_SET_DRV(QLCNIC_MGMT_FUNC, id);
a15ebd37 1113 QLC_SHARED_REG_WR32(adapter, QLCNIC_DRV_OP_MODE, data);
2e9d722d
AC		 1114 qlcnic_api_unlock(adapter);
1115err_lock:
1116 return ret;
1117}
1118
13159183
SC		 1119static void qlcnic_check_vf(struct qlcnic_adapter *adapter,
1120 const struct pci_device_id *ent)
2e9d722d 1121{
2e9d722d
AC		 1122 u32 op_mode, priv_level;
1123
1124 /* Determine FW API version */
13159183
SC		 1125 adapter->ahw->fw_hal_version = QLC_SHARED_REG_RD32(adapter,
1126 QLCNIC_FW_API);
2e9d722d
AC		 1127
1128 /* Find PCI function number */
13159183 1129 qlcnic_get_func_no(adapter);
2e9d722d
AC		 1130
1131 /* Determine function privilege level */
13159183 1132 op_mode = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
0e33c664 1133 if (op_mode == QLC_DEV_DRV_DEFAULT)
2e9d722d 1134 priv_level = QLCNIC_MGMT_FUNC;
0e33c664 1135 else
b1fc6d3c 1136 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
2e9d722d 1137
0866d96d 1138 if (priv_level == QLCNIC_NON_PRIV_FUNC) {
79788450 1139 adapter->ahw->op_mode = QLCNIC_NON_PRIV_FUNC;
9f26f547
AC		 1140 dev_info(&adapter->pdev->dev,
1141 "HAL Version: %d Non Privileged function\n",
79788450 1142 adapter->ahw->fw_hal_version);
9f26f547 1143 adapter->nic_ops = &qlcnic_vf_ops;
0866d96d
AC		 1144 } else
1145 adapter->nic_ops = &qlcnic_ops;
2e9d722d
AC		 1146}
1147
15087c2b 1148#define QLCNIC_82XX_BAR0_LENGTH 0x00200000UL
13159183 1149#define QLCNIC_83XX_BAR0_LENGTH 0x4000
15087c2b
SC		 1150static void qlcnic_get_bar_length(u32 dev_id, ulong *bar)
1151{
1152 switch (dev_id) {
1153 case PCI_DEVICE_ID_QLOGIC_QLE824X:
1154 *bar = QLCNIC_82XX_BAR0_LENGTH;
1155 break;
13159183 1156 case PCI_DEVICE_ID_QLOGIC_QLE834X:
40e2b8ed 1157 case PCI_DEVICE_ID_QLOGIC_QLE8830:
15ca140f 1158 case PCI_DEVICE_ID_QLOGIC_QLE844X:
f8468331 1159 case PCI_DEVICE_ID_QLOGIC_VF_QLE834X:
15ca140f 1160 case PCI_DEVICE_ID_QLOGIC_VF_QLE844X:
da286a6f 1161 case PCI_DEVICE_ID_QLOGIC_VF_QLE8C30:
13159183
SC		 1162 *bar = QLCNIC_83XX_BAR0_LENGTH;
1163 break;
15087c2b
SC		 1164 default:
1165 *bar = 0;
1166 }
1167}
1168
1169static int qlcnic_setup_pci_map(struct pci_dev *pdev,
1170 struct qlcnic_hardware_context *ahw)
af19b491 1171{
15087c2b 1172 u32 offset;
af19b491 1173 void __iomem *mem_ptr0 = NULL;
15087c2b 1174 unsigned long mem_len, pci_len0 = 0, bar0_len;
af19b491 1175
af19b491 1176 /* remap phys address */
af19b491
AKS		 1177 mem_len = pci_resource_len(pdev, 0);
1178
15087c2b
SC		 1179 qlcnic_get_bar_length(pdev->device, &bar0_len);
1180 if (mem_len >= bar0_len) {
af19b491
AKS		 1181
1182 mem_ptr0 = pci_ioremap_bar(pdev, 0);
1183 if (mem_ptr0 == NULL) {
1184 dev_err(&pdev->dev, "failed to map PCI bar 0\n");
1185 return -EIO;
1186 }
1187 pci_len0 = mem_len;
1188 } else {
1189 return -EIO;
1190 }
1191
f8468331 1192 dev_info(&pdev->dev, "%dKB memory map\n", (int)(mem_len >> 10));
7e2cf4fe 1193
15087c2b
SC		 1194 ahw->pci_base0 = mem_ptr0;
1195 ahw->pci_len0 = pci_len0;
1196 offset = QLCNIC_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(ahw->pci_func));
1197 qlcnic_get_ioaddr(ahw, offset);
af19b491
AKS		 1198
1199 return 0;
1200}
1201
60dcbcb0
MC		 1202static bool qlcnic_validate_subsystem_id(struct qlcnic_adapter *adapter,
1203 int index)
2343f06a
MC		 1204{
1205 struct pci_dev *pdev = adapter->pdev;
1206 unsigned short subsystem_vendor;
1207 bool ret = true;
1208
1209 subsystem_vendor = pdev->subsystem_vendor;
1210
1211 if (pdev->device == PCI_DEVICE_ID_QLOGIC_QLE824X ||
1212 pdev->device == PCI_DEVICE_ID_QLOGIC_QLE834X) {
1213 if (qlcnic_boards[index].sub_vendor == subsystem_vendor &&
1214 qlcnic_boards[index].sub_device == pdev->subsystem_device)
1215 ret = true;
1216 else
1217 ret = false;
1218 }
1219
1220 return ret;
1221}
1222
22999798 1223static void qlcnic_get_board_name(struct qlcnic_adapter *adapter, char *name)
af19b491
AKS		 1224{
1225 struct pci_dev *pdev = adapter->pdev;
1226 int i, found = 0;
1227
1228 for (i = 0; i < NUM_SUPPORTED_BOARDS; ++i) {
1229 if (qlcnic_boards[i].vendor == pdev->vendor &&
2343f06a
MC		 1230 qlcnic_boards[i].device == pdev->device &&
1231 qlcnic_validate_subsystem_id(adapter, i)) {
1232 found = 1;
1233 break;
af19b491 1234 }
af19b491
AKS		 1235 }
1236
1237 if (!found)
7f9a0c34 1238 sprintf(name, "%pM Gigabit Ethernet", adapter->mac_addr);
2343f06a
MC		 1239 else
1240 sprintf(name, "%pM: %s" , adapter->mac_addr,
1241 qlcnic_boards[i].short_name);
af19b491
AKS		 1242}
1243
1244static void
1245qlcnic_check_options(struct qlcnic_adapter *adapter)
1246{
a15ebd37 1247 int err;
031a4a26 1248 u32 fw_major, fw_minor, fw_build, prev_fw_version;
af19b491 1249 struct pci_dev *pdev = adapter->pdev;
a15ebd37
HM		 1250 struct qlcnic_hardware_context *ahw = adapter->ahw;
1251 struct qlcnic_fw_dump *fw_dump = &ahw->fw_dump;
031a4a26
SV		 1252
1253 prev_fw_version = adapter->fw_version;
af19b491 1254
a15ebd37
HM		 1255 fw_major = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MAJOR);
1256 fw_minor = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MINOR);
1257 fw_build = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_SUB);
af19b491
AKS		 1258
1259 adapter->fw_version = QLCNIC_VERSION_CODE(fw_major, fw_minor, fw_build);
1260
a15ebd37
HM		 1261 err = qlcnic_get_board_info(adapter);
1262 if (err) {
1263 dev_err(&pdev->dev, "Error getting board config info.\n");
1264 return;
1265 }
1266 if (ahw->op_mode != QLCNIC_NON_PRIV_FUNC) {
031a4a26
SV		 1267 if (fw_dump->tmpl_hdr == NULL ||
1268 adapter->fw_version > prev_fw_version) {
7061b2bd 1269 vfree(fw_dump->tmpl_hdr);
031a4a26
SV		 1270 if (!qlcnic_fw_cmd_get_minidump_temp(adapter))
1271 dev_info(&pdev->dev,
1272 "Supports FW dump capability\n");
1273 }
1274 }
1275
13159183
SC		 1276 dev_info(&pdev->dev, "Driver v%s, firmware v%d.%d.%d\n",
1277 QLCNIC_LINUX_VERSIONID, fw_major, fw_minor, fw_build);
1278
b1fc6d3c 1279 if (adapter->ahw->port_type == QLCNIC_XGBE) {
90d19005
SC		 1280 if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
1281 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_VF;
1282 adapter->max_rxd = MAX_RCV_DESCRIPTORS_VF;
1283 } else {
1284 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
1285 adapter->max_rxd = MAX_RCV_DESCRIPTORS_10G;
1286 }
1287
af19b491 1288 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
90d19005
SC		 1289 adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
1290
b1fc6d3c 1291 } else if (adapter->ahw->port_type == QLCNIC_GBE) {
af19b491
AKS		 1292 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
1293 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
90d19005
SC		 1294 adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
1295 adapter->max_rxd = MAX_RCV_DESCRIPTORS_1G;
af19b491
AKS		 1296 }
1297
099f7aa7 1298 adapter->ahw->msix_supported = !!qlcnic_use_msi_x;
af19b491
AKS		 1299
1300 adapter->num_txd = MAX_CMD_DESCRIPTORS;
1301
251b036a 1302 adapter->max_rds_rings = MAX_RDS_RINGS;
af19b491
AKS		 1303}
1304
174240a8
RB		 1305static int
1306qlcnic_initialize_nic(struct qlcnic_adapter *adapter)
1307{
174240a8 1308 struct qlcnic_info nic_info;
4bd8e738 1309 int err = 0;
174240a8 1310
bff57d8e 1311 memset(&nic_info, 0, sizeof(struct qlcnic_info));
b1fc6d3c 1312 err = qlcnic_get_nic_info(adapter, &nic_info, adapter->ahw->pci_func);
174240a8
RB		 1313 if (err)
1314 return err;
1315
79788450
SC		 1316 adapter->ahw->physical_port = (u8)nic_info.phys_port;
1317 adapter->ahw->switch_mode = nic_info.switch_mode;
1318 adapter->ahw->max_tx_ques = nic_info.max_tx_ques;
1319 adapter->ahw->max_rx_ques = nic_info.max_rx_ques;
1320 adapter->ahw->capabilities = nic_info.capabilities;
776e7bde
SS		 1321
1322 if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_MORE_CAPS) {
1323 u32 temp;
4bd8e738
HM		 1324 temp = QLCRD32(adapter, CRB_FW_CAPABILITIES_2, &err);
1325 if (err == -EIO)
1326 return err;
db131786 1327 adapter->ahw->extra_capability[0] = temp;
d6994ca7
SS		 1328 } else {
1329 adapter->ahw->extra_capability[0] = 0;
776e7bde 1330 }
d6994ca7 1331
79788450
SC		 1332 adapter->ahw->max_mac_filters = nic_info.max_mac_filters;
1333 adapter->ahw->max_mtu = nic_info.max_mtu;
174240a8 1334
34e8c406 1335 if (adapter->ahw->capabilities & BIT_6) {
174240a8 1336 adapter->flags |= QLCNIC_ESWITCH_ENABLED;
34e8c406
HM		 1337 adapter->ahw->nic_mode = QLCNIC_VNIC_MODE;
1338 adapter->max_tx_rings = QLCNIC_MAX_HW_VNIC_TX_RINGS;
1339 adapter->max_sds_rings = QLCNIC_MAX_VNIC_SDS_RINGS;
1340
1341 dev_info(&adapter->pdev->dev, "vNIC mode enabled.\n");
1342 } else {
1343 adapter->ahw->nic_mode = QLCNIC_DEFAULT_MODE;
1344 adapter->max_tx_rings = QLCNIC_MAX_HW_TX_RINGS;
f9566265 1345 adapter->max_sds_rings = QLCNIC_MAX_SDS_RINGS;
174240a8 1346 adapter->flags &= ~QLCNIC_ESWITCH_ENABLED;
34e8c406 1347 }
174240a8
RB		 1348
1349 return err;
1350}
1351
ec079a07
SC		 1352void qlcnic_set_vlan_config(struct qlcnic_adapter *adapter,
1353 struct qlcnic_esw_func_cfg *esw_cfg)
8cf61f89
AKS		 1354{
1355 if (esw_cfg->discard_tagged)
1356 adapter->flags &= ~QLCNIC_TAGGING_ENABLED;
1357 else
1358 adapter->flags |= QLCNIC_TAGGING_ENABLED;
1359
91b7282b
RB		 1360 if (esw_cfg->vlan_id) {
1361 adapter->rx_pvid = esw_cfg->vlan_id;
1362 adapter->tx_pvid = esw_cfg->vlan_id;
1363 } else {
1364 adapter->rx_pvid = 0;
1365 adapter->tx_pvid = 0;
1366 }
8cf61f89
AKS		 1367}
1368
8e586137 1369static int
80d5c368 1370qlcnic_vlan_rx_add(struct net_device *netdev, __be16 proto, u16 vid)
b9796a14
AC		 1371{
1372 struct qlcnic_adapter *adapter = netdev_priv(netdev);
91b7282b
RB		 1373 int err;
1374
1375 if (qlcnic_sriov_vf_check(adapter)) {
1376 err = qlcnic_sriov_cfg_vf_guest_vlan(adapter, vid, 1);
1377 if (err) {
1378 netdev_err(netdev,
1379 "Cannot add VLAN filter for VLAN id %d, err=%d",
1380 vid, err);
1381 return err;
1382 }
1383 }
1384
b9796a14 1385 set_bit(vid, adapter->vlans);
8e586137 1386 return 0;
b9796a14
AC		 1387}
1388
8e586137 1389static int
80d5c368 1390qlcnic_vlan_rx_del(struct net_device *netdev, __be16 proto, u16 vid)
b9796a14
AC		 1391{
1392 struct qlcnic_adapter *adapter = netdev_priv(netdev);
91b7282b
RB		 1393 int err;
1394
1395 if (qlcnic_sriov_vf_check(adapter)) {
1396 err = qlcnic_sriov_cfg_vf_guest_vlan(adapter, vid, 0);
1397 if (err) {
1398 netdev_err(netdev,
1399 "Cannot delete VLAN filter for VLAN id %d, err=%d",
1400 vid, err);
1401 return err;
1402 }
1403 }
b9796a14
AC		 1404
1405 qlcnic_restore_indev_addr(netdev, NETDEV_DOWN);
1406 clear_bit(vid, adapter->vlans);
8e586137 1407 return 0;
b9796a14
AC		 1408}
1409
ec079a07
SC		 1410void qlcnic_set_eswitch_port_features(struct qlcnic_adapter *adapter,
1411 struct qlcnic_esw_func_cfg *esw_cfg)
0325d69b 1412{
ee07c1a7
RB		 1413 adapter->flags &= ~(QLCNIC_MACSPOOF | QLCNIC_MAC_OVERRIDE_DISABLED |
1414 QLCNIC_PROMISC_DISABLED);
7613c87b
RB		 1415
1416 if (esw_cfg->mac_anti_spoof)
1417 adapter->flags |= QLCNIC_MACSPOOF;
fe4d434d 1418
7373373d
RB		 1419 if (!esw_cfg->mac_override)
1420 adapter->flags |= QLCNIC_MAC_OVERRIDE_DISABLED;
1421
ee07c1a7
RB		 1422 if (!esw_cfg->promisc_mode)
1423 adapter->flags |= QLCNIC_PROMISC_DISABLED;
0325d69b
RB		 1424}
1425
d71170fb 1426int qlcnic_set_eswitch_port_config(struct qlcnic_adapter *adapter)
0325d69b
RB		 1427{
1428 struct qlcnic_esw_func_cfg esw_cfg;
1429
1430 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
1431 return 0;
1432
b1fc6d3c 1433 esw_cfg.pci_func = adapter->ahw->pci_func;
0325d69b
RB		 1434 if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg))
1435 return -EIO;
8cf61f89 1436 qlcnic_set_vlan_config(adapter, &esw_cfg);
0325d69b 1437 qlcnic_set_eswitch_port_features(adapter, &esw_cfg);
147a9088 1438 qlcnic_set_netdev_features(adapter, &esw_cfg);
0325d69b
RB		 1439
1440 return 0;
1441}
1442
147a9088
SS		 1443void qlcnic_set_netdev_features(struct qlcnic_adapter *adapter,
1444 struct qlcnic_esw_func_cfg *esw_cfg)
0325d69b
RB		 1445{
1446 struct net_device *netdev = adapter->netdev;
13159183
SC		 1447
1448 if (qlcnic_83xx_check(adapter))
1449 return;
0325d69b 1450
147a9088
SS		 1451 adapter->offload_flags = esw_cfg->offload_flags;
1452 adapter->flags |= QLCNIC_APP_CHANGED_FLAGS;
1453 netdev_update_features(netdev);
1454 adapter->flags &= ~QLCNIC_APP_CHANGED_FLAGS;
0325d69b
RB		 1455}
1456
0866d96d
AC		 1457static int
1458qlcnic_check_eswitch_mode(struct qlcnic_adapter *adapter)
1459{
0866d96d
AC		 1460 u32 op_mode, priv_level;
1461 int err = 0;
1462
174240a8
RB		 1463 err = qlcnic_initialize_nic(adapter);
1464 if (err)
1465 return err;
1466
0866d96d
AC		 1467 if (adapter->flags & QLCNIC_ADAPTER_INITIALIZED)
1468 return 0;
1469
13159183 1470 op_mode = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
b1fc6d3c 1471 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
0866d96d
AC		 1472
1473 if (op_mode == QLC_DEV_DRV_DEFAULT)
1474 priv_level = QLCNIC_MGMT_FUNC;
1475 else
b1fc6d3c 1476 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
0866d96d 1477
174240a8 1478 if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
0866d96d 1479 if (priv_level == QLCNIC_MGMT_FUNC) {
79788450 1480 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
0866d96d
AC		 1481 err = qlcnic_init_pci_info(adapter);
1482 if (err)
1483 return err;
1484 /* Set privilege level for other functions */
1485 qlcnic_set_function_modes(adapter);
1486 dev_info(&adapter->pdev->dev,
1487 "HAL Version: %d, Management function\n",
79788450 1488 adapter->ahw->fw_hal_version);
0866d96d 1489 } else if (priv_level == QLCNIC_PRIV_FUNC) {
79788450 1490 adapter->ahw->op_mode = QLCNIC_PRIV_FUNC;
0866d96d
AC		 1491 dev_info(&adapter->pdev->dev,
1492 "HAL Version: %d, Privileged function\n",
79788450 1493 adapter->ahw->fw_hal_version);
0866d96d 1494 }
34e8c406
HM		 1495 } else {
1496 adapter->ahw->nic_mode = QLCNIC_DEFAULT_MODE;
174240a8 1497 }
0866d96d
AC		 1498
1499 adapter->flags |= QLCNIC_ADAPTER_INITIALIZED;
1500
1501 return err;
1502}
1503
d71170fb 1504int qlcnic_set_default_offload_settings(struct qlcnic_adapter *adapter)
0325d69b
RB		 1505{
1506 struct qlcnic_esw_func_cfg esw_cfg;
1507 struct qlcnic_npar_info *npar;
1508 u8 i;
1509
174240a8 1510 if (adapter->need_fw_reset)
0325d69b
RB		 1511 return 0;
1512
2f514c52 1513 for (i = 0; i < adapter->ahw->total_nic_func; i++) {
35dafcb0
SC		 1514 if (!adapter->npars[i].eswitch_status)
1515 continue;
1516
0325d69b 1517 memset(&esw_cfg, 0, sizeof(struct qlcnic_esw_func_cfg));
bff57d8e 1518 esw_cfg.pci_func = adapter->npars[i].pci_func;
7373373d 1519 esw_cfg.mac_override = BIT_0;
ee07c1a7 1520 esw_cfg.promisc_mode = BIT_0;
bff57d8e
SC		 1521 if (qlcnic_82xx_check(adapter)) {
1522 esw_cfg.offload_flags = BIT_0;
1523 if (QLCNIC_IS_TSO_CAPABLE(adapter))
1524 esw_cfg.offload_flags |= (BIT_1 | BIT_2);
1525 }
0325d69b
RB		 1526 if (qlcnic_config_switch_port(adapter, &esw_cfg))
1527 return -EIO;
1528 npar = &adapter->npars[i];
1529 npar->pvid = esw_cfg.vlan_id;
7373373d 1530 npar->mac_override = esw_cfg.mac_override;
0325d69b
RB		 1531 npar->mac_anti_spoof = esw_cfg.mac_anti_spoof;
1532 npar->discard_tagged = esw_cfg.discard_tagged;
1533 npar->promisc_mode = esw_cfg.promisc_mode;
1534 npar->offload_flags = esw_cfg.offload_flags;
1535 }
1536
1537 return 0;
1538}
1539
13159183 1540
4e8acb01
RB		 1541static int
1542qlcnic_reset_eswitch_config(struct qlcnic_adapter *adapter,
1543 struct qlcnic_npar_info *npar, int pci_func)
1544{
1545 struct qlcnic_esw_func_cfg esw_cfg;
1546 esw_cfg.op_mode = QLCNIC_PORT_DEFAULTS;
1547 esw_cfg.pci_func = pci_func;
1548 esw_cfg.vlan_id = npar->pvid;
7373373d 1549 esw_cfg.mac_override = npar->mac_override;
4e8acb01
RB		 1550 esw_cfg.discard_tagged = npar->discard_tagged;
1551 esw_cfg.mac_anti_spoof = npar->mac_anti_spoof;
1552 esw_cfg.offload_flags = npar->offload_flags;
1553 esw_cfg.promisc_mode = npar->promisc_mode;
1554 if (qlcnic_config_switch_port(adapter, &esw_cfg))
1555 return -EIO;
1556
1557 esw_cfg.op_mode = QLCNIC_ADD_VLAN;
1558 if (qlcnic_config_switch_port(adapter, &esw_cfg))
1559 return -EIO;
1560
1561 return 0;
1562}
1563
d71170fb 1564int qlcnic_reset_npar_config(struct qlcnic_adapter *adapter)
cea8975e 1565{
4e8acb01 1566 int i, err;
cea8975e
AC		 1567 struct qlcnic_npar_info *npar;
1568 struct qlcnic_info nic_info;
bff57d8e 1569 u8 pci_func;
cea8975e 1570
bff57d8e
SC		 1571 if (qlcnic_82xx_check(adapter))
1572 if (!adapter->need_fw_reset)
1573 return 0;
cea8975e 1574
4e8acb01 1575 /* Set the NPAR config data after FW reset */
2f514c52 1576 for (i = 0; i < adapter->ahw->total_nic_func; i++) {
4e8acb01 1577 npar = &adapter->npars[i];
bff57d8e 1578 pci_func = npar->pci_func;
35dafcb0
SC		 1579 if (!adapter->npars[i].eswitch_status)
1580 continue;
1581
bff57d8e 1582 memset(&nic_info, 0, sizeof(struct qlcnic_info));
13159183 1583 err = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
4e8acb01
RB		 1584 if (err)
1585 return err;
1586 nic_info.min_tx_bw = npar->min_bw;
1587 nic_info.max_tx_bw = npar->max_bw;
1588 err = qlcnic_set_nic_info(adapter, &nic_info);
1589 if (err)
1590 return err;
cea8975e 1591
4e8acb01
RB		 1592 if (npar->enable_pm) {
1593 err = qlcnic_config_port_mirroring(adapter,
bff57d8e
SC		 1594 npar->dest_npar, 1,
1595 pci_func);
4e8acb01
RB		 1596 if (err)
1597 return err;
cea8975e 1598 }
bff57d8e 1599 err = qlcnic_reset_eswitch_config(adapter, npar, pci_func);
4e8acb01
RB		 1600 if (err)
1601 return err;
cea8975e 1602 }
4e8acb01 1603 return 0;
cea8975e
AC		 1604}
1605
78f84e1a
AKS		 1606static int qlcnic_check_npar_opertional(struct qlcnic_adapter *adapter)
1607{
1608 u8 npar_opt_timeo = QLCNIC_DEV_NPAR_OPER_TIMEO;
1609 u32 npar_state;
1610
79788450 1611 if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
78f84e1a
AKS		 1612 return 0;
1613
a15ebd37
HM		 1614 npar_state = QLC_SHARED_REG_RD32(adapter,
1615 QLCNIC_CRB_DEV_NPAR_STATE);
78f84e1a
AKS		 1616 while (npar_state != QLCNIC_DEV_NPAR_OPER && --npar_opt_timeo) {
1617 msleep(1000);
a15ebd37
HM		 1618 npar_state = QLC_SHARED_REG_RD32(adapter,
1619 QLCNIC_CRB_DEV_NPAR_STATE);
78f84e1a
AKS		 1620 }
1621 if (!npar_opt_timeo) {
1622 dev_err(&adapter->pdev->dev,
8a168ca7 1623 "Waiting for NPAR state to operational timeout\n");
78f84e1a
AKS		 1624 return -EIO;
1625 }
1626 return 0;
1627}
1628
174240a8
RB		 1629static int
1630qlcnic_set_mgmt_operations(struct qlcnic_adapter *adapter)
1631{
1632 int err;
1633
1634 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
79788450 1635 adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
174240a8
RB		 1636 return 0;
1637
1638 err = qlcnic_set_default_offload_settings(adapter);
1639 if (err)
1640 return err;
1641
1642 err = qlcnic_reset_npar_config(adapter);
1643 if (err)
1644 return err;
1645
1646 qlcnic_dev_set_npar_ready(adapter);
1647
1648 return err;
1649}
1650
21041400 1651static int qlcnic_82xx_start_firmware(struct qlcnic_adapter *adapter)
af19b491 1652{
d4066833 1653 int err;
af19b491 1654
aa5e18c0
SC		 1655 err = qlcnic_can_start_firmware(adapter);
1656 if (err < 0)
1657 return err;
1658 else if (!err)
d4066833 1659 goto check_fw_status;
af19b491 1660
099f7aa7 1661 if (qlcnic_load_fw_file)
4d5bdb38 1662 qlcnic_request_firmware(adapter);
8f891387 1663 else {
8cfdce08
SC		 1664 err = qlcnic_check_flash_fw_ver(adapter);
1665 if (err)
8f891387 1666 goto err_out;
1667
79788450 1668 adapter->ahw->fw_type = QLCNIC_FLASH_ROMIMAGE;
8f891387 1669 }
af19b491
AKS		 1670
1671 err = qlcnic_need_fw_reset(adapter);
af19b491 1672 if (err == 0)
4e70812b 1673 goto check_fw_status;
af19b491 1674
d4066833
SC		 1675 err = qlcnic_pinit_from_rom(adapter);
1676 if (err)
1677 goto err_out;
af19b491
AKS		 1678
1679 err = qlcnic_load_firmware(adapter);
1680 if (err)
1681 goto err_out;
1682
1683 qlcnic_release_firmware(adapter);
d4066833 1684 QLCWR32(adapter, CRB_DRIVER_VERSION, QLCNIC_DRIVER_VERSION);
af19b491 1685
d4066833
SC		 1686check_fw_status:
1687 err = qlcnic_check_fw_status(adapter);
af19b491
AKS		 1688 if (err)
1689 goto err_out;
1690
a15ebd37 1691 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_READY);
6df900e9 1692 qlcnic_idc_debug_info(adapter, 1);
0866d96d
AC		 1693 err = qlcnic_check_eswitch_mode(adapter);
1694 if (err) {
1695 dev_err(&adapter->pdev->dev,
1696 "Memory allocation failed for eswitch\n");
1697 goto err_out;
1698 }
174240a8
RB		 1699 err = qlcnic_set_mgmt_operations(adapter);
1700 if (err)
1701 goto err_out;
1702
1703 qlcnic_check_options(adapter);
af19b491
AKS		 1704 adapter->need_fw_reset = 0;
1705
a7fc948f
AKS		 1706 qlcnic_release_firmware(adapter);
1707 return 0;
af19b491
AKS		 1708
1709err_out:
a15ebd37 1710 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_FAILED);
a7fc948f 1711 dev_err(&adapter->pdev->dev, "Device state set to failed\n");
0866d96d 1712
af19b491
AKS		 1713 qlcnic_release_firmware(adapter);
1714 return err;
1715}
1716
1717static int
1718qlcnic_request_irq(struct qlcnic_adapter *adapter)
1719{
1720 irq_handler_t handler;
1721 struct qlcnic_host_sds_ring *sds_ring;
13159183 1722 struct qlcnic_host_tx_ring *tx_ring;
ddb2e174 1723 int err, ring, num_sds_rings;
af19b491
AKS		 1724
1725 unsigned long flags = 0;
1726 struct net_device *netdev = adapter->netdev;
b1fc6d3c 1727 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
af19b491 1728
79788450 1729 if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
13159183
SC		 1730 if (qlcnic_82xx_check(adapter))
1731 handler = qlcnic_tmp_intr;
c2534384
MC		 1732 else
1733 handler = qlcnic_83xx_tmp_intr;
7eb9855d
AKS		 1734 if (!QLCNIC_IS_MSI_FAMILY(adapter))
1735 flags |= IRQF_SHARED;
1736
1737 } else {
1738 if (adapter->flags & QLCNIC_MSIX_ENABLED)
1739 handler = qlcnic_msix_intr;
1740 else if (adapter->flags & QLCNIC_MSI_ENABLED)
1741 handler = qlcnic_msi_intr;
1742 else {
1743 flags |= IRQF_SHARED;
ac166700
HM		 1744 if (qlcnic_82xx_check(adapter))
1745 handler = qlcnic_intr;
1746 else
1747 handler = qlcnic_83xx_intr;
7eb9855d 1748 }
af19b491
AKS		 1749 }
1750 adapter->irq = netdev->irq;
1751
13159183 1752 if (adapter->ahw->diag_test != QLCNIC_LOOPBACK_TEST) {
ac166700
HM		 1753 if (qlcnic_82xx_check(adapter) ||
1754 (qlcnic_83xx_check(adapter) &&
1755 (adapter->flags & QLCNIC_MSIX_ENABLED))) {
34e8c406 1756 num_sds_rings = adapter->drv_sds_rings;
ddb2e174 1757 for (ring = 0; ring < num_sds_rings; ring++) {
ac166700 1758 sds_ring = &recv_ctx->sds_rings[ring];
ddb2e174 1759 if (qlcnic_82xx_check(adapter) &&
012ec812 1760 !qlcnic_check_multi_tx(adapter) &&
aa2a8034
HM		 1761 (ring == (num_sds_rings - 1))) {
1762 if (!(adapter->flags &
1763 QLCNIC_MSIX_ENABLED))
1764 snprintf(sds_ring->name,
1765 sizeof(sds_ring->name),
1766 "qlcnic");
1767 else
1768 snprintf(sds_ring->name,
1769 sizeof(sds_ring->name),
1770 "%s-tx-0-rx-%d",
1771 netdev->name, ring);
1772 } else {
ddb2e174
HM		 1773 snprintf(sds_ring->name,
1774 sizeof(sds_ring->name),
aa2a8034 1775 "%s-rx-%d",
ddb2e174 1776 netdev->name, ring);
aa2a8034 1777 }
ac166700
HM		 1778 err = request_irq(sds_ring->irq, handler, flags,
1779 sds_ring->name, sds_ring);
1780 if (err)
1781 return err;
1782 }
13159183 1783 }
012ec812
HM		 1784 if ((qlcnic_82xx_check(adapter) &&
1785 qlcnic_check_multi_tx(adapter)) ||
1786 (qlcnic_83xx_check(adapter) &&
1787 (adapter->flags & QLCNIC_MSIX_ENABLED) &&
1788 !(adapter->flags & QLCNIC_TX_INTR_SHARED))) {
13159183 1789 handler = qlcnic_msix_tx_intr;
34e8c406 1790 for (ring = 0; ring < adapter->drv_tx_rings;
13159183
SC		 1791 ring++) {
1792 tx_ring = &adapter->tx_ring[ring];
ddb2e174 1793 snprintf(tx_ring->name, sizeof(tx_ring->name),
aa2a8034 1794 "%s-tx-%d", netdev->name, ring);
13159183
SC		 1795 err = request_irq(tx_ring->irq, handler, flags,
1796 tx_ring->name, tx_ring);
1797 if (err)
1798 return err;
1799 }
1800 }
af19b491 1801 }
af19b491
AKS		 1802 return 0;
1803}
1804
1805static void
1806qlcnic_free_irq(struct qlcnic_adapter *adapter)
1807{
1808 int ring;
1809 struct qlcnic_host_sds_ring *sds_ring;
13159183 1810 struct qlcnic_host_tx_ring *tx_ring;
af19b491 1811
b1fc6d3c 1812 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
af19b491 1813
13159183 1814 if (adapter->ahw->diag_test != QLCNIC_LOOPBACK_TEST) {
ac166700
HM		 1815 if (qlcnic_82xx_check(adapter) ||
1816 (qlcnic_83xx_check(adapter) &&
1817 (adapter->flags & QLCNIC_MSIX_ENABLED))) {
34e8c406 1818 for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
ac166700
HM		 1819 sds_ring = &recv_ctx->sds_rings[ring];
1820 free_irq(sds_ring->irq, sds_ring);
1821 }
13159183 1822 }
012ec812
HM		 1823 if ((qlcnic_83xx_check(adapter) &&
1824 !(adapter->flags & QLCNIC_TX_INTR_SHARED)) ||
1825 (qlcnic_82xx_check(adapter) &&
1826 qlcnic_check_multi_tx(adapter))) {
34e8c406 1827 for (ring = 0; ring < adapter->drv_tx_rings;
13159183
SC		 1828 ring++) {
1829 tx_ring = &adapter->tx_ring[ring];
1830 if (tx_ring->irq)
1831 free_irq(tx_ring->irq, tx_ring);
1832 }
1833 }
af19b491
AKS		 1834 }
1835}
1836
99e85879
SS		 1837static void qlcnic_get_lro_mss_capability(struct qlcnic_adapter *adapter)
1838{
1839 u32 capab = 0;
1840
1841 if (qlcnic_82xx_check(adapter)) {
db131786 1842 if (adapter->ahw->extra_capability[0] &
99e85879
SS		 1843 QLCNIC_FW_CAPABILITY_2_LRO_MAX_TCP_SEG)
1844 adapter->flags |= QLCNIC_FW_LRO_MSS_CAP;
1845 } else {
1846 capab = adapter->ahw->capabilities;
1847 if (QLC_83XX_GET_FW_LRO_MSS_CAPABILITY(capab))
1848 adapter->flags |= QLCNIC_FW_LRO_MSS_CAP;
1849 }
1850}
1851
a514722a
HM		 1852static int qlcnic_config_def_intr_coalesce(struct qlcnic_adapter *adapter)
1853{
1854 struct qlcnic_hardware_context *ahw = adapter->ahw;
1855 int err;
1856
1857 /* Initialize interrupt coalesce parameters */
1858 ahw->coal.flag = QLCNIC_INTR_DEFAULT;
1859
1860 if (qlcnic_83xx_check(adapter)) {
1861 ahw->coal.type = QLCNIC_INTR_COAL_TYPE_RX_TX;
1862 ahw->coal.tx_time_us = QLCNIC_DEF_INTR_COALESCE_TX_TIME_US;
1863 ahw->coal.tx_packets = QLCNIC_DEF_INTR_COALESCE_TX_PACKETS;
1864 ahw->coal.rx_time_us = QLCNIC_DEF_INTR_COALESCE_RX_TIME_US;
1865 ahw->coal.rx_packets = QLCNIC_DEF_INTR_COALESCE_RX_PACKETS;
1866
1867 err = qlcnic_83xx_set_rx_tx_intr_coal(adapter);
1868 } else {
1869 ahw->coal.type = QLCNIC_INTR_COAL_TYPE_RX;
1870 ahw->coal.rx_time_us = QLCNIC_DEF_INTR_COALESCE_RX_TIME_US;
1871 ahw->coal.rx_packets = QLCNIC_DEF_INTR_COALESCE_RX_PACKETS;
1872
1873 err = qlcnic_82xx_set_rx_coalesce(adapter);
1874 }
1875
1876 return err;
1877}
1878
319ecf12 1879int __qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
af19b491 1880{
8a15ad1f
AKS		 1881 int ring;
1882 struct qlcnic_host_rds_ring *rds_ring;
1883
af19b491
AKS		 1884 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1885 return -EIO;
1886
8a15ad1f
AKS		 1887 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
1888 return 0;
012ec812 1889
0325d69b
RB		 1890 if (qlcnic_set_eswitch_port_config(adapter))
1891 return -EIO;
012ec812 1892
99e85879 1893 qlcnic_get_lro_mss_capability(adapter);
cae82d49 1894
8a15ad1f
AKS		 1895 if (qlcnic_fw_create_ctx(adapter))
1896 return -EIO;
1897
1898 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
b1fc6d3c 1899 rds_ring = &adapter->recv_ctx->rds_rings[ring];
4be41e92 1900 qlcnic_post_rx_buffers(adapter, rds_ring, ring);
8a15ad1f
AKS		 1901 }
1902
af19b491
AKS		 1903 qlcnic_set_multi(netdev);
1904 qlcnic_fw_cmd_set_mtu(adapter, netdev->mtu);
1905
b1fc6d3c 1906 adapter->ahw->linkup = 0;
af19b491 1907
34e8c406 1908 if (adapter->drv_sds_rings > 1)
af19b491
AKS		 1909 qlcnic_config_rss(adapter, 1);
1910
a514722a 1911 qlcnic_config_def_intr_coalesce(adapter);
af19b491 1912
24763d80 1913 if (netdev->features & NETIF_F_LRO)
af19b491
AKS		 1914 qlcnic_config_hw_lro(adapter, QLCNIC_LRO_ENABLED);
1915
cfacb172 1916 set_bit(__QLCNIC_DEV_UP, &adapter->state);
af19b491
AKS		 1917 qlcnic_napi_enable(adapter);
1918
1919 qlcnic_linkevent_request(adapter, 1);
1920
79788450 1921 adapter->ahw->reset_context = 0;
060d0564 1922 netif_tx_start_all_queues(netdev);
af19b491
AKS		 1923 return 0;
1924}
1925
629263ac 1926int qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
af19b491
AKS		 1927{
1928 int err = 0;
1929
1930 rtnl_lock();
1931 if (netif_running(netdev))
1932 err = __qlcnic_up(adapter, netdev);
1933 rtnl_unlock();
1934
1935 return err;
1936}
1937
319ecf12 1938void __qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
af19b491 1939{
012ec812
HM		 1940 int ring;
1941
af19b491
AKS		 1942 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1943 return;
1944
1945 if (!test_and_clear_bit(__QLCNIC_DEV_UP, &adapter->state))
1946 return;
1947
1948 smp_mb();
af19b491 1949 netif_carrier_off(netdev);
0a46bac0 1950 adapter->ahw->linkup = 0;
af19b491
AKS		 1951 netif_tx_disable(netdev);
1952
1953 qlcnic_free_mac_list(adapter);
1954
b5e5492c
AKS		 1955 if (adapter->fhash.fnum)
1956 qlcnic_delete_lb_filters(adapter);
1957
af19b491 1958 qlcnic_nic_set_promisc(adapter, QLCNIC_NIU_NON_PROMISC_MODE);
74b7ba1a
RB		 1959 if (qlcnic_sriov_vf_check(adapter))
1960 qlcnic_sriov_cleanup_async_list(&adapter->ahw->sriov->bc);
af19b491
AKS		 1961
1962 qlcnic_napi_disable(adapter);
1963
8a15ad1f 1964 qlcnic_fw_destroy_ctx(adapter);
cae82d49 1965 adapter->flags &= ~QLCNIC_FW_LRO_MSS_CAP;
8a15ad1f
AKS		 1966
1967 qlcnic_reset_rx_buffers_list(adapter);
012ec812 1968
34e8c406 1969 for (ring = 0; ring < adapter->drv_tx_rings; ring++)
012ec812 1970 qlcnic_release_tx_buffers(adapter, &adapter->tx_ring[ring]);
af19b491
AKS		 1971}
1972
1973/* Usage: During suspend and firmware recovery module */
1974
629263ac 1975void qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
af19b491
AKS		 1976{
1977 rtnl_lock();
1978 if (netif_running(netdev))
1979 __qlcnic_down(adapter, netdev);
1980 rtnl_unlock();
1981
1982}
1983
319ecf12 1984int
af19b491
AKS		 1985qlcnic_attach(struct qlcnic_adapter *adapter)
1986{
1987 struct net_device *netdev = adapter->netdev;
1988 struct pci_dev *pdev = adapter->pdev;
8a15ad1f 1989 int err;
af19b491
AKS		 1990
1991 if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC)
1992 return 0;
1993
af19b491
AKS		 1994 err = qlcnic_napi_add(adapter, netdev);
1995 if (err)
1996 return err;
1997
1998 err = qlcnic_alloc_sw_resources(adapter);
1999 if (err) {
2000 dev_err(&pdev->dev, "Error in setting sw resources\n");
8a15ad1f 2001 goto err_out_napi_del;
af19b491
AKS		 2002 }
2003
2004 err = qlcnic_alloc_hw_resources(adapter);
2005 if (err) {
2006 dev_err(&pdev->dev, "Error in setting hw resources\n");
2007 goto err_out_free_sw;
2008 }
2009
af19b491
AKS		 2010 err = qlcnic_request_irq(adapter);
2011 if (err) {
2012 dev_err(&pdev->dev, "failed to setup interrupt\n");
8a15ad1f 2013 goto err_out_free_hw;
af19b491
AKS		 2014 }
2015
af19b491
AKS		 2016 qlcnic_create_sysfs_entries(adapter);
2017
7f1f6056 2018#ifdef CONFIG_QLCNIC_VXLAN
2b3d7b75
SS		 2019 if (qlcnic_encap_rx_offload(adapter))
2020 vxlan_get_rx_port(netdev);
7f1f6056 2021#endif
2b3d7b75 2022
af19b491
AKS		 2023 adapter->is_up = QLCNIC_ADAPTER_UP_MAGIC;
2024 return 0;
2025
8a15ad1f 2026err_out_free_hw:
af19b491
AKS		 2027 qlcnic_free_hw_resources(adapter);
2028err_out_free_sw:
2029 qlcnic_free_sw_resources(adapter);
8a15ad1f
AKS		 2030err_out_napi_del:
2031 qlcnic_napi_del(adapter);
af19b491
AKS		 2032 return err;
2033}
2034
319ecf12 2035void qlcnic_detach(struct qlcnic_adapter *adapter)
af19b491
AKS		 2036{
2037 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
2038 return;
2039
2040 qlcnic_remove_sysfs_entries(adapter);
2041
2042 qlcnic_free_hw_resources(adapter);
2043 qlcnic_release_rx_buffers(adapter);
2044 qlcnic_free_irq(adapter);
2045 qlcnic_napi_del(adapter);
2046 qlcnic_free_sw_resources(adapter);
2047
2048 adapter->is_up = 0;
2049}
2050
34e8c406 2051void qlcnic_diag_free_res(struct net_device *netdev, int drv_sds_rings)
7eb9855d
AKS		 2052{
2053 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2054 struct qlcnic_host_sds_ring *sds_ring;
34e8c406 2055 int drv_tx_rings = adapter->drv_tx_rings;
7eb9855d
AKS		 2056 int ring;
2057
78ad3892 2058 clear_bit(__QLCNIC_DEV_UP, &adapter->state);
79788450 2059 if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
34e8c406 2060 for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
b1fc6d3c 2061 sds_ring = &adapter->recv_ctx->sds_rings[ring];
2cc5752e 2062 qlcnic_disable_sds_intr(adapter, sds_ring);
cdaff185 2063 }
7eb9855d
AKS		 2064 }
2065
8a15ad1f
AKS		 2066 qlcnic_fw_destroy_ctx(adapter);
2067
7eb9855d
AKS		 2068 qlcnic_detach(adapter);
2069
79788450 2070 adapter->ahw->diag_test = 0;
34e8c406
HM		 2071 adapter->drv_sds_rings = drv_sds_rings;
2072 adapter->drv_tx_rings = drv_tx_rings;
7eb9855d
AKS		 2073
2074 if (qlcnic_attach(adapter))
34ce3626 2075 goto out;
7eb9855d
AKS		 2076
2077 if (netif_running(netdev))
2078 __qlcnic_up(adapter, netdev);
34ce3626 2079out:
7eb9855d
AKS		 2080 netif_device_attach(netdev);
2081}
2082
b1fc6d3c
AC		 2083static int qlcnic_alloc_adapter_resources(struct qlcnic_adapter *adapter)
2084{
868e9144 2085 struct qlcnic_hardware_context *ahw = adapter->ahw;
b1fc6d3c 2086 int err = 0;
be273dc1 2087
b1fc6d3c
AC		 2088 adapter->recv_ctx = kzalloc(sizeof(struct qlcnic_recv_context),
2089 GFP_KERNEL);
2090 if (!adapter->recv_ctx) {
b1fc6d3c 2091 err = -ENOMEM;
8816d009 2092 goto err_out;
b1fc6d3c 2093 }
a514722a 2094
868e9144
SC		 2095 if (qlcnic_83xx_check(adapter)) {
2096 ahw->coal.type = QLCNIC_INTR_COAL_TYPE_RX_TX;
2097 ahw->coal.tx_time_us = QLCNIC_DEF_INTR_COALESCE_TX_TIME_US;
2098 ahw->coal.tx_packets = QLCNIC_DEF_INTR_COALESCE_TX_PACKETS;
2099 ahw->coal.rx_time_us = QLCNIC_DEF_INTR_COALESCE_RX_TIME_US;
2100 ahw->coal.rx_packets = QLCNIC_DEF_INTR_COALESCE_RX_PACKETS;
2101 } else {
2102 ahw->coal.type = QLCNIC_INTR_COAL_TYPE_RX;
2103 ahw->coal.rx_time_us = QLCNIC_DEF_INTR_COALESCE_RX_TIME_US;
2104 ahw->coal.rx_packets = QLCNIC_DEF_INTR_COALESCE_RX_PACKETS;
2105 }
2106
4be41e92
SC		 2107 /* clear stats */
2108 memset(&adapter->stats, 0, sizeof(adapter->stats));
b1fc6d3c
AC		 2109err_out:
2110 return err;
2111}
2112
2113static void qlcnic_free_adapter_resources(struct qlcnic_adapter *adapter)
2114{
4da005cf
SS		 2115 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
2116
b1fc6d3c
AC		 2117 kfree(adapter->recv_ctx);
2118 adapter->recv_ctx = NULL;
2119
4da005cf
SS		 2120 if (fw_dump->tmpl_hdr) {
2121 vfree(fw_dump->tmpl_hdr);
2122 fw_dump->tmpl_hdr = NULL;
2123 }
2124
2125 if (fw_dump->dma_buffer) {
2126 dma_free_coherent(&adapter->pdev->dev, QLC_PEX_DMA_READ_SIZE,
2127 fw_dump->dma_buffer, fw_dump->phys_addr);
2128 fw_dump->dma_buffer = NULL;
18f2f616 2129 }
4be41e92 2130
81d0aeb0 2131 kfree(adapter->ahw->reset.buff);
4be41e92 2132 adapter->ahw->fw_dump.tmpl_hdr = NULL;
b1fc6d3c
AC		 2133}
2134
7eb9855d
AKS		 2135int qlcnic_diag_alloc_res(struct net_device *netdev, int test)
2136{
2137 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2138 struct qlcnic_host_sds_ring *sds_ring;
8a15ad1f 2139 struct qlcnic_host_rds_ring *rds_ring;
7eb9855d
AKS		 2140 int ring;
2141 int ret;
2142
2143 netif_device_detach(netdev);
2144
2145 if (netif_running(netdev))
2146 __qlcnic_down(adapter, netdev);
2147
2148 qlcnic_detach(adapter);
2149
34e8c406 2150 adapter->drv_sds_rings = QLCNIC_SINGLE_RING;
79788450 2151 adapter->ahw->diag_test = test;
4be41e92 2152 adapter->ahw->linkup = 0;
7eb9855d
AKS		 2153
2154 ret = qlcnic_attach(adapter);
34ce3626
AKS		 2155 if (ret) {
2156 netif_device_attach(netdev);
7eb9855d 2157 return ret;
34ce3626 2158 }
7eb9855d 2159
8a15ad1f
AKS		 2160 ret = qlcnic_fw_create_ctx(adapter);
2161 if (ret) {
2162 qlcnic_detach(adapter);
57e46248 2163 netif_device_attach(netdev);
8a15ad1f
AKS		 2164 return ret;
2165 }
2166
2167 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
b1fc6d3c 2168 rds_ring = &adapter->recv_ctx->rds_rings[ring];
4be41e92 2169 qlcnic_post_rx_buffers(adapter, rds_ring, ring);
8a15ad1f
AKS		 2170 }
2171
79788450 2172 if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
34e8c406 2173 for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
b1fc6d3c 2174 sds_ring = &adapter->recv_ctx->sds_rings[ring];
2cc5752e 2175 qlcnic_enable_sds_intr(adapter, sds_ring);
cdaff185 2176 }
7eb9855d 2177 }
22c8c934 2178
79788450 2179 if (adapter->ahw->diag_test == QLCNIC_LOOPBACK_TEST) {
22c8c934
SC		 2180 adapter->ahw->loopback_state = 0;
2181 qlcnic_linkevent_request(adapter, 1);
2182 }
2183
78ad3892 2184 set_bit(__QLCNIC_DEV_UP, &adapter->state);
7eb9855d
AKS		 2185
2186 return 0;
2187}
2188
68bf1c68
AKS		 2189/* Reset context in hardware only */
2190static int
2191qlcnic_reset_hw_context(struct qlcnic_adapter *adapter)
2192{
2193 struct net_device *netdev = adapter->netdev;
2194
2195 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
2196 return -EBUSY;
2197
2198 netif_device_detach(netdev);
2199
2200 qlcnic_down(adapter, netdev);
2201
2202 qlcnic_up(adapter, netdev);
2203
2204 netif_device_attach(netdev);
2205
2206 clear_bit(__QLCNIC_RESETTING, &adapter->state);
95b3890a 2207 netdev_info(adapter->netdev, "%s: soft reset complete\n", __func__);
68bf1c68
AKS		 2208 return 0;
2209}
2210
af19b491
AKS		 2211int
2212qlcnic_reset_context(struct qlcnic_adapter *adapter)
2213{
2214 int err = 0;
2215 struct net_device *netdev = adapter->netdev;
2216
2217 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
2218 return -EBUSY;
2219
2220 if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC) {
2221
2222 netif_device_detach(netdev);
2223
2224 if (netif_running(netdev))
2225 __qlcnic_down(adapter, netdev);
2226
2227 qlcnic_detach(adapter);
2228
2229 if (netif_running(netdev)) {
2230 err = qlcnic_attach(adapter);
1d5c88e3 2231 if (!err) {
34ce3626 2232 __qlcnic_up(adapter, netdev);
1d5c88e3
AC		 2233 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
2234 }
af19b491
AKS		 2235 }
2236
2237 netif_device_attach(netdev);
2238 }
2239
af19b491
AKS		 2240 clear_bit(__QLCNIC_RESETTING, &adapter->state);
2241 return err;
2242}
2243
21041400 2244static void qlcnic_82xx_set_mac_filter_count(struct qlcnic_adapter *adapter)
52e493d0
JK		 2245{
2246 struct qlcnic_hardware_context *ahw = adapter->ahw;
2f514c52 2247 u16 act_pci_fn = ahw->total_nic_func;
52e493d0
JK		 2248 u16 count;
2249
2250 ahw->max_mc_count = QLCNIC_MAX_MC_COUNT;
2251 if (act_pci_fn <= 2)
2252 count = (QLCNIC_MAX_UC_COUNT - QLCNIC_MAX_MC_COUNT) /
2253 act_pci_fn;
2254 else
2255 count = (QLCNIC_LB_MAX_FILTERS - QLCNIC_MAX_MC_COUNT) /
2256 act_pci_fn;
2257 ahw->max_uc_count = count;
2258}
2259
84d7ad2c
SS		 2260static int qlcnic_set_real_num_queues(struct qlcnic_adapter *adapter,
2261 u8 tx_queues, u8 rx_queues)
2262{
2263 struct net_device *netdev = adapter->netdev;
2264 int err = 0;
2265
2266 if (tx_queues) {
2267 err = netif_set_real_num_tx_queues(netdev, tx_queues);
2268 if (err) {
2269 netdev_err(netdev, "failed to set %d Tx queues\n",
2270 tx_queues);
2271 return err;
2272 }
2273 }
2274
2275 if (rx_queues) {
2276 err = netif_set_real_num_rx_queues(netdev, rx_queues);
2277 if (err)
2278 netdev_err(netdev, "failed to set %d Rx queues\n",
2279 rx_queues);
2280 }
2281
2282 return err;
2283}
2284
f8468331 2285int
5ad6ff9d
SC		 2286qlcnic_setup_netdev(struct qlcnic_adapter *adapter, struct net_device *netdev,
2287 int pci_using_dac)
af19b491
AKS		 2288{
2289 int err;
2290 struct pci_dev *pdev = adapter->pdev;
2291
13159183 2292 adapter->rx_csum = 1;
79788450 2293 adapter->ahw->mc_enabled = 0;
52e493d0 2294 qlcnic_set_mac_filter_count(adapter);
af19b491
AKS		 2295
2296 netdev->netdev_ops = &qlcnic_netdev_ops;
13159183 2297 netdev->watchdog_timeo = QLCNIC_WATCHDOG_TIMEOUTVALUE * HZ;
af19b491
AKS		 2298
2299 qlcnic_change_mtu(netdev, netdev->mtu);
2300
7ad24ea4
WK		 2301 netdev->ethtool_ops = (qlcnic_sriov_vf_check(adapter)) ?
2302 &qlcnic_sriov_vf_ethtool_ops : &qlcnic_ethtool_ops;
af19b491 2303
7e38d04b 2304 netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_RXCSUM |
13159183 2305 NETIF_F_IPV6_CSUM | NETIF_F_GRO |
f646968f 2306 NETIF_F_HW_VLAN_CTAG_RX);
13159183
SC		 2307 netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
2308 NETIF_F_IPV6_CSUM);
ac8d0c4f 2309
13159183
SC		 2310 if (QLCNIC_IS_TSO_CAPABLE(adapter)) {
2311 netdev->features |= (NETIF_F_TSO | NETIF_F_TSO6);
2312 netdev->vlan_features |= (NETIF_F_TSO | NETIF_F_TSO6);
2313 }
af19b491 2314
13159183
SC		 2315 if (pci_using_dac) {
2316 netdev->features |= NETIF_F_HIGHDMA;
2317 netdev->vlan_features |= NETIF_F_HIGHDMA;
2318 }
af19b491 2319
13159183 2320 if (qlcnic_vlan_tx_check(adapter))
f646968f 2321 netdev->features |= (NETIF_F_HW_VLAN_CTAG_TX);
135d84a9 2322
91b7282b
RB		 2323 if (qlcnic_sriov_vf_check(adapter))
2324 netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
2325
13159183
SC		 2326 if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
2327 netdev->features |= NETIF_F_LRO;
135d84a9 2328
381709de
SS		 2329 if (qlcnic_encap_tx_offload(adapter)) {
2330 netdev->features |= NETIF_F_GSO_UDP_TUNNEL;
2331
2332 /* encapsulation Tx offload supported by Adapter */
2333 netdev->hw_enc_features = NETIF_F_IP_CSUM |
2334 NETIF_F_GSO_UDP_TUNNEL |
2335 NETIF_F_TSO |
2336 NETIF_F_TSO6;
2337 }
2338
2b3d7b75
SS		 2339 if (qlcnic_encap_rx_offload(adapter))
2340 netdev->hw_enc_features |= NETIF_F_RXCSUM;
2341
7e38d04b 2342 netdev->hw_features = netdev->features;
52e493d0 2343 netdev->priv_flags |= IFF_UNICAST_FLT;
af19b491
AKS		 2344 netdev->irq = adapter->msix_entries[0].vector;
2345
84d7ad2c
SS		 2346 err = qlcnic_set_real_num_queues(adapter, adapter->drv_tx_rings,
2347 adapter->drv_sds_rings);
aa4a1f7d
HM		 2348 if (err)
2349 return err;
012ec812 2350
cd1560e2
RB		 2351 qlcnic_dcb_init_dcbnl_ops(adapter->dcb);
2352
af19b491
AKS		 2353 err = register_netdev(netdev);
2354 if (err) {
2355 dev_err(&pdev->dev, "failed to register net device\n");
2356 return err;
2357 }
2358
2359 return 0;
2360}
2361
5ad6ff9d 2362static int qlcnic_set_dma_mask(struct pci_dev *pdev, int *pci_using_dac)
1bb09fb9
AKS		 2363{
2364 if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) &&
2365 !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
2366 *pci_using_dac = 1;
2367 else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) &&
2368 !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))
2369 *pci_using_dac = 0;
2370 else {
2371 dev_err(&pdev->dev, "Unable to set DMA mask, aborting\n");
2372 return -EIO;
2373 }
2374
2375 return 0;
2376}
2377
4be41e92
SC		 2378void qlcnic_free_tx_rings(struct qlcnic_adapter *adapter)
2379{
2380 int ring;
2381 struct qlcnic_host_tx_ring *tx_ring;
2382
34e8c406 2383 for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
4be41e92 2384 tx_ring = &adapter->tx_ring[ring];
7061b2bd 2385 if (tx_ring) {
4be41e92
SC		 2386 vfree(tx_ring->cmd_buf_arr);
2387 tx_ring->cmd_buf_arr = NULL;
2388 }
2389 }
7061b2bd 2390 kfree(adapter->tx_ring);
4be41e92
SC		 2391}
2392
2393int qlcnic_alloc_tx_rings(struct qlcnic_adapter *adapter,
2394 struct net_device *netdev)
2395{
b2adaca9 2396 int ring, vector, index;
4be41e92
SC		 2397 struct qlcnic_host_tx_ring *tx_ring;
2398 struct qlcnic_cmd_buffer *cmd_buf_arr;
2399
34e8c406 2400 tx_ring = kcalloc(adapter->drv_tx_rings,
b2adaca9
JP		 2401 sizeof(struct qlcnic_host_tx_ring), GFP_KERNEL);
2402 if (tx_ring == NULL)
4be41e92 2403 return -ENOMEM;
b2adaca9 2404
4be41e92
SC		 2405 adapter->tx_ring = tx_ring;
2406
34e8c406 2407 for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
4be41e92
SC		 2408 tx_ring = &adapter->tx_ring[ring];
2409 tx_ring->num_desc = adapter->num_txd;
2410 tx_ring->txq = netdev_get_tx_queue(netdev, ring);
2411 cmd_buf_arr = vzalloc(TX_BUFF_RINGSIZE(tx_ring));
2412 if (cmd_buf_arr == NULL) {
4be41e92
SC		 2413 qlcnic_free_tx_rings(adapter);
2414 return -ENOMEM;
2415 }
4be41e92 2416 tx_ring->cmd_buf_arr = cmd_buf_arr;
a02bdd42 2417 spin_lock_init(&tx_ring->tx_clean_lock);
4be41e92
SC		 2418 }
2419
012ec812
HM		 2420 if (qlcnic_83xx_check(adapter) ||
2421 (qlcnic_82xx_check(adapter) && qlcnic_check_multi_tx(adapter))) {
34e8c406 2422 for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
4be41e92
SC		 2423 tx_ring = &adapter->tx_ring[ring];
2424 tx_ring->adapter = adapter;
2425 if (adapter->flags & QLCNIC_MSIX_ENABLED) {
34e8c406 2426 index = adapter->drv_sds_rings + ring;
4be41e92
SC		 2427 vector = adapter->msix_entries[index].vector;
2428 tx_ring->irq = vector;
2429 }
2430 }
2431 }
012ec812 2432
4be41e92
SC		 2433 return 0;
2434}
2435
8af3f33d
PP		 2436void qlcnic_set_drv_version(struct qlcnic_adapter *adapter)
2437{
2438 struct qlcnic_hardware_context *ahw = adapter->ahw;
2439 u32 fw_cmd = 0;
2440
2441 if (qlcnic_82xx_check(adapter))
2442 fw_cmd = QLCNIC_CMD_82XX_SET_DRV_VER;
2443 else if (qlcnic_83xx_check(adapter))
2444 fw_cmd = QLCNIC_CMD_83XX_SET_DRV_VER;
2445
d6994ca7 2446 if (ahw->extra_capability[0] & QLCNIC_FW_CAPABILITY_SET_DRV_VER)
8af3f33d
PP		 2447 qlcnic_fw_cmd_set_drv_version(adapter, fw_cmd);
2448}
2449
2c97e9e2
SC		 2450/* Reset firmware API lock */
2451static void qlcnic_reset_api_lock(struct qlcnic_adapter *adapter)
2452{
2453 qlcnic_api_lock(adapter);
2454 qlcnic_api_unlock(adapter);
2455}
2456
2457
6bb58bb0 2458static int
af19b491
AKS		 2459qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
2460{
2461 struct net_device *netdev = NULL;
2462 struct qlcnic_adapter *adapter = NULL;
7e2cf4fe 2463 struct qlcnic_hardware_context *ahw;
5ad6ff9d 2464 int err, pci_using_dac = -1;
7bc48646 2465 char board_name[QLCNIC_MAX_BOARD_NAME_LEN + 19]; /* MAC + ": " + name */
af19b491
AKS		 2466
2467 err = pci_enable_device(pdev);
2468 if (err)
2469 return err;
2470
2471 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
2472 err = -ENODEV;
2473 goto err_out_disable_pdev;
2474 }
2475
1bb09fb9
AKS		 2476 err = qlcnic_set_dma_mask(pdev, &pci_using_dac);
2477 if (err)
2478 goto err_out_disable_pdev;
2479
af19b491
AKS		 2480 err = pci_request_regions(pdev, qlcnic_driver_name);
2481 if (err)
2482 goto err_out_disable_pdev;
2483
2484 pci_set_master(pdev);
451724c8 2485 pci_enable_pcie_error_reporting(pdev);
af19b491 2486
7e2cf4fe 2487 ahw = kzalloc(sizeof(struct qlcnic_hardware_context), GFP_KERNEL);
02135582
SC		 2488 if (!ahw) {
2489 err = -ENOMEM;
7e2cf4fe 2490 goto err_out_free_res;
02135582 2491 }
7e2cf4fe 2492
f8468331
RB		 2493 switch (ent->device) {
2494 case PCI_DEVICE_ID_QLOGIC_QLE824X:
7e2cf4fe 2495 ahw->hw_ops = &qlcnic_hw_ops;
f8468331
RB		 2496 ahw->reg_tbl = (u32 *) qlcnic_reg_tbl;
2497 break;
2498 case PCI_DEVICE_ID_QLOGIC_QLE834X:
40e2b8ed 2499 case PCI_DEVICE_ID_QLOGIC_QLE8830:
15ca140f 2500 case PCI_DEVICE_ID_QLOGIC_QLE844X:
13159183 2501 qlcnic_83xx_register_map(ahw);
f8468331
RB		 2502 break;
2503 case PCI_DEVICE_ID_QLOGIC_VF_QLE834X:
da286a6f 2504 case PCI_DEVICE_ID_QLOGIC_VF_QLE8C30:
15ca140f 2505 case PCI_DEVICE_ID_QLOGIC_VF_QLE844X:
f8468331
RB		 2506 qlcnic_sriov_vf_register_map(ahw);
2507 break;
2508 default:
13159183 2509 goto err_out_free_hw_res;
7e2cf4fe
SC		 2510 }
2511
2512 err = qlcnic_setup_pci_map(pdev, ahw);
2513 if (err)
2514 goto err_out_free_hw_res;
2515
012ec812
HM		 2516 netdev = alloc_etherdev_mq(sizeof(struct qlcnic_adapter),
2517 QLCNIC_MAX_TX_RINGS);
af19b491 2518 if (!netdev) {
af19b491 2519 err = -ENOMEM;
7e2cf4fe 2520 goto err_out_iounmap;
af19b491
AKS		 2521 }
2522
2523 SET_NETDEV_DEV(netdev, &pdev->dev);
2524
2525 adapter = netdev_priv(netdev);
2526 adapter->netdev = netdev;
2527 adapter->pdev = pdev;
13159183
SC		 2528 adapter->ahw = ahw;
2529
2530 adapter->qlcnic_wq = create_singlethread_workqueue("qlcnic");
2531 if (adapter->qlcnic_wq == NULL) {
02135582 2532 err = -ENOMEM;
13159183
SC		 2533 dev_err(&pdev->dev, "Failed to create workqueue\n");
2534 goto err_out_free_netdev;
2535 }
af19b491 2536
2dfc9671
PST		 2537 err = qlcnic_alloc_adapter_resources(adapter);
2538 if (err)
2b1f18a4 2539 goto err_out_free_wq;
b1fc6d3c
AC		 2540
2541 adapter->dev_rst_time = jiffies;
2f514c52
JK		 2542 ahw->revision_id = pdev->revision;
2543 ahw->max_vnic_func = qlcnic_get_vnic_func_count(adapter);
fe1adc6b
JK		 2544 if (qlcnic_mac_learn == FDB_MAC_LEARN)
2545 adapter->fdb_mac_learn = true;
2546 else if (qlcnic_mac_learn == DRV_MAC_LEARN)
2547 adapter->drv_mac_learn = true;
af19b491 2548
b1fc6d3c
AC		 2549 rwlock_init(&adapter->ahw->crb_lock);
2550 mutex_init(&adapter->ahw->mem_lock);
af19b491 2551
af19b491
AKS		 2552 INIT_LIST_HEAD(&adapter->mac_list);
2553
14d385b9
SC		 2554 qlcnic_register_dcb(adapter);
2555
7e2cf4fe 2556 if (qlcnic_82xx_check(adapter)) {
13159183 2557 qlcnic_check_vf(adapter, ent);
7e2cf4fe 2558 adapter->portnum = adapter->ahw->pci_func;
2c97e9e2 2559 qlcnic_reset_api_lock(adapter);
7e2cf4fe
SC		 2560 err = qlcnic_start_firmware(adapter);
2561 if (err) {
66451615
SC		 2562 dev_err(&pdev->dev, "Loading fw failed.Please Reboot\n"
2563 "\t\tIf reboot doesn't help, try flashing the card\n");
2564 goto err_out_maintenance_mode;
7e2cf4fe 2565 }
af19b491 2566
34e8c406
HM		 2567 /* compute and set default and max tx/sds rings */
2568 if (adapter->ahw->msix_supported) {
2569 if (qlcnic_check_multi_tx_capability(adapter) == 1)
2570 qlcnic_set_tx_ring_count(adapter,
2571 QLCNIC_SINGLE_RING);
2572 else
2573 qlcnic_set_tx_ring_count(adapter,
2574 QLCNIC_DEF_TX_RINGS);
2575 qlcnic_set_sds_ring_count(adapter,
2576 QLCNIC_DEF_SDS_RINGS);
2577 } else {
2578 qlcnic_set_tx_ring_count(adapter, QLCNIC_SINGLE_RING);
2579 qlcnic_set_sds_ring_count(adapter, QLCNIC_SINGLE_RING);
012ec812
HM		 2580 }
2581
7e2cf4fe
SC		 2582 err = qlcnic_setup_idc_param(adapter);
2583 if (err)
2584 goto err_out_free_hw;
b0044bcf 2585
7e2cf4fe 2586 adapter->flags |= QLCNIC_NEED_FLR;
14d385b9 2587
13159183
SC		 2588 } else if (qlcnic_83xx_check(adapter)) {
2589 qlcnic_83xx_check_vf(adapter, ent);
2590 adapter->portnum = adapter->ahw->pci_func;
f8468331 2591 err = qlcnic_83xx_init(adapter, pci_using_dac);
629263ac 2592 if (err) {
78ea2d97
SC		 2593 switch (err) {
2594 case -ENOTRECOVERABLE:
2a355aec
SC		 2595 dev_err(&pdev->dev, "Adapter initialization failed due to a faulty hardware\n");
2596 dev_err(&pdev->dev, "Please replace the adapter with new one and return the faulty adapter for repair\n");
78ea2d97
SC		 2597 goto err_out_free_hw;
2598 case -ENOMEM:
2599 dev_err(&pdev->dev, "Adapter initialization failed. Please reboot\n");
2600 goto err_out_free_hw;
aaecf51c
SC		 2601 case -EOPNOTSUPP:
2602 dev_err(&pdev->dev, "Adapter initialization failed\n");
2603 goto err_out_free_hw;
78ea2d97 2604 default:
c65762fc 2605 dev_err(&pdev->dev, "Adapter initialization failed. Driver will load in maintenance mode to recover the adapter using the application\n");
78ea2d97
SC		 2606 goto err_out_maintenance_mode;
2607 }
629263ac 2608 }
78ea2d97 2609
f8468331
RB		 2610 if (qlcnic_sriov_vf_check(adapter))
2611 return 0;
13159183
SC		 2612 } else {
2613 dev_err(&pdev->dev,
2614 "%s: failed. Please Reboot\n", __func__);
7824acd9 2615 err = -ENODEV;
13159183 2616 goto err_out_free_hw;
a7fc948f 2617 }
af19b491 2618
da48e6c3
RB		 2619 if (qlcnic_read_mac_addr(adapter))
2620 dev_warn(&pdev->dev, "failed to read mac addr\n");
2621
07a251c8
SS		 2622 qlcnic_read_phys_port_id(adapter);
2623
da48e6c3 2624 if (adapter->portnum == 0) {
22999798 2625 qlcnic_get_board_name(adapter, board_name);
13159183 2626
da48e6c3 2627 pr_info("%s: %s Board Chip rev 0x%x\n",
22999798
SC		 2628 module_name(THIS_MODULE),
2629 board_name, adapter->ahw->revision_id);
da48e6c3 2630 }
460374f7
HM		 2631
2632 if (qlcnic_83xx_check(adapter) && !qlcnic_use_msi_x &&
2633 !!qlcnic_use_msi)
2634 dev_warn(&pdev->dev,
01b91f4c 2635 "Device does not support MSI interrupts\n");
460374f7 2636
068a8d19 2637 if (qlcnic_82xx_check(adapter)) {
4d52e1e8
SC		 2638 qlcnic_dcb_enable(adapter->dcb);
2639 qlcnic_dcb_get_info(adapter->dcb);
34e8c406 2640 err = qlcnic_setup_intr(adapter);
4d52e1e8 2641
068a8d19
MC		 2642 if (err) {
2643 dev_err(&pdev->dev, "Failed to setup interrupt\n");
13159183 2644 goto err_out_disable_msi;
068a8d19 2645 }
13159183 2646 }
af19b491 2647
02135582
SC		 2648 err = qlcnic_get_act_pci_func(adapter);
2649 if (err)
2650 goto err_out_disable_mbx_intr;
2651
bf63014f
RB		 2652 if (adapter->portnum == 0)
2653 qlcnic_set_drv_version(adapter);
2654
1bb09fb9 2655 err = qlcnic_setup_netdev(adapter, netdev, pci_using_dac);
af19b491 2656 if (err)
7e2cf4fe 2657 goto err_out_disable_mbx_intr;
af19b491
AKS		 2658
2659 pci_set_drvdata(pdev, adapter);
2660
97ee45eb
SC		 2661 if (qlcnic_82xx_check(adapter))
2662 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
2663 FW_POLL_DELAY);
af19b491 2664
b1fc6d3c 2665 switch (adapter->ahw->port_type) {
af19b491
AKS		 2666 case QLCNIC_GBE:
2667 dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
2668 adapter->netdev->name);
2669 break;
2670 case QLCNIC_XGBE:
2671 dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
2672 adapter->netdev->name);
2673 break;
2674 }
2675
fe1adc6b 2676 if (adapter->drv_mac_learn)
e5dcf6dc
SC		 2677 qlcnic_alloc_lb_filters_mem(adapter);
2678
7e2cf4fe 2679 qlcnic_add_sysfs(adapter);
1f0f467b 2680 qlcnic_register_hwmon_dev(adapter);
af19b491
AKS		 2681 return 0;
2682
7e2cf4fe 2683err_out_disable_mbx_intr:
7dd90cf1 2684 if (qlcnic_83xx_check(adapter))
13159183 2685 qlcnic_83xx_free_mbx_intr(adapter);
7e2cf4fe 2686
af19b491
AKS		 2687err_out_disable_msi:
2688 qlcnic_teardown_intr(adapter);
7e2cf4fe 2689 qlcnic_cancel_idc_work(adapter);
21854f02 2690 qlcnic_clr_all_drv_state(adapter, 0);
af19b491 2691
b1fc6d3c
AC		 2692err_out_free_hw:
2693 qlcnic_free_adapter_resources(adapter);
2694
2b1f18a4
WY		 2695err_out_free_wq:
2696 destroy_workqueue(adapter->qlcnic_wq);
2697
af19b491
AKS		 2698err_out_free_netdev:
2699 free_netdev(netdev);
2700
7e2cf4fe 2701err_out_iounmap:
f1a094a8 2702 qlcnic_cleanup_pci_map(ahw);
7e2cf4fe
SC		 2703
2704err_out_free_hw_res:
2705 kfree(ahw);
2706
af19b491
AKS		 2707err_out_free_res:
2708 pci_release_regions(pdev);
2709
2710err_out_disable_pdev:
af19b491
AKS		 2711 pci_disable_device(pdev);
2712 return err;
66451615
SC		 2713
2714err_out_maintenance_mode:
78ea2d97 2715 set_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state);
66451615 2716 netdev->netdev_ops = &qlcnic_netdev_failed_ops;
7ad24ea4 2717 netdev->ethtool_ops = &qlcnic_ethtool_failed_ops;
78ea2d97
SC		 2718 ahw->port_type = QLCNIC_XGBE;
2719
2720 if (qlcnic_83xx_check(adapter))
2721 adapter->tgt_status_reg = NULL;
2722 else
2723 ahw->board_type = QLCNIC_BRDTYPE_P3P_10G_SFP_PLUS;
2724
66451615
SC		 2725 err = register_netdev(netdev);
2726
2727 if (err) {
2728 dev_err(&pdev->dev, "Failed to register net device\n");
2729 qlcnic_clr_all_drv_state(adapter, 0);
2730 goto err_out_free_hw;
2731 }
2732
2733 pci_set_drvdata(pdev, adapter);
2734 qlcnic_add_sysfs(adapter);
2735
2736 return 0;
af19b491
AKS		 2737}
2738
6bb58bb0 2739static void qlcnic_remove(struct pci_dev *pdev)
af19b491
AKS		 2740{
2741 struct qlcnic_adapter *adapter;
2742 struct net_device *netdev;
13159183 2743 struct qlcnic_hardware_context *ahw;
af19b491
AKS		 2744
2745 adapter = pci_get_drvdata(pdev);
2746 if (adapter == NULL)
2747 return;
2748
2749 netdev = adapter->netdev;
2750
13159183 2751 qlcnic_cancel_idc_work(adapter);
132a3f2b 2752 qlcnic_sriov_pf_disable(adapter);
13159183 2753 ahw = adapter->ahw;
af19b491
AKS		 2754
2755 unregister_netdev(netdev);
02feda17 2756 qlcnic_sriov_cleanup(adapter);
af19b491 2757
13159183 2758 if (qlcnic_83xx_check(adapter)) {
9b0fff2a 2759 qlcnic_83xx_initialize_nic(adapter, 0);
3d73b5fd 2760 cancel_delayed_work_sync(&adapter->idc_aen_work);
068a8d19
MC		 2761 qlcnic_83xx_free_mbx_intr(adapter);
2762 qlcnic_83xx_detach_mailbox_work(adapter);
2763 qlcnic_83xx_free_mailbox(ahw->mailbox);
7000078a 2764 kfree(ahw->fw_info);
13159183
SC		 2765 }
2766
3720bf79 2767 qlcnic_dcb_free(adapter->dcb);
af19b491 2768 qlcnic_detach(adapter);
7061b2bd
ME		 2769 kfree(adapter->npars);
2770 kfree(adapter->eswitch);
2e9d722d 2771
97ee45eb
SC		 2772 if (qlcnic_82xx_check(adapter))
2773 qlcnic_clr_all_drv_state(adapter, 0);
af19b491
AKS		 2774
2775 clear_bit(__QLCNIC_RESETTING, &adapter->state);
2776
b5e5492c
AKS		 2777 qlcnic_free_lb_filters_mem(adapter);
2778
af19b491
AKS		 2779 qlcnic_teardown_intr(adapter);
2780
13159183 2781 qlcnic_remove_sysfs(adapter);
af19b491 2782
1f0f467b
HP		 2783 qlcnic_unregister_hwmon_dev(adapter);
2784
f1a094a8 2785 qlcnic_cleanup_pci_map(adapter->ahw);
af19b491
AKS		 2786
2787 qlcnic_release_firmware(adapter);
2788
451724c8 2789 pci_disable_pcie_error_reporting(pdev);
af19b491
AKS		 2790 pci_release_regions(pdev);
2791 pci_disable_device(pdev);
af19b491 2792
13159183
SC		 2793 if (adapter->qlcnic_wq) {
2794 destroy_workqueue(adapter->qlcnic_wq);
2795 adapter->qlcnic_wq = NULL;
2796 }
14d385b9 2797
b1fc6d3c 2798 qlcnic_free_adapter_resources(adapter);
13159183 2799 kfree(ahw);
af19b491
AKS		 2800 free_netdev(netdev);
2801}
af19b491
AKS		 2802
2803static void qlcnic_shutdown(struct pci_dev *pdev)
2804{
2805 if (__qlcnic_shutdown(pdev))
2806 return;
2807
2808 pci_disable_device(pdev);
2809}
2810
2811#ifdef CONFIG_PM
486a5bc7 2812static int qlcnic_suspend(struct pci_dev *pdev, pm_message_t state)
af19b491
AKS		 2813{
2814 int retval;
2815
2816 retval = __qlcnic_shutdown(pdev);
2817 if (retval)
2818 return retval;
2819
2820 pci_set_power_state(pdev, pci_choose_state(pdev, state));
2821 return 0;
2822}
2823
486a5bc7 2824static int qlcnic_resume(struct pci_dev *pdev)
af19b491
AKS		 2825{
2826 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
af19b491
AKS		 2827 int err;
2828
2829 err = pci_enable_device(pdev);
2830 if (err)
2831 return err;
2832
2833 pci_set_power_state(pdev, PCI_D0);
2834 pci_set_master(pdev);
2835 pci_restore_state(pdev);
2836
486a5bc7 2837 return __qlcnic_resume(adapter);
af19b491
AKS		 2838}
2839#endif
2840
2841static int qlcnic_open(struct net_device *netdev)
2842{
2843 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2844 int err;
2845
78ea2d97
SC		 2846 if (test_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state)) {
2847 netdev_err(netdev, "%s: Device is in non-operational state\n",
2848 __func__);
66451615
SC		 2849
2850 return -EIO;
2851 }
2852
c55ad8e5
AKS		 2853 netif_carrier_off(netdev);
2854
af19b491
AKS		 2855 err = qlcnic_attach(adapter);
2856 if (err)
2857 return err;
2858
2859 err = __qlcnic_up(adapter, netdev);
2860 if (err)
060d0564 2861 qlcnic_detach(adapter);
af19b491 2862
af19b491
AKS		 2863 return err;
2864}
2865
2866/*
2867 * qlcnic_close - Disables a network interface entry point
2868 */
2869static int qlcnic_close(struct net_device *netdev)
2870{
2871 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2872
2873 __qlcnic_down(adapter, netdev);
13159183 2874
af19b491
AKS		 2875 return 0;
2876}
2877
d747c333
RB		 2878#define QLCNIC_VF_LB_BUCKET_SIZE 1
2879
e5dcf6dc 2880void qlcnic_alloc_lb_filters_mem(struct qlcnic_adapter *adapter)
b5e5492c
AKS		 2881{
2882 void *head;
2883 int i;
13159183
SC		 2884 struct net_device *netdev = adapter->netdev;
2885 u32 filter_size = 0;
2886 u16 act_pci_func = 0;
b5e5492c 2887
e5dcf6dc 2888 if (adapter->fhash.fmax && adapter->fhash.fhead)
b5e5492c
AKS		 2889 return;
2890
2f514c52 2891 act_pci_func = adapter->ahw->total_nic_func;
b5e5492c 2892 spin_lock_init(&adapter->mac_learn_lock);
53643a75 2893 spin_lock_init(&adapter->rx_mac_learn_lock);
b5e5492c 2894
d747c333
RB		 2895 if (qlcnic_sriov_vf_check(adapter)) {
2896 filter_size = QLCNIC_83XX_SRIOV_VF_MAX_MAC - 1;
2897 adapter->fhash.fbucket_size = QLCNIC_VF_LB_BUCKET_SIZE;
2898 } else if (qlcnic_82xx_check(adapter)) {
13159183
SC		 2899 filter_size = QLCNIC_LB_MAX_FILTERS;
2900 adapter->fhash.fbucket_size = QLCNIC_LB_BUCKET_SIZE;
2901 } else {
2902 filter_size = QLC_83XX_LB_MAX_FILTERS;
2903 adapter->fhash.fbucket_size = QLC_83XX_LB_BUCKET_SIZE;
2904 }
2905
2906 head = kcalloc(adapter->fhash.fbucket_size,
1d9219dd 2907 sizeof(struct hlist_head), GFP_ATOMIC);
13159183 2908
b5e5492c
AKS		 2909 if (!head)
2910 return;
2911
13159183 2912 adapter->fhash.fmax = (filter_size / act_pci_func);
43d620c8 2913 adapter->fhash.fhead = head;
b5e5492c 2914
13159183
SC		 2915 netdev_info(netdev, "active nic func = %d, mac filter size=%d\n",
2916 act_pci_func, adapter->fhash.fmax);
2917
2918 for (i = 0; i < adapter->fhash.fbucket_size; i++)
b5e5492c 2919 INIT_HLIST_HEAD(&adapter->fhash.fhead[i]);
53643a75
SS		 2920
2921 adapter->rx_fhash.fbucket_size = adapter->fhash.fbucket_size;
2922
2923 head = kcalloc(adapter->rx_fhash.fbucket_size,
2924 sizeof(struct hlist_head), GFP_ATOMIC);
2925
2926 if (!head)
2927 return;
2928
2929 adapter->rx_fhash.fmax = (filter_size / act_pci_func);
2930 adapter->rx_fhash.fhead = head;
2931
2932 for (i = 0; i < adapter->rx_fhash.fbucket_size; i++)
2933 INIT_HLIST_HEAD(&adapter->rx_fhash.fhead[i]);
b5e5492c
AKS		 2934}
2935
2936static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter)
2937{
7061b2bd 2938 if (adapter->fhash.fmax)
b5e5492c
AKS		 2939 kfree(adapter->fhash.fhead);
2940
2941 adapter->fhash.fhead = NULL;
2942 adapter->fhash.fmax = 0;
53643a75 2943
7061b2bd 2944 if (adapter->rx_fhash.fmax)
53643a75
SS		 2945 kfree(adapter->rx_fhash.fhead);
2946
2947 adapter->rx_fhash.fmax = 0;
2948 adapter->rx_fhash.fhead = NULL;
b5e5492c
AKS		 2949}
2950
629263ac 2951int qlcnic_check_temp(struct qlcnic_adapter *adapter)
af19b491
AKS		 2952{
2953 struct net_device *netdev = adapter->netdev;
97ee45eb 2954 u32 temp_state, temp_val, temp = 0;
af19b491
AKS		 2955 int rv = 0;
2956
13159183
SC		 2957 if (qlcnic_83xx_check(adapter))
2958 temp = QLCRDX(adapter->ahw, QLC_83XX_ASIC_TEMP);
2959
97ee45eb 2960 if (qlcnic_82xx_check(adapter))
a15ebd37 2961 temp = QLC_SHARED_REG_RD32(adapter, QLCNIC_ASIC_TEMP);
af19b491
AKS		 2962
2963 temp_state = qlcnic_get_temp_state(temp);
2964 temp_val = qlcnic_get_temp_val(temp);
2965
2966 if (temp_state == QLCNIC_TEMP_PANIC) {
2967 dev_err(&netdev->dev,
2968 "Device temperature %d degrees C exceeds"
2969 " maximum allowed. Hardware has been shut down.\n",
2970 temp_val);
2971 rv = 1;
2972 } else if (temp_state == QLCNIC_TEMP_WARN) {
79788450 2973 if (adapter->ahw->temp == QLCNIC_TEMP_NORMAL) {
af19b491
AKS		 2974 dev_err(&netdev->dev,
2975 "Device temperature %d degrees C "
2976 "exceeds operating range."
2977 " Immediate action needed.\n",
2978 temp_val);
2979 }
2980 } else {
79788450 2981 if (adapter->ahw->temp == QLCNIC_TEMP_WARN) {
af19b491
AKS		 2982 dev_info(&netdev->dev,
2983 "Device temperature is now %d degrees C"
2984 " in normal range.\n", temp_val);
2985 }
2986 }
79788450 2987 adapter->ahw->temp = temp_state;
af19b491
AKS		 2988 return rv;
2989}
2990
95b3890a 2991static inline void dump_tx_ring_desc(struct qlcnic_host_tx_ring *tx_ring)
af19b491 2992{
95b3890a
HM		 2993 int i;
2994 struct cmd_desc_type0 *tx_desc_info;
2995
2996 for (i = 0; i < tx_ring->num_desc; i++) {
2997 tx_desc_info = &tx_ring->desc_head[i];
2998 pr_info("TX Desc: %d\n", i);
2999 print_hex_dump(KERN_INFO, "TX: ", DUMP_PREFIX_OFFSET, 16, 1,
3000 &tx_ring->desc_head[i],
3001 sizeof(struct cmd_desc_type0), true);
3002 }
3003}
3004
665d1eca 3005static void qlcnic_dump_rings(struct qlcnic_adapter *adapter)
95b3890a 3006{
665d1eca 3007 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
95b3890a 3008 struct net_device *netdev = adapter->netdev;
665d1eca
HP		 3009 struct qlcnic_host_rds_ring *rds_ring;
3010 struct qlcnic_host_sds_ring *sds_ring;
012ec812
HM		 3011 struct qlcnic_host_tx_ring *tx_ring;
3012 int ring;
af19b491 3013
95b3890a
HM		 3014 if (!netdev || !netif_running(netdev))
3015 return;
3016
665d1eca
HP		 3017 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
3018 rds_ring = &recv_ctx->rds_rings[ring];
3019 if (!rds_ring)
3020 continue;
3021 netdev_info(netdev,
3022 "rds_ring=%d crb_rcv_producer=%d producer=%u num_desc=%u\n",
3023 ring, readl(rds_ring->crb_rcv_producer),
3024 rds_ring->producer, rds_ring->num_desc);
3025 }
3026
3027 for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
3028 sds_ring = &(recv_ctx->sds_rings[ring]);
3029 if (!sds_ring)
3030 continue;
3031 netdev_info(netdev,
3032 "sds_ring=%d crb_sts_consumer=%d consumer=%u crb_intr_mask=%d num_desc=%u\n",
3033 ring, readl(sds_ring->crb_sts_consumer),
3034 sds_ring->consumer, readl(sds_ring->crb_intr_mask),
3035 sds_ring->num_desc);
3036 }
3037
95b3890a
HM		 3038 for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
3039 tx_ring = &adapter->tx_ring[ring];
665d1eca
HP		 3040 if (!tx_ring)
3041 continue;
95b3890a
HM		 3042 netdev_info(netdev, "Tx ring=%d Context Id=0x%x\n",
3043 ring, tx_ring->ctx_id);
3044 netdev_info(netdev,
3045 "xmit_finished=%llu, xmit_called=%llu, xmit_on=%llu, xmit_off=%llu\n",
3046 tx_ring->tx_stats.xmit_finished,
3047 tx_ring->tx_stats.xmit_called,
3048 tx_ring->tx_stats.xmit_on,
3049 tx_ring->tx_stats.xmit_off);
d5d2bf3e
MC		 3050
3051 if (tx_ring->crb_intr_mask)
3052 netdev_info(netdev, "crb_intr_mask=%d\n",
3053 readl(tx_ring->crb_intr_mask));
3054
95b3890a 3055 netdev_info(netdev,
d5d2bf3e 3056 "hw_producer=%d, sw_producer=%d sw_consumer=%d, hw_consumer=%d\n",
95b3890a
HM		 3057 readl(tx_ring->crb_cmd_producer),
3058 tx_ring->producer, tx_ring->sw_consumer,
3059 le32_to_cpu(*(tx_ring->hw_consumer)));
3060
3061 netdev_info(netdev, "Total desc=%d, Available desc=%d\n",
3062 tx_ring->num_desc, qlcnic_tx_avail(tx_ring));
3063
665d1eca 3064 if (netif_msg_tx_err(adapter->ahw))
95b3890a
HM		 3065 dump_tx_ring_desc(tx_ring);
3066 }
665d1eca 3067
95b3890a
HM		 3068}
3069
3070static void qlcnic_tx_timeout(struct net_device *netdev)
3071{
3072 struct qlcnic_adapter *adapter = netdev_priv(netdev);
3073
af19b491
AKS		 3074 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
3075 return;
3076
665d1eca
HP		 3077 qlcnic_dump_rings(adapter);
3078
3079 if (++adapter->tx_timeo_cnt >= QLCNIC_MAX_TX_TIMEOUTS ||
3080 netif_msg_tx_err(adapter->ahw)) {
3081 netdev_err(netdev, "Tx timeout, reset the adapter.\n");
536faa61
SC		 3082 if (qlcnic_82xx_check(adapter))
3083 adapter->need_fw_reset = 1;
3084 else if (qlcnic_83xx_check(adapter))
3085 qlcnic_83xx_idc_request_reset(adapter,
3086 QLCNIC_FORCE_FW_DUMP_KEY);
3087 } else {
665d1eca 3088 netdev_err(netdev, "Tx timeout, reset adapter context.\n");
79788450 3089 adapter->ahw->reset_context = 1;
536faa61 3090 }
af19b491
AKS		 3091}
3092
3093static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev)
3094{
3095 struct qlcnic_adapter *adapter = netdev_priv(netdev);
3096 struct net_device_stats *stats = &netdev->stats;
3097
1ac6762a
MC		 3098 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
3099 qlcnic_update_stats(adapter);
3100
af19b491
AKS		 3101 stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
3102 stats->tx_packets = adapter->stats.xmitfinished;
7e382594 3103 stats->rx_bytes = adapter->stats.rxbytes + adapter->stats.lrobytes;
af19b491
AKS		 3104 stats->tx_bytes = adapter->stats.txbytes;
3105 stats->rx_dropped = adapter->stats.rxdropped;
3106 stats->tx_dropped = adapter->stats.txdropped;
3107
3108 return stats;
3109}
3110
21041400 3111static irqreturn_t qlcnic_82xx_clear_legacy_intr(struct qlcnic_adapter *adapter)
af19b491 3112{
af19b491
AKS		 3113 u32 status;
3114
3115 status = readl(adapter->isr_int_vec);
3116
79788450 3117 if (!(status & adapter->ahw->int_vec_bit))
af19b491
AKS		 3118 return IRQ_NONE;
3119
3120 /* check interrupt state machine, to be sure */
3121 status = readl(adapter->crb_int_state_reg);
3122 if (!ISR_LEGACY_INT_TRIGGERED(status))
3123 return IRQ_NONE;
3124
3125 writel(0xffffffff, adapter->tgt_status_reg);
3126 /* read twice to ensure write is flushed */
3127 readl(adapter->isr_int_vec);
3128 readl(adapter->isr_int_vec);
3129
7eb9855d
AKS		 3130 return IRQ_HANDLED;
3131}
3132
3133static irqreturn_t qlcnic_tmp_intr(int irq, void *data)
3134{
3135 struct qlcnic_host_sds_ring *sds_ring = data;
3136 struct qlcnic_adapter *adapter = sds_ring->adapter;
3137
3138 if (adapter->flags & QLCNIC_MSIX_ENABLED)
3139 goto done;
3140 else if (adapter->flags & QLCNIC_MSI_ENABLED) {
3141 writel(0xffffffff, adapter->tgt_status_reg);
3142 goto done;
3143 }
3144
3145 if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
3146 return IRQ_NONE;
3147
3148done:
79788450 3149 adapter->ahw->diag_cnt++;
2cc5752e 3150 qlcnic_enable_sds_intr(adapter, sds_ring);
7eb9855d
AKS		 3151 return IRQ_HANDLED;
3152}
3153
3154static irqreturn_t qlcnic_intr(int irq, void *data)
3155{
3156 struct qlcnic_host_sds_ring *sds_ring = data;
3157 struct qlcnic_adapter *adapter = sds_ring->adapter;
3158
3159 if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
3160 return IRQ_NONE;
3161
af19b491
AKS		 3162 napi_schedule(&sds_ring->napi);
3163
3164 return IRQ_HANDLED;
3165}
3166
3167static irqreturn_t qlcnic_msi_intr(int irq, void *data)
3168{
3169 struct qlcnic_host_sds_ring *sds_ring = data;
3170 struct qlcnic_adapter *adapter = sds_ring->adapter;
3171
3172 /* clear interrupt */
3173 writel(0xffffffff, adapter->tgt_status_reg);
3174
3175 napi_schedule(&sds_ring->napi);
3176 return IRQ_HANDLED;
3177}
3178
3179static irqreturn_t qlcnic_msix_intr(int irq, void *data)
3180{
3181 struct qlcnic_host_sds_ring *sds_ring = data;
3182
3183 napi_schedule(&sds_ring->napi);
3184 return IRQ_HANDLED;
3185}
3186
13159183
SC		 3187static irqreturn_t qlcnic_msix_tx_intr(int irq, void *data)
3188{
3189 struct qlcnic_host_tx_ring *tx_ring = data;
3190
3191 napi_schedule(&tx_ring->napi);
3192 return IRQ_HANDLED;
3193}
3194
af19b491
AKS		 3195#ifdef CONFIG_NET_POLL_CONTROLLER
3196static void qlcnic_poll_controller(struct net_device *netdev)
3197{
3198 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2b018ad9
M		 3199 struct qlcnic_host_sds_ring *sds_ring;
3200 struct qlcnic_recv_context *recv_ctx;
3201 struct qlcnic_host_tx_ring *tx_ring;
3202 int ring;
3203
3204 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
3205 return;
3206
3207 recv_ctx = adapter->recv_ctx;
bf82791e 3208
34e8c406 3209 for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
bf82791e 3210 sds_ring = &recv_ctx->sds_rings[ring];
2b018ad9
M		 3211 qlcnic_disable_sds_intr(adapter, sds_ring);
3212 napi_schedule(&sds_ring->napi);
3213 }
3214
3215 if (adapter->flags & QLCNIC_MSIX_ENABLED) {
3216 /* Only Multi-Tx queue capable devices need to
3217 * schedule NAPI for TX rings
3218 */
3219 if ((qlcnic_83xx_check(adapter) &&
3220 (adapter->flags & QLCNIC_TX_INTR_SHARED)) ||
3221 (qlcnic_82xx_check(adapter) &&
3222 !qlcnic_check_multi_tx(adapter)))
3223 return;
3224
3225 for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
3226 tx_ring = &adapter->tx_ring[ring];
3227 qlcnic_disable_tx_intr(adapter, tx_ring);
3228 napi_schedule(&tx_ring->napi);
3229 }
bf82791e 3230 }
af19b491
AKS		 3231}
3232#endif
3233
6df900e9
SC		 3234static void
3235qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding)
3236{
3237 u32 val;
3238
3239 val = adapter->portnum & 0xf;
3240 val |= encoding << 7;
3241 val |= (jiffies - adapter->dev_rst_time) << 8;
3242
a15ebd37 3243 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_SCRATCH, val);
6df900e9
SC		 3244 adapter->dev_rst_time = jiffies;
3245}
3246
ade91f8e
AKS		 3247static int
3248qlcnic_set_drv_state(struct qlcnic_adapter *adapter, u8 state)
af19b491
AKS		 3249{
3250 u32 val;
3251
3252 WARN_ON(state != QLCNIC_DEV_NEED_RESET &&
3253 state != QLCNIC_DEV_NEED_QUISCENT);
3254
3255 if (qlcnic_api_lock(adapter))
ade91f8e 3256 return -EIO;
af19b491 3257
a15ebd37 3258 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
af19b491
AKS		 3259
3260 if (state == QLCNIC_DEV_NEED_RESET)
6d2a4724 3261 QLC_DEV_SET_RST_RDY(val, adapter->portnum);
af19b491 3262 else if (state == QLCNIC_DEV_NEED_QUISCENT)
6d2a4724 3263 QLC_DEV_SET_QSCNT_RDY(val, adapter->portnum);
af19b491 3264
a15ebd37 3265 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
af19b491
AKS		 3266
3267 qlcnic_api_unlock(adapter);
ade91f8e
AKS		 3268
3269 return 0;
af19b491
AKS		 3270}
3271
1b95a839
AKS		 3272static int
3273qlcnic_clr_drv_state(struct qlcnic_adapter *adapter)
3274{
3275 u32 val;
3276
3277 if (qlcnic_api_lock(adapter))
3278 return -EBUSY;
3279
a15ebd37 3280 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 3281 QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
a15ebd37 3282 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
1b95a839
AKS		 3283
3284 qlcnic_api_unlock(adapter);
3285
3286 return 0;
3287}
3288
486a5bc7 3289void qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8 failed)
af19b491
AKS		 3290{
3291 u32 val;
3292
3293 if (qlcnic_api_lock(adapter))
3294 goto err;
3295
a15ebd37 3296 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
6d2a4724 3297 QLC_DEV_CLR_REF_CNT(val, adapter->portnum);
a15ebd37 3298 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
af19b491 3299
21854f02 3300 if (failed) {
a15ebd37
HM		 3301 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3302 QLCNIC_DEV_FAILED);
21854f02
AKS		 3303 dev_info(&adapter->pdev->dev,
3304 "Device state set to Failed. Please Reboot\n");
3305 } else if (!(val & 0x11111111))
a15ebd37
HM		 3306 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3307 QLCNIC_DEV_COLD);
af19b491 3308
a15ebd37 3309 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 3310 QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
a15ebd37 3311 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
af19b491
AKS		 3312
3313 qlcnic_api_unlock(adapter);
3314err:
3315 adapter->fw_fail_cnt = 0;
032a13c7 3316 adapter->flags &= ~QLCNIC_FW_HANG;
af19b491
AKS		 3317 clear_bit(__QLCNIC_START_FW, &adapter->state);
3318 clear_bit(__QLCNIC_RESETTING, &adapter->state);
3319}
3320
f73dfc50 3321/* Grab api lock, before checking state */
af19b491
AKS		 3322static int
3323qlcnic_check_drv_state(struct qlcnic_adapter *adapter)
3324{
602ca6f0 3325 int act, state, active_mask;
a15ebd37 3326 struct qlcnic_hardware_context *ahw = adapter->ahw;
af19b491 3327
a15ebd37
HM		 3328 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3329 act = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
af19b491 3330
602ca6f0 3331 if (adapter->flags & QLCNIC_FW_RESET_OWNER) {
a15ebd37 3332 active_mask = (~(1 << (ahw->pci_func * 4)));
602ca6f0
SV		 3333 act = act & active_mask;
3334 }
3335
af19b491
AKS		 3336 if (((state & 0x11111111) == (act & 0x11111111)) ||
3337 ((act & 0x11111111) == ((state >> 1) & 0x11111111)))
3338 return 0;
3339 else
3340 return 1;
3341}
3342
96f8118c
SC		 3343static int qlcnic_check_idc_ver(struct qlcnic_adapter *adapter)
3344{
a15ebd37 3345 u32 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_IDC_VER);
96f8118c
SC		 3346
3347 if (val != QLCNIC_DRV_IDC_VER) {
3348 dev_warn(&adapter->pdev->dev, "IDC Version mismatch, driver's"
3349 " idc ver = %x; reqd = %x\n", QLCNIC_DRV_IDC_VER, val);
3350 }
3351
3352 return 0;
3353}
3354
af19b491
AKS		 3355static int
3356qlcnic_can_start_firmware(struct qlcnic_adapter *adapter)
3357{
3358 u32 val, prev_state;
aa5e18c0 3359 u8 dev_init_timeo = adapter->dev_init_timeo;
6d2a4724 3360 u8 portnum = adapter->portnum;
96f8118c 3361 u8 ret;
af19b491 3362
f73dfc50
AKS		 3363 if (test_and_clear_bit(__QLCNIC_START_FW, &adapter->state))
3364 return 1;
3365
af19b491
AKS		 3366 if (qlcnic_api_lock(adapter))
3367 return -1;
3368
a15ebd37 3369 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
6d2a4724
AKS		 3370 if (!(val & (1 << (portnum * 4)))) {
3371 QLC_DEV_SET_REF_CNT(val, portnum);
a15ebd37 3372 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
af19b491
AKS		 3373 }
3374
a15ebd37 3375 prev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
65b5b420 3376 QLCDB(adapter, HW, "Device state = %u\n", prev_state);
af19b491
AKS		 3377
3378 switch (prev_state) {
3379 case QLCNIC_DEV_COLD:
a15ebd37
HM		 3380 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3381 QLCNIC_DEV_INITIALIZING);
3382 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_IDC_VER,
3383 QLCNIC_DRV_IDC_VER);
6df900e9 3384 qlcnic_idc_debug_info(adapter, 0);
af19b491
AKS		 3385 qlcnic_api_unlock(adapter);
3386 return 1;
3387
3388 case QLCNIC_DEV_READY:
96f8118c 3389 ret = qlcnic_check_idc_ver(adapter);
af19b491 3390 qlcnic_api_unlock(adapter);
96f8118c 3391 return ret;
af19b491
AKS		 3392
3393 case QLCNIC_DEV_NEED_RESET:
a15ebd37 3394 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 3395 QLC_DEV_SET_RST_RDY(val, portnum);
a15ebd37 3396 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
af19b491
AKS		 3397 break;
3398
3399 case QLCNIC_DEV_NEED_QUISCENT:
a15ebd37 3400 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 3401 QLC_DEV_SET_QSCNT_RDY(val, portnum);
a15ebd37 3402 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
af19b491
AKS		 3403 break;
3404
3405 case QLCNIC_DEV_FAILED:
a7fc948f 3406 dev_err(&adapter->pdev->dev, "Device in failed state.\n");
af19b491
AKS		 3407 qlcnic_api_unlock(adapter);
3408 return -1;
bbd8c6a4
AKS		 3409
3410 case QLCNIC_DEV_INITIALIZING:
3411 case QLCNIC_DEV_QUISCENT:
3412 break;
af19b491
AKS		 3413 }
3414
3415 qlcnic_api_unlock(adapter);
aa5e18c0
SC		 3416
3417 do {
af19b491 3418 msleep(1000);
a15ebd37 3419 prev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
a5e463d0
SC		 3420
3421 if (prev_state == QLCNIC_DEV_QUISCENT)
3422 continue;
3423 } while ((prev_state != QLCNIC_DEV_READY) && --dev_init_timeo);
af19b491 3424
65b5b420
AKS		 3425 if (!dev_init_timeo) {
3426 dev_err(&adapter->pdev->dev,
3427 "Waiting for device to initialize timeout\n");
af19b491 3428 return -1;
65b5b420 3429 }
af19b491
AKS		 3430
3431 if (qlcnic_api_lock(adapter))
3432 return -1;
3433
a15ebd37 3434 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 3435 QLC_DEV_CLR_RST_QSCNT(val, portnum);
a15ebd37 3436 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
af19b491 3437
96f8118c 3438 ret = qlcnic_check_idc_ver(adapter);
af19b491
AKS		 3439 qlcnic_api_unlock(adapter);
3440
96f8118c 3441 return ret;
af19b491
AKS		 3442}
3443
3444static void
3445qlcnic_fwinit_work(struct work_struct *work)
3446{
3447 struct qlcnic_adapter *adapter = container_of(work,
3448 struct qlcnic_adapter, fw_work.work);
3c4b23b1 3449 u32 dev_state = 0xf;
7b749ff4 3450 u32 val;
af19b491 3451
f73dfc50
AKS		 3452 if (qlcnic_api_lock(adapter))
3453 goto err_ret;
af19b491 3454
a15ebd37 3455 dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
b8c17620
AKS		 3456 if (dev_state == QLCNIC_DEV_QUISCENT ||
3457 dev_state == QLCNIC_DEV_NEED_QUISCENT) {
a5e463d0
SC		 3458 qlcnic_api_unlock(adapter);
3459 qlcnic_schedule_work(adapter, qlcnic_fwinit_work,
3460 FW_POLL_DELAY * 2);
3461 return;
3462 }
3463
79788450 3464 if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
3c4b23b1
AKS		 3465 qlcnic_api_unlock(adapter);
3466 goto wait_npar;
9f26f547
AC		 3467 }
3468
16e3cf73
SV		 3469 if (dev_state == QLCNIC_DEV_INITIALIZING ||
3470 dev_state == QLCNIC_DEV_READY) {
3471 dev_info(&adapter->pdev->dev, "Detected state change from "
3472 "DEV_NEED_RESET, skipping ack check\n");
3473 goto skip_ack_check;
3474 }
3475
f73dfc50 3476 if (adapter->fw_wait_cnt++ > adapter->reset_ack_timeo) {
16e3cf73 3477 dev_info(&adapter->pdev->dev, "Reset:Failed to get ack %d sec\n",
f73dfc50
AKS		 3478 adapter->reset_ack_timeo);
3479 goto skip_ack_check;
3480 }
3481
3482 if (!qlcnic_check_drv_state(adapter)) {
3483skip_ack_check:
a15ebd37 3484 dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
a5e463d0 3485
f73dfc50 3486 if (dev_state == QLCNIC_DEV_NEED_RESET) {
a15ebd37
HM		 3487 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3488 QLCNIC_DEV_INITIALIZING);
f73dfc50
AKS		 3489 set_bit(__QLCNIC_START_FW, &adapter->state);
3490 QLCDB(adapter, DRV, "Restarting fw\n");
6df900e9 3491 qlcnic_idc_debug_info(adapter, 0);
a15ebd37
HM		 3492 val = QLC_SHARED_REG_RD32(adapter,
3493 QLCNIC_CRB_DRV_STATE);
7b749ff4 3494 QLC_DEV_SET_RST_RDY(val, adapter->portnum);
a15ebd37
HM		 3495 QLC_SHARED_REG_WR32(adapter,
3496 QLCNIC_CRB_DRV_STATE, val);
af19b491
AKS		 3497 }
3498
f73dfc50
AKS		 3499 qlcnic_api_unlock(adapter);
3500
287e38aa 3501 rtnl_lock();
890b6e02 3502 if (qlcnic_check_fw_dump_state(adapter) &&
7b749ff4 3503 (adapter->flags & QLCNIC_FW_RESET_OWNER)) {
9d6a6440
AC		 3504 QLCDB(adapter, DRV, "Take FW dump\n");
3505 qlcnic_dump_fw(adapter);
032a13c7 3506 adapter->flags |= QLCNIC_FW_HANG;
9d6a6440 3507 }
287e38aa 3508 rtnl_unlock();
7b749ff4
SV		 3509
3510 adapter->flags &= ~QLCNIC_FW_RESET_OWNER;
9f26f547 3511 if (!adapter->nic_ops->start_firmware(adapter)) {
af19b491 3512 qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
b18971d1 3513 adapter->fw_wait_cnt = 0;
af19b491
AKS		 3514 return;
3515 }
af19b491
AKS		 3516 goto err_ret;
3517 }
3518
f73dfc50 3519 qlcnic_api_unlock(adapter);
aa5e18c0 3520
9f26f547 3521wait_npar:
a15ebd37 3522 dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
f73dfc50 3523 QLCDB(adapter, HW, "Func waiting: Device state=%u\n", dev_state);
65b5b420 3524
af19b491 3525 switch (dev_state) {
3c4b23b1 3526 case QLCNIC_DEV_READY:
7e2cf4fe 3527 if (!qlcnic_start_firmware(adapter)) {
f73dfc50 3528 qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
b18971d1 3529 adapter->fw_wait_cnt = 0;
f73dfc50
AKS		 3530 return;
3531 }
3c4b23b1
AKS		 3532 case QLCNIC_DEV_FAILED:
3533 break;
3534 default:
3535 qlcnic_schedule_work(adapter,
3536 qlcnic_fwinit_work, FW_POLL_DELAY);
3537 return;
af19b491
AKS		 3538 }
3539
3540err_ret:
f73dfc50
AKS		 3541 dev_err(&adapter->pdev->dev, "Fwinit work failed state=%u "
3542 "fw_wait_cnt=%u\n", dev_state, adapter->fw_wait_cnt);
34ce3626 3543 netif_device_attach(adapter->netdev);
21854f02 3544 qlcnic_clr_all_drv_state(adapter, 0);
af19b491
AKS		 3545}
3546
3547static void
3548qlcnic_detach_work(struct work_struct *work)
3549{
3550 struct qlcnic_adapter *adapter = container_of(work,
3551 struct qlcnic_adapter, fw_work.work);
3552 struct net_device *netdev = adapter->netdev;
3553 u32 status;
3554
3555 netif_device_detach(netdev);
3556
b8c17620
AKS		 3557 /* Dont grab rtnl lock during Quiscent mode */
3558 if (adapter->dev_state == QLCNIC_DEV_NEED_QUISCENT) {
3559 if (netif_running(netdev))
3560 __qlcnic_down(adapter, netdev);
3561 } else
3562 qlcnic_down(adapter, netdev);
af19b491 3563
a15ebd37 3564 status = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS1);
af19b491 3565
44f65b29
SC		 3566 if (status & QLCNIC_RCODE_FATAL_ERROR) {
3567 dev_err(&adapter->pdev->dev,
3568 "Detaching the device: peg halt status1=0x%x\n",
3569 status);
3570
3571 if (QLCNIC_FWERROR_CODE(status) == QLCNIC_FWERROR_FAN_FAILURE) {
3572 dev_err(&adapter->pdev->dev,
3573 "On board active cooling fan failed. "
3574 "Device has been halted.\n");
3575 dev_err(&adapter->pdev->dev,
3576 "Replace the adapter.\n");
3577 }
3578
af19b491 3579 goto err_ret;
44f65b29 3580 }
af19b491 3581
79788450 3582 if (adapter->ahw->temp == QLCNIC_TEMP_PANIC) {
44f65b29 3583 dev_err(&adapter->pdev->dev, "Detaching the device: temp=%d\n",
79788450 3584 adapter->ahw->temp);
af19b491 3585 goto err_ret;
44f65b29
SC		 3586 }
3587
602ca6f0
SV		 3588 /* Dont ack if this instance is the reset owner */
3589 if (!(adapter->flags & QLCNIC_FW_RESET_OWNER)) {
44f65b29
SC		 3590 if (qlcnic_set_drv_state(adapter, adapter->dev_state)) {
3591 dev_err(&adapter->pdev->dev,
3592 "Failed to set driver state,"
3593 "detaching the device.\n");
602ca6f0 3594 goto err_ret;
44f65b29 3595 }
602ca6f0 3596 }
af19b491
AKS		 3597
3598 adapter->fw_wait_cnt = 0;
3599
3600 qlcnic_schedule_work(adapter, qlcnic_fwinit_work, FW_POLL_DELAY);
3601
3602 return;
3603
3604err_ret:
34ce3626 3605 netif_device_attach(netdev);
21854f02 3606 qlcnic_clr_all_drv_state(adapter, 1);
af19b491
AKS		 3607}
3608
3c4b23b1
AKS		 3609/*Transit NPAR state to NON Operational */
3610static void
3611qlcnic_set_npar_non_operational(struct qlcnic_adapter *adapter)
3612{
3613 u32 state;
3614
a15ebd37 3615 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
3c4b23b1
AKS		 3616 if (state == QLCNIC_DEV_NPAR_NON_OPER)
3617 return;
3618
3619 if (qlcnic_api_lock(adapter))
3620 return;
a15ebd37
HM		 3621 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
3622 QLCNIC_DEV_NPAR_NON_OPER);
3c4b23b1
AKS		 3623 qlcnic_api_unlock(adapter);
3624}
3625
21041400 3626static void qlcnic_82xx_dev_request_reset(struct qlcnic_adapter *adapter,
3627 u32 key)
af19b491 3628{
646779f1
SV		 3629 u32 state, xg_val = 0, gb_val = 0;
3630
3631 qlcnic_xg_set_xg0_mask(xg_val);
3632 qlcnic_xg_set_xg1_mask(xg_val);
3633 QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, xg_val);
3634 qlcnic_gb_set_gb0_mask(gb_val);
3635 qlcnic_gb_set_gb1_mask(gb_val);
3636 qlcnic_gb_set_gb2_mask(gb_val);
3637 qlcnic_gb_set_gb3_mask(gb_val);
3638 QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, gb_val);
3639 dev_info(&adapter->pdev->dev, "Pause control frames disabled"
3640 " on all ports\n");
cea8975e 3641 adapter->need_fw_reset = 1;
13159183 3642
af19b491
AKS		 3643 if (qlcnic_api_lock(adapter))
3644 return;
3645
13159183 3646 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
78ea2d97
SC		 3647
3648 if (test_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state)) {
3649 netdev_err(adapter->netdev, "%s: Device is in non-operational state\n",
66451615
SC		 3650 __func__);
3651 qlcnic_api_unlock(adapter);
3652
3653 return;
3654 }
af19b491 3655
f73dfc50 3656 if (state == QLCNIC_DEV_READY) {
13159183
SC		 3657 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3658 QLCNIC_DEV_NEED_RESET);
602ca6f0 3659 adapter->flags |= QLCNIC_FW_RESET_OWNER;
65b5b420 3660 QLCDB(adapter, DRV, "NEED_RESET state set\n");
6df900e9 3661 qlcnic_idc_debug_info(adapter, 0);
af19b491
AKS		 3662 }
3663
13159183
SC		 3664 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
3665 QLCNIC_DEV_NPAR_NON_OPER);
af19b491
AKS		 3666 qlcnic_api_unlock(adapter);
3667}
3668
9f26f547
AC		 3669/* Transit to NPAR READY state from NPAR NOT READY state */
3670static void
3671qlcnic_dev_set_npar_ready(struct qlcnic_adapter *adapter)
3672{
9f26f547
AC		 3673 if (qlcnic_api_lock(adapter))
3674 return;
3675
a15ebd37
HM		 3676 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
3677 QLCNIC_DEV_NPAR_OPER);
3c4b23b1 3678 QLCDB(adapter, DRV, "NPAR operational state set\n");
9f26f547
AC		 3679
3680 qlcnic_api_unlock(adapter);
3681}
3682
13159183
SC		 3683void qlcnic_schedule_work(struct qlcnic_adapter *adapter,
3684 work_func_t func, int delay)
af19b491 3685{
451724c8
SC		 3686 if (test_bit(__QLCNIC_AER, &adapter->state))
3687 return;
3688
af19b491 3689 INIT_DELAYED_WORK(&adapter->fw_work, func);
13159183
SC		 3690 queue_delayed_work(adapter->qlcnic_wq, &adapter->fw_work,
3691 round_jiffies_relative(delay));
af19b491
AKS		 3692}
3693
3694static void
3695qlcnic_attach_work(struct work_struct *work)
3696{
3697 struct qlcnic_adapter *adapter = container_of(work,
3698 struct qlcnic_adapter, fw_work.work);
3699 struct net_device *netdev = adapter->netdev;
b18971d1 3700 u32 npar_state;
af19b491 3701
79788450 3702 if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC) {
a15ebd37
HM		 3703 npar_state = QLC_SHARED_REG_RD32(adapter,
3704 QLCNIC_CRB_DEV_NPAR_STATE);
b18971d1
AKS		 3705 if (adapter->fw_wait_cnt++ > QLCNIC_DEV_NPAR_OPER_TIMEO)
3706 qlcnic_clr_all_drv_state(adapter, 0);
3707 else if (npar_state != QLCNIC_DEV_NPAR_OPER)
3708 qlcnic_schedule_work(adapter, qlcnic_attach_work,
3709 FW_POLL_DELAY);
3710 else
3711 goto attach;
3712 QLCDB(adapter, DRV, "Waiting for NPAR state to operational\n");
3713 return;
3714 }
3715attach:
1de899d3 3716 qlcnic_dcb_get_info(adapter->dcb);
14d385b9 3717
af19b491 3718 if (netif_running(netdev)) {
52486a3a 3719 if (qlcnic_up(adapter, netdev))
af19b491 3720 goto done;
af19b491 3721
aec1e845 3722 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
af19b491
AKS		 3723 }
3724
af19b491 3725done:
34ce3626 3726 netif_device_attach(netdev);
af19b491 3727 adapter->fw_fail_cnt = 0;
032a13c7 3728 adapter->flags &= ~QLCNIC_FW_HANG;
af19b491 3729 clear_bit(__QLCNIC_RESETTING, &adapter->state);
24866d15
HM		 3730 if (adapter->portnum == 0)
3731 qlcnic_set_drv_version(adapter);
1b95a839
AKS		 3732
3733 if (!qlcnic_clr_drv_state(adapter))
3734 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
3735 FW_POLL_DELAY);
af19b491
AKS		 3736}
3737
3738static int
3739qlcnic_check_health(struct qlcnic_adapter *adapter)
3740{
891e71b1
PP		 3741 struct qlcnic_hardware_context *ahw = adapter->ahw;
3742 struct qlcnic_fw_dump *fw_dump = &ahw->fw_dump;
4e70812b 3743 u32 state = 0, heartbeat;
853d4bca 3744 u32 peg_status;
4bd8e738 3745 int err = 0;
af19b491
AKS		 3746
3747 if (qlcnic_check_temp(adapter))
3748 goto detach;
3749
2372a5f1 3750 if (adapter->need_fw_reset)
7e2cf4fe 3751 qlcnic_dev_request_reset(adapter, 0);
af19b491 3752
a15ebd37 3753 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
b8c17620 3754 if (state == QLCNIC_DEV_NEED_RESET) {
3c4b23b1 3755 qlcnic_set_npar_non_operational(adapter);
af19b491 3756 adapter->need_fw_reset = 1;
b8c17620
AKS		 3757 } else if (state == QLCNIC_DEV_NEED_QUISCENT)
3758 goto detach;
af19b491 3759
a15ebd37 3760 heartbeat = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_ALIVE_COUNTER);
4e70812b
SC		 3761 if (heartbeat != adapter->heartbeat) {
3762 adapter->heartbeat = heartbeat;
af19b491
AKS		 3763 adapter->fw_fail_cnt = 0;
3764 if (adapter->need_fw_reset)
3765 goto detach;
68bf1c68 3766
891e71b1 3767 if (ahw->reset_context && qlcnic_auto_fw_reset)
68bf1c68 3768 qlcnic_reset_hw_context(adapter);
68bf1c68 3769
af19b491
AKS		 3770 return 0;
3771 }
3772
3773 if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
3774 return 0;
3775
032a13c7
SV		 3776 adapter->flags |= QLCNIC_FW_HANG;
3777
7e2cf4fe 3778 qlcnic_dev_request_reset(adapter, 0);
af19b491 3779
099f7aa7 3780 if (qlcnic_auto_fw_reset)
0df170b6 3781 clear_bit(__QLCNIC_FW_ATTACHED, &adapter->state);
af19b491 3782
853d4bca 3783 dev_err(&adapter->pdev->dev, "firmware hang detected\n");
a15ebd37 3784 peg_status = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS1);
853d4bca 3785 dev_err(&adapter->pdev->dev, "Dumping hw/fw registers\n"
c76ecb7a
SV		 3786 "PEG_HALT_STATUS1: 0x%x, PEG_HALT_STATUS2: 0x%x,\n"
3787 "PEG_NET_0_PC: 0x%x, PEG_NET_1_PC: 0x%x,\n"
3788 "PEG_NET_2_PC: 0x%x, PEG_NET_3_PC: 0x%x,\n"
3789 "PEG_NET_4_PC: 0x%x\n",
a15ebd37
HM		 3790 peg_status,
3791 QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS2),
4bd8e738
HM		 3792 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_0 + 0x3c, &err),
3793 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_1 + 0x3c, &err),
3794 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_2 + 0x3c, &err),
3795 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_3 + 0x3c, &err),
3796 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_4 + 0x3c, &err));
97048a1f 3797 if (QLCNIC_FWERROR_CODE(peg_status) == 0x67)
853d4bca
AR		 3798 dev_err(&adapter->pdev->dev,
3799 "Firmware aborted with error code 0x00006700. "
3800 "Device is being reset.\n");
af19b491
AKS		 3801detach:
3802 adapter->dev_state = (state == QLCNIC_DEV_NEED_QUISCENT) ? state :
3803 QLCNIC_DEV_NEED_RESET;
3804
099f7aa7
SC		 3805 if (qlcnic_auto_fw_reset && !test_and_set_bit(__QLCNIC_RESETTING,
3806 &adapter->state)) {
65b5b420 3807
af19b491 3808 qlcnic_schedule_work(adapter, qlcnic_detach_work, 0);
65b5b420 3809 QLCDB(adapter, DRV, "fw recovery scheduled.\n");
891e71b1
PP		 3810 } else if (!qlcnic_auto_fw_reset && fw_dump->enable &&
3811 adapter->flags & QLCNIC_FW_RESET_OWNER) {
3812 qlcnic_dump_fw(adapter);
65b5b420 3813 }
af19b491
AKS		 3814
3815 return 1;
3816}
3817
486a5bc7 3818void qlcnic_fw_poll_work(struct work_struct *work)
af19b491
AKS		 3819{
3820 struct qlcnic_adapter *adapter = container_of(work,
3821 struct qlcnic_adapter, fw_work.work);
3822
3823 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
3824 goto reschedule;
3825
3826
3827 if (qlcnic_check_health(adapter))
3828 return;
3829
b5e5492c
AKS		 3830 if (adapter->fhash.fnum)
3831 qlcnic_prune_lb_filters(adapter);
3832
af19b491
AKS		 3833reschedule:
3834 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
3835}
3836
451724c8
SC		 3837static int qlcnic_is_first_func(struct pci_dev *pdev)
3838{
3839 struct pci_dev *oth_pdev;
3840 int val = pdev->devfn;
3841
3842 while (val-- > 0) {
3843 oth_pdev = pci_get_domain_bus_and_slot(pci_domain_nr
3844 (pdev->bus), pdev->bus->number,
3845 PCI_DEVFN(PCI_SLOT(pdev->devfn), val));
bfc978fa
AKS		 3846 if (!oth_pdev)
3847 continue;
451724c8 3848
bfc978fa
AKS		 3849 if (oth_pdev->current_state != PCI_D3cold) {
3850 pci_dev_put(oth_pdev);
451724c8 3851 return 0;
bfc978fa
AKS		 3852 }
3853 pci_dev_put(oth_pdev);
451724c8
SC		 3854 }
3855 return 1;
3856}
3857
3858static int qlcnic_attach_func(struct pci_dev *pdev)
3859{
3860 int err, first_func;
3861 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3862 struct net_device *netdev = adapter->netdev;
3863
3864 pdev->error_state = pci_channel_io_normal;
3865
3866 err = pci_enable_device(pdev);
3867 if (err)
3868 return err;
3869
451724c8
SC		 3870 pci_set_master(pdev);
3871 pci_restore_state(pdev);
3872
3873 first_func = qlcnic_is_first_func(pdev);
3874
3875 if (qlcnic_api_lock(adapter))
3876 return -EINVAL;
3877
79788450 3878 if (adapter->ahw->op_mode != QLCNIC_NON_PRIV_FUNC && first_func) {
451724c8
SC		 3879 adapter->need_fw_reset = 1;
3880 set_bit(__QLCNIC_START_FW, &adapter->state);
a15ebd37
HM		 3881 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3882 QLCNIC_DEV_INITIALIZING);
451724c8
SC		 3883 QLCDB(adapter, DRV, "Restarting fw\n");
3884 }
3885 qlcnic_api_unlock(adapter);
3886
13159183 3887 err = qlcnic_start_firmware(adapter);
451724c8
SC		 3888 if (err)
3889 return err;
3890
3891 qlcnic_clr_drv_state(adapter);
13159183
SC		 3892 kfree(adapter->msix_entries);
3893 adapter->msix_entries = NULL;
34e8c406 3894 err = qlcnic_setup_intr(adapter);
13159183 3895
9a97e705
M		 3896 if (err) {
3897 kfree(adapter->msix_entries);
3898 netdev_err(netdev, "failed to setup interrupt\n");
3899 return err;
3900 }
3901
451724c8
SC		 3902 if (netif_running(netdev)) {
3903 err = qlcnic_attach(adapter);
3904 if (err) {
21854f02 3905 qlcnic_clr_all_drv_state(adapter, 1);
451724c8
SC		 3906 clear_bit(__QLCNIC_AER, &adapter->state);
3907 netif_device_attach(netdev);
3908 return err;
3909 }
3910
3911 err = qlcnic_up(adapter, netdev);
3912 if (err)
3913 goto done;
3914
aec1e845 3915 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
451724c8
SC		 3916 }
3917 done:
3918 netif_device_attach(netdev);
3919 return err;
3920}
3921
21041400 3922static pci_ers_result_t qlcnic_82xx_io_error_detected(struct pci_dev *pdev,
3923 pci_channel_state_t state)
451724c8
SC		 3924{
3925 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3926 struct net_device *netdev = adapter->netdev;
3927
3928 if (state == pci_channel_io_perm_failure)
3929 return PCI_ERS_RESULT_DISCONNECT;
3930
3931 if (state == pci_channel_io_normal)
3932 return PCI_ERS_RESULT_RECOVERED;
3933
3934 set_bit(__QLCNIC_AER, &adapter->state);
3935 netif_device_detach(netdev);
3936
3937 cancel_delayed_work_sync(&adapter->fw_work);
3938
3939 if (netif_running(netdev))
3940 qlcnic_down(adapter, netdev);
3941
3942 qlcnic_detach(adapter);
3943 qlcnic_teardown_intr(adapter);
3944
3945 clear_bit(__QLCNIC_RESETTING, &adapter->state);
3946
3947 pci_save_state(pdev);
3948 pci_disable_device(pdev);
3949
3950 return PCI_ERS_RESULT_NEED_RESET;
3951}
3952
21041400 3953static pci_ers_result_t qlcnic_82xx_io_slot_reset(struct pci_dev *pdev)
451724c8
SC		 3954{
3955 return qlcnic_attach_func(pdev) ? PCI_ERS_RESULT_DISCONNECT :
3956 PCI_ERS_RESULT_RECOVERED;
3957}
3958
21041400 3959static void qlcnic_82xx_io_resume(struct pci_dev *pdev)
451724c8 3960{
a15ebd37 3961 u32 state;
451724c8
SC		 3962 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3963
3964 pci_cleanup_aer_uncorrect_error_status(pdev);
a15ebd37
HM		 3965 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3966 if (state == QLCNIC_DEV_READY && test_and_clear_bit(__QLCNIC_AER,
3967 &adapter->state))
451724c8 3968 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
4460f2e8 3969 FW_POLL_DELAY);
451724c8
SC		 3970}
3971
4460f2e8
PP		 3972static pci_ers_result_t qlcnic_io_error_detected(struct pci_dev *pdev,
3973 pci_channel_state_t state)
3974{
3975 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3976 struct qlcnic_hardware_ops *hw_ops = adapter->ahw->hw_ops;
3977
3978 if (hw_ops->io_error_detected) {
3979 return hw_ops->io_error_detected(pdev, state);
3980 } else {
3981 dev_err(&pdev->dev, "AER error_detected handler not registered.\n");
3982 return PCI_ERS_RESULT_DISCONNECT;
3983 }
3984}
3985
3986static pci_ers_result_t qlcnic_io_slot_reset(struct pci_dev *pdev)
3987{
3988 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3989 struct qlcnic_hardware_ops *hw_ops = adapter->ahw->hw_ops;
3990
3991 if (hw_ops->io_slot_reset) {
3992 return hw_ops->io_slot_reset(pdev);
3993 } else {
3994 dev_err(&pdev->dev, "AER slot_reset handler not registered.\n");
3995 return PCI_ERS_RESULT_DISCONNECT;
3996 }
3997}
3998
3999static void qlcnic_io_resume(struct pci_dev *pdev)
4000{
4001 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
4002 struct qlcnic_hardware_ops *hw_ops = adapter->ahw->hw_ops;
4003
4004 if (hw_ops->io_resume)
4005 hw_ops->io_resume(pdev);
4006 else
4007 dev_err(&pdev->dev, "AER resume handler not registered.\n");
4008}
4009
4010
87eb743b
AC		 4011static int
4012qlcnicvf_start_firmware(struct qlcnic_adapter *adapter)
4013{
4014 int err;
4015
4016 err = qlcnic_can_start_firmware(adapter);
4017 if (err)
4018 return err;
4019
78f84e1a
AKS		 4020 err = qlcnic_check_npar_opertional(adapter);
4021 if (err)
4022 return err;
3c4b23b1 4023
174240a8
RB		 4024 err = qlcnic_initialize_nic(adapter);
4025 if (err)
4026 return err;
4027
87eb743b
AC		 4028 qlcnic_check_options(adapter);
4029
7373373d
RB		 4030 err = qlcnic_set_eswitch_port_config(adapter);
4031 if (err)
4032 return err;
4033
87eb743b
AC		 4034 adapter->need_fw_reset = 0;
4035
4036 return err;
4037}
4038
34e8c406
HM		 4039int qlcnic_validate_rings(struct qlcnic_adapter *adapter, __u32 ring_cnt,
4040 int queue_type)
aa4a1f7d
HM		 4041{
4042 struct net_device *netdev = adapter->netdev;
34e8c406
HM		 4043 u8 max_hw_rings = 0;
4044 char buf[8];
4045 int cur_rings;
4046
4047 if (queue_type == QLCNIC_RX_QUEUE) {
4048 max_hw_rings = adapter->max_sds_rings;
4049 cur_rings = adapter->drv_sds_rings;
4050 strcpy(buf, "SDS");
4051 } else if (queue_type == QLCNIC_TX_QUEUE) {
18afc102 4052 max_hw_rings = adapter->max_tx_rings;
34e8c406
HM		 4053 cur_rings = adapter->drv_tx_rings;
4054 strcpy(buf, "Tx");
aa4a1f7d
HM		 4055 }
4056
34e8c406
HM		 4057 if (!is_power_of_2(ring_cnt)) {
4058 netdev_err(netdev, "%s rings value should be a power of 2\n",
4059 buf);
aa4a1f7d
HM		 4060 return -EINVAL;
4061 }
4062
34e8c406
HM		 4063 if (qlcnic_82xx_check(adapter) && (queue_type == QLCNIC_TX_QUEUE) &&
4064 !qlcnic_check_multi_tx(adapter)) {
4065 netdev_err(netdev, "No Multi Tx queue support\n");
4066 return -EINVAL;
f94bc1e7
SC		 4067 }
4068
34e8c406
HM		 4069 if (ring_cnt > num_online_cpus()) {
4070 netdev_err(netdev,
4071 "%s value[%u] should not be higher than, number of online CPUs\n",
4072 buf, num_online_cpus());
f94bc1e7
SC		 4073 return -EINVAL;
4074 }
34e8c406 4075
f94bc1e7 4076 return 0;
f94bc1e7
SC		 4077}
4078
cb9327d5 4079int qlcnic_setup_rings(struct qlcnic_adapter *adapter)
f94bc1e7
SC		 4080{
4081 struct net_device *netdev = adapter->netdev;
84d7ad2c 4082 u8 tx_rings, rx_rings;
34e8c406 4083 int err;
f94bc1e7 4084
319ecf12
SC		 4085 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
4086 return -EBUSY;
4087
84d7ad2c
SS		 4088 tx_rings = adapter->drv_tss_rings;
4089 rx_rings = adapter->drv_rss_rings;
4090
f94bc1e7 4091 netif_device_detach(netdev);
84d7ad2c
SS		 4092
4093 err = qlcnic_set_real_num_queues(adapter, tx_rings, rx_rings);
4094 if (err)
4095 goto done;
4096
f94bc1e7
SC		 4097 if (netif_running(netdev))
4098 __qlcnic_down(adapter, netdev);
13159183 4099
7dd90cf1
SC		 4100 qlcnic_detach(adapter);
4101
7ed3ce48 4102 if (qlcnic_83xx_check(adapter)) {
13159183 4103 qlcnic_83xx_free_mbx_intr(adapter);
7ed3ce48
RB		 4104 qlcnic_83xx_enable_mbx_poll(adapter);
4105 }
13159183 4106
f94bc1e7 4107 qlcnic_teardown_intr(adapter);
aa4a1f7d 4108
34e8c406 4109 err = qlcnic_setup_intr(adapter);
9a97e705
M		 4110 if (err) {
4111 kfree(adapter->msix_entries);
4112 netdev_err(netdev, "failed to setup interrupt\n");
4113 return err;
4114 }
f94bc1e7 4115
84d7ad2c
SS		 4116 /* Check if we need to update real_num_{tx|rx}_queues because
4117 * qlcnic_setup_intr() may change Tx/Rx rings size
4118 */
4119 if ((tx_rings != adapter->drv_tx_rings) ||
4120 (rx_rings != adapter->drv_sds_rings)) {
4121 err = qlcnic_set_real_num_queues(adapter,
4122 adapter->drv_tx_rings,
4123 adapter->drv_sds_rings);
4124 if (err)
4125 goto done;
4126 }
cb9327d5 4127
13159183 4128 if (qlcnic_83xx_check(adapter)) {
9b0fff2a 4129 qlcnic_83xx_initialize_nic(adapter, 1);
13159183 4130 err = qlcnic_83xx_setup_mbx_intr(adapter);
7ed3ce48 4131 qlcnic_83xx_disable_mbx_poll(adapter);
13159183
SC		 4132 if (err) {
4133 dev_err(&adapter->pdev->dev,
4134 "failed to setup mbx interrupt\n");
4135 goto done;
4136 }
f94bc1e7
SC		 4137 }
4138
4139 if (netif_running(netdev)) {
4140 err = qlcnic_attach(adapter);
4141 if (err)
4142 goto done;
4143 err = __qlcnic_up(adapter, netdev);
4144 if (err)
4145 goto done;
4146 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
4147 }
aa4a1f7d 4148done:
f94bc1e7
SC		 4149 netif_device_attach(netdev);
4150 clear_bit(__QLCNIC_RESETTING, &adapter->state);
4151 return err;
4152}
4153
af19b491
AKS		 4154#ifdef CONFIG_INET
4155
4156#define is_qlcnic_netdev(dev) (dev->netdev_ops == &qlcnic_netdev_ops)
4157
af19b491 4158static void
aec1e845
AKS		 4159qlcnic_config_indev_addr(struct qlcnic_adapter *adapter,
4160 struct net_device *dev, unsigned long event)
af19b491
AKS		 4161{
4162 struct in_device *indev;
af19b491 4163
af19b491
AKS		 4164 indev = in_dev_get(dev);
4165 if (!indev)
4166 return;
4167
4168 for_ifa(indev) {
4169 switch (event) {
4170 case NETDEV_UP:
4171 qlcnic_config_ipaddr(adapter,
4172 ifa->ifa_address, QLCNIC_IP_UP);
4173 break;
4174 case NETDEV_DOWN:
4175 qlcnic_config_ipaddr(adapter,
4176 ifa->ifa_address, QLCNIC_IP_DOWN);
4177 break;
4178 default:
4179 break;
4180 }
4181 } endfor_ifa(indev);
4182
4183 in_dev_put(indev);
af19b491
AKS		 4184}
4185
319ecf12 4186void qlcnic_restore_indev_addr(struct net_device *netdev, unsigned long event)
aec1e845
AKS		 4187{
4188 struct qlcnic_adapter *adapter = netdev_priv(netdev);
4189 struct net_device *dev;
4190 u16 vid;
4191
4192 qlcnic_config_indev_addr(adapter, netdev, event);
4193
43c00a75 4194 rcu_read_lock();
b9796a14 4195 for_each_set_bit(vid, adapter->vlans, VLAN_N_VID) {
f06c7f9f 4196 dev = __vlan_find_dev_deep_rcu(netdev, htons(ETH_P_8021Q), vid);
aec1e845
AKS		 4197 if (!dev)
4198 continue;
aec1e845
AKS		 4199 qlcnic_config_indev_addr(adapter, dev, event);
4200 }
43c00a75 4201 rcu_read_unlock();
aec1e845
AKS		 4202}
4203
af19b491
AKS		 4204static int qlcnic_netdev_event(struct notifier_block *this,
4205 unsigned long event, void *ptr)
4206{
4207 struct qlcnic_adapter *adapter;
351638e7 4208 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
af19b491
AKS		 4209
4210recheck:
4211 if (dev == NULL)
4212 goto done;
4213
4214 if (dev->priv_flags & IFF_802_1Q_VLAN) {
4215 dev = vlan_dev_real_dev(dev);
4216 goto recheck;
4217 }
4218
4219 if (!is_qlcnic_netdev(dev))
4220 goto done;
4221
4222 adapter = netdev_priv(dev);
4223
4224 if (!adapter)
4225 goto done;
4226
8a15ad1f 4227 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
af19b491
AKS		 4228 goto done;
4229
aec1e845 4230 qlcnic_config_indev_addr(adapter, dev, event);
af19b491
AKS		 4231done:
4232 return NOTIFY_DONE;
4233}
4234
4235static int
4236qlcnic_inetaddr_event(struct notifier_block *this,
4237 unsigned long event, void *ptr)
4238{
4239 struct qlcnic_adapter *adapter;
4240 struct net_device *dev;
4241
4242 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
4243
4244 dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
4245
4246recheck:
aec1e845 4247 if (dev == NULL)
af19b491
AKS		 4248 goto done;
4249
4250 if (dev->priv_flags & IFF_802_1Q_VLAN) {
4251 dev = vlan_dev_real_dev(dev);
4252 goto recheck;
4253 }
4254
4255 if (!is_qlcnic_netdev(dev))
4256 goto done;
4257
4258 adapter = netdev_priv(dev);
4259
251a84c9 4260 if (!adapter)
af19b491
AKS		 4261 goto done;
4262
8a15ad1f 4263 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
af19b491
AKS		 4264 goto done;
4265
4266 switch (event) {
4267 case NETDEV_UP:
4268 qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_UP);
13159183 4269
af19b491
AKS		 4270 break;
4271 case NETDEV_DOWN:
4272 qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_DOWN);
13159183 4273
af19b491
AKS		 4274 break;
4275 default:
4276 break;
4277 }
4278
4279done:
4280 return NOTIFY_DONE;
4281}
4282
4283static struct notifier_block qlcnic_netdev_cb = {
4284 .notifier_call = qlcnic_netdev_event,
4285};
4286
4287static struct notifier_block qlcnic_inetaddr_cb = {
4288 .notifier_call = qlcnic_inetaddr_event,
4289};
4290#else
f8ca2b6f 4291void qlcnic_restore_indev_addr(struct net_device *dev, unsigned long event)
af19b491
AKS		 4292{ }
4293#endif
fec9dd15 4294static const struct pci_error_handlers qlcnic_err_handler = {
451724c8
SC		 4295 .error_detected = qlcnic_io_error_detected,
4296 .slot_reset = qlcnic_io_slot_reset,
4297 .resume = qlcnic_io_resume,
4298};
af19b491
AKS		 4299
4300static struct pci_driver qlcnic_driver = {
4301 .name = qlcnic_driver_name,
4302 .id_table = qlcnic_pci_tbl,
4303 .probe = qlcnic_probe,
6bb58bb0 4304 .remove = qlcnic_remove,
af19b491
AKS		 4305#ifdef CONFIG_PM
4306 .suspend = qlcnic_suspend,
4307 .resume = qlcnic_resume,
4308#endif
451724c8 4309 .shutdown = qlcnic_shutdown,
02feda17
RB		 4310 .err_handler = &qlcnic_err_handler,
4311#ifdef CONFIG_QLCNIC_SRIOV
4312 .sriov_configure = qlcnic_pci_sriov_configure,
4313#endif
451724c8 4314
af19b491
AKS		 4315};
4316
4317static int __init qlcnic_init_module(void)
4318{
0cf3a14c 4319 int ret;
af19b491
AKS		 4320
4321 printk(KERN_INFO "%s\n", qlcnic_driver_string);
4322
4323#ifdef CONFIG_INET
4324 register_netdevice_notifier(&qlcnic_netdev_cb);
4325 register_inetaddr_notifier(&qlcnic_inetaddr_cb);
4326#endif
4327
0cf3a14c
AKS		 4328 ret = pci_register_driver(&qlcnic_driver);
4329 if (ret) {
4330#ifdef CONFIG_INET
4331 unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
4332 unregister_netdevice_notifier(&qlcnic_netdev_cb);
4333#endif
4334 }
af19b491 4335
0cf3a14c 4336 return ret;
af19b491
AKS		 4337}
4338
4339module_init(qlcnic_init_module);
4340
4341static void __exit qlcnic_exit_module(void)
4342{
af19b491
AKS		 4343 pci_unregister_driver(&qlcnic_driver);
4344
4345#ifdef CONFIG_INET
4346 unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
4347 unregister_netdevice_notifier(&qlcnic_netdev_cb);
4348#endif
4349}
4350
4351module_exit(qlcnic_exit_module);
Ubuntu Artful kernel mirror