qlcnic_main.c

   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
  23MODULE_DESCRIPTION("QLogic 1/10 GbE Converged/Intelligent Ethernet Driver");
  24MODULE_LICENSE("GPL");
  25MODULE_VERSION(QLCNIC_LINUX_VERSIONID);
  26MODULE_FIRMWARE(QLCNIC_UNIFIED_ROMIMAGE_NAME);
  27
  28char qlcnic_driver_name[] = "qlcnic";
  29static const char qlcnic_driver_string[] = "QLogic 1/10 GbE "
  30	"Converged/Intelligent Ethernet Driver v" QLCNIC_LINUX_VERSIONID;
  31
  32static int qlcnic_mac_learn;
  33module_param(qlcnic_mac_learn, int, 0444);
  34MODULE_PARM_DESC(qlcnic_mac_learn,
  35		 "Mac Filter (0=learning is disabled, 1=Driver learning is enabled, 2=FDB learning is enabled)");
  36
  37int qlcnic_use_msi = 1;
  38MODULE_PARM_DESC(use_msi, "MSI interrupt (0=disabled, 1=enabled)");
  39module_param_named(use_msi, qlcnic_use_msi, int, 0444);
  40
  41int qlcnic_use_msi_x = 1;
  42MODULE_PARM_DESC(use_msi_x, "MSI-X interrupt (0=disabled, 1=enabled)");
  43module_param_named(use_msi_x, qlcnic_use_msi_x, int, 0444);
  44
  45int qlcnic_auto_fw_reset = 1;
  46MODULE_PARM_DESC(auto_fw_reset, "Auto firmware reset (0=disabled, 1=enabled)");
  47module_param_named(auto_fw_reset, qlcnic_auto_fw_reset, int, 0644);
  48
  49int qlcnic_load_fw_file;
  50MODULE_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)");
  51module_param_named(load_fw_file, qlcnic_load_fw_file, int, 0444);
  52
  53static int qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
  54static void qlcnic_remove(struct pci_dev *pdev);
  55static int qlcnic_open(struct net_device *netdev);
  56static int qlcnic_close(struct net_device *netdev);
  57static void qlcnic_tx_timeout(struct net_device *netdev, unsigned int txqueue);
  58static void qlcnic_attach_work(struct work_struct *work);
  59static void qlcnic_fwinit_work(struct work_struct *work);
  60
  61static void qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding);
  62static int qlcnic_can_start_firmware(struct qlcnic_adapter *adapter);
  63
  64static irqreturn_t qlcnic_tmp_intr(int irq, void *data);
  65static irqreturn_t qlcnic_intr(int irq, void *data);
  66static irqreturn_t qlcnic_msi_intr(int irq, void *data);
  67static irqreturn_t qlcnic_msix_intr(int irq, void *data);
  68static irqreturn_t qlcnic_msix_tx_intr(int irq, void *data);
  69
  70static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev);
  71static int qlcnic_start_firmware(struct qlcnic_adapter *);
  72
  73static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter);
  74static void qlcnic_dev_set_npar_ready(struct qlcnic_adapter *);
  75static int qlcnicvf_start_firmware(struct qlcnic_adapter *);
  76static int qlcnic_vlan_rx_add(struct net_device *, __be16, u16);
  77static int qlcnic_vlan_rx_del(struct net_device *, __be16, u16);
  78
  79static int qlcnic_82xx_setup_intr(struct qlcnic_adapter *);
  80static void qlcnic_82xx_dev_request_reset(struct qlcnic_adapter *, u32);
  81static irqreturn_t qlcnic_82xx_clear_legacy_intr(struct qlcnic_adapter *);
  82static pci_ers_result_t qlcnic_82xx_io_slot_reset(struct pci_dev *);
  83static int qlcnic_82xx_start_firmware(struct qlcnic_adapter *);
  84static void qlcnic_82xx_io_resume(struct pci_dev *);
  85static void qlcnic_82xx_set_mac_filter_count(struct qlcnic_adapter *);
  86static pci_ers_result_t qlcnic_82xx_io_error_detected(struct pci_dev *,
  87						      pci_channel_state_t);
  88static 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
 103static 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
 114MODULE_DEVICE_TABLE(pci, qlcnic_pci_tbl);
 115
 116
 117inline 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
 122static 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
 129static 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
 155static 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
 276static const
 277struct qlcnic_legacy_intr_set legacy_intr[] = QLCNIC_LEGACY_INTR_CONFIG;
 278
 279int 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
 288void 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
 294int 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
 318static 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
 333static 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
 368static 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
 394static 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
 428static 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
 445static 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
 456static 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
 471static 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
 487static 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
 494static 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
 502static 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
 530static const struct net_device_ops qlcnic_netdev_failed_ops = {
 531	.ndo_open	   = qlcnic_open,
 532};
 533
 534static 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
 548struct 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
 554static 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
 609static 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
 622static 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
 641void 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
 651void 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
 661int 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
 692restore:
 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
 731int 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) {
 747enable_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
 804static 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
 818static 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
 852static 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
 881int 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
 912void 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
 928static void qlcnic_cleanup_pci_map(struct qlcnic_hardware_context *ahw)
 929{
 930	if (ahw->pci_base0 != NULL)
 931		iounmap(ahw->pci_base0);
 932}
 933
 934static 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
 964static 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
 981int 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
1061err_eswitch:
1062	kfree(adapter->eswitch);
1063	adapter->eswitch = NULL;
1064err_npars:
1065	kfree(adapter->npars);
1066	adapter->npars = NULL;
1067err_pci_info:
1068	kfree(pci_info);
1069
1070	return ret;
1071}
1072
1073static int
1074qlcnic_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);
1091err_lock:
1092	return ret;
1093}
1094
1095static 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
1126static 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
1145static 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
1178static 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
1199static 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
1220static void
1221qlcnic_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
1281static int
1282qlcnic_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
1328void 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
1345static int
1346qlcnic_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
1365static int
1366qlcnic_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
1386void 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
1402int 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
1419void 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
1433static int
1434qlcnic_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
1480int 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
1517static int
1518qlcnic_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
1540int 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
1582static 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
1605static int
1606qlcnic_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
1627static 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
1662check_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
1685err_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
1693static int
1694qlcnic_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
1781static void
1782qlcnic_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
1813static 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
1828static 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
1855int __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
1902int 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
1914void __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
1951void 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
1960int
1961qlcnic_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
2000err_out_free_hw:
2001	qlcnic_free_hw_resources(adapter);
2002err_out_free_sw:
2003	qlcnic_free_sw_resources(adapter);
2004err_out_napi_del:
2005	qlcnic_napi_del(adapter);
2006	return err;
2007}
2008
2009void 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
2025void 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);
2053out:
2054	netif_device_attach(netdev);
2055}
2056
2057static 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));
2083err_out:
2084	return err;
2085}
2086
2087static 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
2109int 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 */
2164static int
2165qlcnic_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
2185int
2186qlcnic_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
2218static 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
2234static 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
2259int
2260qlcnic_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
2337void 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
2352int 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
2395void 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 */
2410static void qlcnic_reset_api_lock(struct qlcnic_adapter *adapter)
2411{
2412	qlcnic_api_lock(adapter);
2413	qlcnic_api_unlock(adapter);
2414}
2415
2416
2417static int
2418qlcnic_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
2650err_out_disable_mbx_intr:
2651	if (qlcnic_83xx_check(adapter))
2652		qlcnic_83xx_free_mbx_intr(adapter);
2653
2654err_out_disable_msi:
2655	qlcnic_teardown_intr(adapter);
2656	qlcnic_cancel_idc_work(adapter);
2657	qlcnic_clr_all_drv_state(adapter, 0);
2658
2659err_out_free_hw:
2660	qlcnic_free_adapter_resources(adapter);
2661
2662err_out_free_wq:
2663	destroy_workqueue(adapter->qlcnic_wq);
2664
2665err_out_free_netdev:
2666	free_netdev(netdev);
2667
2668err_out_iounmap:
2669	qlcnic_cleanup_pci_map(ahw);
2670
2671err_out_free_hw_res:
2672	kfree(ahw);
2673
2674err_out_free_res:
2675	pci_release_regions(pdev);
2676
2677err_out_disable_pdev:
2678	pci_disable_device(pdev);
2679	return err;
2680
2681err_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
2706static 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
2769static void qlcnic_shutdown(struct pci_dev *pdev)
2770{
2771	if (__qlcnic_shutdown(pdev))
2772		return;
2773
2774	pci_disable_device(pdev);
2775}
2776
2777static int __maybe_unused qlcnic_suspend(struct device *dev_d)
2778{
2779	return __qlcnic_shutdown(to_pci_dev(dev_d));
2780}
2781
2782static 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
2789static 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 */
2817static 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
2828void 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
2884static 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
2899int 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
2939static 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
2951static 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
3016static 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
3039static 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
3057static 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
3079static 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
3094done:
3095	adapter->ahw->diag_cnt++;
3096	qlcnic_enable_sds_intr(adapter, sds_ring);
3097	return IRQ_HANDLED;
3098}
3099
3100static 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
3113static 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
3125static 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
3133static 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
3141static void
3142qlcnic_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
3154static int
3155qlcnic_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
3179static int
3180qlcnic_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
3196void 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);
3221err:
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 */
3229static int
3230qlcnic_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
3250static 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
3262static int
3263qlcnic_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
3348static void
3349qlcnic_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)) {
3387skip_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
3425wait_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
3445err_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
3452static void
3453qlcnic_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
3509err_ret:
3510	netif_device_attach(netdev);
3511	qlcnic_clr_all_drv_state(adapter, 1);
3512}
3513
3514/*Transit NPAR state to NON Operational */
3515static void
3516qlcnic_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
3531static 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 */
3575static void
3576qlcnic_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
3588void 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
3599static void
3600qlcnic_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	}
3620attach:
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
3630done:
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
3643static int
3644qlcnic_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");
3706detach:
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
3723void 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
3738reschedule:
3739	qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
3740}
3741
3742static 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
3763static 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	err = pci_enable_device(pdev);
3770	if (err)
3771		return err;
3772
3773	pci_set_master(pdev);
3774	pci_restore_state(pdev);
3775
3776	first_func = qlcnic_is_first_func(pdev);
3777
3778	if (qlcnic_api_lock(adapter))
3779		return -EINVAL;
3780
3781	if (adapter->ahw->op_mode != QLCNIC_NON_PRIV_FUNC && first_func) {
3782		adapter->need_fw_reset = 1;
3783		set_bit(__QLCNIC_START_FW, &adapter->state);
3784		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3785				    QLCNIC_DEV_INITIALIZING);
3786		QLCDB(adapter, DRV, "Restarting fw\n");
3787	}
3788	qlcnic_api_unlock(adapter);
3789
3790	err = qlcnic_start_firmware(adapter);
3791	if (err)
3792		return err;
3793
3794	qlcnic_clr_drv_state(adapter);
3795	kfree(adapter->msix_entries);
3796	adapter->msix_entries = NULL;
3797	err = qlcnic_setup_intr(adapter);
3798
3799	if (err) {
3800		kfree(adapter->msix_entries);
3801		netdev_err(netdev, "failed to setup interrupt\n");
3802		return err;
3803	}
3804
3805	if (netif_running(netdev)) {
3806		err = qlcnic_attach(adapter);
3807		if (err) {
3808			qlcnic_clr_all_drv_state(adapter, 1);
3809			clear_bit(__QLCNIC_AER, &adapter->state);
3810			netif_device_attach(netdev);
3811			return err;
3812		}
3813
3814		err = qlcnic_up(adapter, netdev);
3815		if (err)
3816			goto done;
3817
3818		qlcnic_restore_indev_addr(netdev, NETDEV_UP);
3819	}
3820 done:
3821	netif_device_attach(netdev);
3822	return err;
3823}
3824
3825static pci_ers_result_t qlcnic_82xx_io_error_detected(struct pci_dev *pdev,
3826						      pci_channel_state_t state)
3827{
3828	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3829	struct net_device *netdev = adapter->netdev;
3830
3831	if (state == pci_channel_io_perm_failure)
3832		return PCI_ERS_RESULT_DISCONNECT;
3833
3834	if (state == pci_channel_io_normal)
3835		return PCI_ERS_RESULT_RECOVERED;
3836
3837	set_bit(__QLCNIC_AER, &adapter->state);
3838	netif_device_detach(netdev);
3839
3840	cancel_delayed_work_sync(&adapter->fw_work);
3841
3842	if (netif_running(netdev))
3843		qlcnic_down(adapter, netdev);
3844
3845	qlcnic_detach(adapter);
3846	qlcnic_teardown_intr(adapter);
3847
3848	clear_bit(__QLCNIC_RESETTING, &adapter->state);
3849
3850	pci_save_state(pdev);
3851	pci_disable_device(pdev);
3852
3853	return PCI_ERS_RESULT_NEED_RESET;
3854}
3855
3856static pci_ers_result_t qlcnic_82xx_io_slot_reset(struct pci_dev *pdev)
3857{
3858	pci_ers_result_t res;
3859
3860	rtnl_lock();
3861	res = qlcnic_attach_func(pdev) ? PCI_ERS_RESULT_DISCONNECT :
3862					 PCI_ERS_RESULT_RECOVERED;
3863	rtnl_unlock();
3864
3865	return res;
3866}
3867
3868static void qlcnic_82xx_io_resume(struct pci_dev *pdev)
3869{
3870	u32 state;
3871	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3872
3873	state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3874	if (state == QLCNIC_DEV_READY && test_and_clear_bit(__QLCNIC_AER,
3875							    &adapter->state))
3876		qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
3877				     FW_POLL_DELAY);
3878}
3879
3880static pci_ers_result_t qlcnic_io_error_detected(struct pci_dev *pdev,
3881						 pci_channel_state_t state)
3882{
3883	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3884	struct qlcnic_hardware_ops *hw_ops = adapter->ahw->hw_ops;
3885
3886	if (hw_ops->io_error_detected) {
3887		return hw_ops->io_error_detected(pdev, state);
3888	} else {
3889		dev_err(&pdev->dev, "AER error_detected handler not registered.\n");
3890		return PCI_ERS_RESULT_DISCONNECT;
3891	}
3892}
3893
3894static pci_ers_result_t qlcnic_io_slot_reset(struct pci_dev *pdev)
3895{
3896	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3897	struct qlcnic_hardware_ops *hw_ops = adapter->ahw->hw_ops;
3898
3899	if (hw_ops->io_slot_reset) {
3900		return hw_ops->io_slot_reset(pdev);
3901	} else {
3902		dev_err(&pdev->dev, "AER slot_reset handler not registered.\n");
3903		return PCI_ERS_RESULT_DISCONNECT;
3904	}
3905}
3906
3907static void qlcnic_io_resume(struct pci_dev *pdev)
3908{
3909	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3910	struct qlcnic_hardware_ops *hw_ops = adapter->ahw->hw_ops;
3911
3912	if (hw_ops->io_resume)
3913		hw_ops->io_resume(pdev);
3914	else
3915		dev_err(&pdev->dev, "AER resume handler not registered.\n");
3916}
3917
3918
3919static int
3920qlcnicvf_start_firmware(struct qlcnic_adapter *adapter)
3921{
3922	int err;
3923
3924	err = qlcnic_can_start_firmware(adapter);
3925	if (err)
3926		return err;
3927
3928	err = qlcnic_check_npar_opertional(adapter);
3929	if (err)
3930		return err;
3931
3932	err = qlcnic_initialize_nic(adapter);
3933	if (err)
3934		return err;
3935
3936	qlcnic_check_options(adapter);
3937
3938	err = qlcnic_set_eswitch_port_config(adapter);
3939	if (err)
3940		return err;
3941
3942	adapter->need_fw_reset = 0;
3943
3944	return err;
3945}
3946
3947int qlcnic_validate_rings(struct qlcnic_adapter *adapter, __u32 ring_cnt,
3948			  int queue_type)
3949{
3950	struct net_device *netdev = adapter->netdev;
3951	char buf[8];
3952
3953	if (queue_type == QLCNIC_RX_QUEUE)
3954		strcpy(buf, "SDS");
3955	else
3956		strcpy(buf, "Tx");
3957
3958	if (!is_power_of_2(ring_cnt)) {
3959		netdev_err(netdev, "%s rings value should be a power of 2\n",
3960			   buf);
3961		return -EINVAL;
3962	}
3963
3964	if (qlcnic_82xx_check(adapter) && (queue_type == QLCNIC_TX_QUEUE) &&
3965	    !qlcnic_check_multi_tx(adapter)) {
3966			netdev_err(netdev, "No Multi Tx queue support\n");
3967			return -EINVAL;
3968	}
3969
3970	if (ring_cnt > num_online_cpus()) {
3971		netdev_err(netdev,
3972			   "%s value[%u] should not be higher than, number of online CPUs\n",
3973			   buf, num_online_cpus());
3974		return -EINVAL;
3975	}
3976
3977	return 0;
3978}
3979
3980int qlcnic_setup_rings(struct qlcnic_adapter *adapter)
3981{
3982	struct net_device *netdev = adapter->netdev;
3983	u8 tx_rings, rx_rings;
3984	int err;
3985
3986	if (test_bit(__QLCNIC_RESETTING, &adapter->state))
3987		return -EBUSY;
3988
3989	tx_rings = adapter->drv_tss_rings;
3990	rx_rings = adapter->drv_rss_rings;
3991
3992	netif_device_detach(netdev);
3993
3994	err = qlcnic_set_real_num_queues(adapter, tx_rings, rx_rings);
3995	if (err)
3996		goto done;
3997
3998	if (netif_running(netdev))
3999		__qlcnic_down(adapter, netdev);
4000
4001	qlcnic_detach(adapter);
4002
4003	if (qlcnic_83xx_check(adapter)) {
4004		qlcnic_83xx_free_mbx_intr(adapter);
4005		qlcnic_83xx_enable_mbx_poll(adapter);
4006	}
4007
4008	qlcnic_teardown_intr(adapter);
4009
4010	err = qlcnic_setup_intr(adapter);
4011	if (err) {
4012		kfree(adapter->msix_entries);
4013		netdev_err(netdev, "failed to setup interrupt\n");
4014		return err;
4015	}
4016
4017	/* Check if we need to update real_num_{tx|rx}_queues because
4018	 * qlcnic_setup_intr() may change Tx/Rx rings size
4019	 */
4020	if ((tx_rings != adapter->drv_tx_rings) ||
4021	    (rx_rings != adapter->drv_sds_rings)) {
4022		err = qlcnic_set_real_num_queues(adapter,
4023						 adapter->drv_tx_rings,
4024						 adapter->drv_sds_rings);
4025		if (err)
4026			goto done;
4027	}
4028
4029	if (qlcnic_83xx_check(adapter)) {
4030		qlcnic_83xx_initialize_nic(adapter, 1);
4031		err = qlcnic_83xx_setup_mbx_intr(adapter);
4032		qlcnic_83xx_disable_mbx_poll(adapter);
4033		if (err) {
4034			dev_err(&adapter->pdev->dev,
4035				"failed to setup mbx interrupt\n");
4036			goto done;
4037		}
4038	}
4039
4040	if (netif_running(netdev)) {
4041		err = qlcnic_attach(adapter);
4042		if (err)
4043			goto done;
4044		err = __qlcnic_up(adapter, netdev);
4045		if (err)
4046			goto done;
4047		qlcnic_restore_indev_addr(netdev, NETDEV_UP);
4048	}
4049done:
4050	netif_device_attach(netdev);
4051	clear_bit(__QLCNIC_RESETTING, &adapter->state);
4052	return err;
4053}
4054
4055#ifdef CONFIG_INET
4056
4057#define is_qlcnic_netdev(dev) (dev->netdev_ops == &qlcnic_netdev_ops)
4058
4059static void
4060qlcnic_config_indev_addr(struct qlcnic_adapter *adapter,
4061			struct net_device *dev, unsigned long event)
4062{
4063	const struct in_ifaddr *ifa;
4064	struct in_device *indev;
4065
4066	indev = in_dev_get(dev);
4067	if (!indev)
4068		return;
4069
4070	in_dev_for_each_ifa_rtnl(ifa, indev) {
4071		switch (event) {
4072		case NETDEV_UP:
4073			qlcnic_config_ipaddr(adapter,
4074					ifa->ifa_address, QLCNIC_IP_UP);
4075			break;
4076		case NETDEV_DOWN:
4077			qlcnic_config_ipaddr(adapter,
4078					ifa->ifa_address, QLCNIC_IP_DOWN);
4079			break;
4080		default:
4081			break;
4082		}
4083	}
4084
4085	in_dev_put(indev);
4086}
4087
4088void qlcnic_restore_indev_addr(struct net_device *netdev, unsigned long event)
4089{
4090	struct qlcnic_adapter *adapter = netdev_priv(netdev);
4091	struct net_device *dev;
4092	u16 vid;
4093
4094	qlcnic_config_indev_addr(adapter, netdev, event);
4095
4096	rcu_read_lock();
4097	for_each_set_bit(vid, adapter->vlans, VLAN_N_VID) {
4098		dev = __vlan_find_dev_deep_rcu(netdev, htons(ETH_P_8021Q), vid);
4099		if (!dev)
4100			continue;
4101		qlcnic_config_indev_addr(adapter, dev, event);
4102	}
4103	rcu_read_unlock();
4104}
4105
4106static int qlcnic_netdev_event(struct notifier_block *this,
4107				 unsigned long event, void *ptr)
4108{
4109	struct qlcnic_adapter *adapter;
4110	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
4111
4112recheck:
4113	if (dev == NULL)
4114		goto done;
4115
4116	if (is_vlan_dev(dev)) {
4117		dev = vlan_dev_real_dev(dev);
4118		goto recheck;
4119	}
4120
4121	if (!is_qlcnic_netdev(dev))
4122		goto done;
4123
4124	adapter = netdev_priv(dev);
4125
4126	if (!adapter)
4127		goto done;
4128
4129	if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
4130		goto done;
4131
4132	qlcnic_config_indev_addr(adapter, dev, event);
4133done:
4134	return NOTIFY_DONE;
4135}
4136
4137static int
4138qlcnic_inetaddr_event(struct notifier_block *this,
4139		unsigned long event, void *ptr)
4140{
4141	struct qlcnic_adapter *adapter;
4142	struct net_device *dev;
4143
4144	struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
4145
4146	dev = ifa->ifa_dev->dev;
4147
4148recheck:
4149	if (dev == NULL)
4150		goto done;
4151
4152	if (is_vlan_dev(dev)) {
4153		dev = vlan_dev_real_dev(dev);
4154		goto recheck;
4155	}
4156
4157	if (!is_qlcnic_netdev(dev))
4158		goto done;
4159
4160	adapter = netdev_priv(dev);
4161
4162	if (!adapter)
4163		goto done;
4164
4165	if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
4166		goto done;
4167
4168	switch (event) {
4169	case NETDEV_UP:
4170		qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_UP);
4171
4172		break;
4173	case NETDEV_DOWN:
4174		qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_DOWN);
4175
4176		break;
4177	default:
4178		break;
4179	}
4180
4181done:
4182	return NOTIFY_DONE;
4183}
4184
4185static struct notifier_block	qlcnic_netdev_cb = {
4186	.notifier_call = qlcnic_netdev_event,
4187};
4188
4189static struct notifier_block qlcnic_inetaddr_cb = {
4190	.notifier_call = qlcnic_inetaddr_event,
4191};
4192#else
4193void qlcnic_restore_indev_addr(struct net_device *dev, unsigned long event)
4194{ }
4195#endif
4196static const struct pci_error_handlers qlcnic_err_handler = {
4197	.error_detected = qlcnic_io_error_detected,
4198	.slot_reset = qlcnic_io_slot_reset,
4199	.resume = qlcnic_io_resume,
4200};
4201
4202static SIMPLE_DEV_PM_OPS(qlcnic_pm_ops, qlcnic_suspend, qlcnic_resume);
4203
4204static struct pci_driver qlcnic_driver = {
4205	.name = qlcnic_driver_name,
4206	.id_table = qlcnic_pci_tbl,
4207	.probe = qlcnic_probe,
4208	.remove = qlcnic_remove,
4209	.driver.pm = &qlcnic_pm_ops,
4210	.shutdown = qlcnic_shutdown,
4211	.err_handler = &qlcnic_err_handler,
4212#ifdef CONFIG_QLCNIC_SRIOV
4213	.sriov_configure = qlcnic_pci_sriov_configure,
4214#endif
4215
4216};
4217
4218static int __init qlcnic_init_module(void)
4219{
4220	int ret;
4221
4222	printk(KERN_INFO "%s\n", qlcnic_driver_string);
4223
4224#ifdef CONFIG_INET
4225	register_netdevice_notifier(&qlcnic_netdev_cb);
4226	register_inetaddr_notifier(&qlcnic_inetaddr_cb);
4227#endif
4228
4229	ret = pci_register_driver(&qlcnic_driver);
4230	if (ret) {
4231#ifdef CONFIG_INET
4232		unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
4233		unregister_netdevice_notifier(&qlcnic_netdev_cb);
4234#endif
4235	}
4236
4237	return ret;
4238}
4239
4240module_init(qlcnic_init_module);
4241
4242static void __exit qlcnic_exit_module(void)
4243{
4244	pci_unregister_driver(&qlcnic_driver);
4245
4246#ifdef CONFIG_INET
4247	unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
4248	unregister_netdevice_notifier(&qlcnic_netdev_cb);
4249#endif
4250}
4251
4252module_exit(qlcnic_exit_module);