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