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