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