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