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