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