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