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