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