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