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