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