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