Lines Matching refs:adapter
61 static void qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding);
62 static int qlcnic_can_start_firmware(struct qlcnic_adapter *adapter);
73 static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter);
88 static u32 qlcnic_vlan_tx_check(struct qlcnic_adapter *adapter)
90 struct qlcnic_hardware_context *ahw = adapter->ahw;
92 if (adapter->pdev->device == PCI_DEVICE_ID_QLOGIC_QLE824X)
294 int qlcnic_read_mac_addr(struct qlcnic_adapter *adapter)
296 struct net_device *netdev = adapter->netdev;
297 struct pci_dev *pdev = adapter->pdev;
301 ret = qlcnic_get_mac_address(adapter, mac_addr,
302 adapter->ahw->pci_func);
307 memcpy(adapter->mac_addr, netdev->dev_addr, netdev->addr_len);
318 static void qlcnic_delete_adapter_mac(struct qlcnic_adapter *adapter)
322 list_for_each_entry(cur, &adapter->mac_list, list) {
323 if (ether_addr_equal_unaligned(adapter->mac_addr, cur->mac_addr)) {
324 qlcnic_sre_macaddr_change(adapter, cur->mac_addr,
335 struct qlcnic_adapter *adapter = netdev_priv(netdev);
338 if (qlcnic_sriov_vf_check(adapter))
341 if ((adapter->flags & QLCNIC_MAC_OVERRIDE_DISABLED))
347 if (ether_addr_equal_unaligned(adapter->mac_addr, addr->sa_data) &&
351 if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
353 qlcnic_napi_disable(adapter);
356 qlcnic_delete_adapter_mac(adapter);
357 memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
359 qlcnic_set_multi(adapter->netdev);
361 if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
363 qlcnic_napi_enable(adapter);
373 struct qlcnic_adapter *adapter = netdev_priv(netdev);
376 if (!adapter->fdb_mac_learn)
379 if ((adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
380 qlcnic_sriov_check(adapter)) {
384 err = qlcnic_nic_del_mac(adapter, addr);
399 struct qlcnic_adapter *adapter = netdev_priv(netdev);
402 if (!adapter->fdb_mac_learn)
405 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED) &&
406 !qlcnic_sriov_check(adapter)) {
411 if (ether_addr_equal(addr, adapter->mac_addr))
415 if (netdev_uc_count(netdev) < adapter->ahw->max_uc_count)
432 struct qlcnic_adapter *adapter = netdev_priv(netdev);
435 if (!adapter->fdb_mac_learn)
438 if ((adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
439 qlcnic_sriov_check(adapter))
445 static void qlcnic_82xx_cancel_idc_work(struct qlcnic_adapter *adapter)
447 while (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
450 if (!adapter->fw_work.work.func)
453 cancel_delayed_work_sync(&adapter->fw_work);
459 struct qlcnic_adapter *adapter = netdev_priv(netdev);
460 struct qlcnic_hardware_context *ahw = adapter->ahw;
462 if (!(adapter->flags & QLCNIC_HAS_PHYS_PORT_ID))
473 struct qlcnic_adapter *adapter = netdev_priv(dev);
479 err = qlcnic_set_vxlan_port(adapter, ntohs(ti.port));
484 return qlcnic_set_vxlan_parsing(adapter, ntohs(ti.port));
610 static int qlcnic_check_multi_tx_capability(struct qlcnic_adapter *adapter)
612 struct qlcnic_hardware_context *ahw = adapter->ahw;
614 if (qlcnic_82xx_check(adapter) &&
616 test_and_set_bit(__QLCNIC_MULTI_TX_UNIQUE, &adapter->state);
623 static int qlcnic_max_rings(struct qlcnic_adapter *adapter, u8 ring_cnt,
629 max_rings = adapter->max_sds_rings;
631 max_rings = adapter->max_tx_rings;
642 void qlcnic_set_tx_ring_count(struct qlcnic_adapter *adapter, u8 tx_cnt)
644 /* 83xx adapter does not have max_tx_rings intialized in probe */
645 if (adapter->max_tx_rings)
646 adapter->drv_tx_rings = qlcnic_max_rings(adapter, tx_cnt,
649 adapter->drv_tx_rings = tx_cnt;
652 void qlcnic_set_sds_ring_count(struct qlcnic_adapter *adapter, u8 rx_cnt)
654 /* 83xx adapter does not have max_sds_rings intialized in probe */
655 if (adapter->max_sds_rings)
656 adapter->drv_sds_rings = qlcnic_max_rings(adapter, rx_cnt,
659 adapter->drv_sds_rings = rx_cnt;
662 int qlcnic_setup_tss_rss_intr(struct qlcnic_adapter *adapter)
664 struct pci_dev *pdev = adapter->pdev;
667 adapter->flags &= ~QLCNIC_TSS_RSS;
669 if (adapter->drv_tss_rings > 0)
670 num_msix += adapter->drv_tss_rings;
672 num_msix += adapter->drv_tx_rings;
674 if (adapter->drv_rss_rings > 0)
675 num_msix += adapter->drv_rss_rings;
677 num_msix += adapter->drv_sds_rings;
679 if (qlcnic_83xx_check(adapter))
682 if (!adapter->msix_entries) {
683 adapter->msix_entries = kcalloc(num_msix,
686 if (!adapter->msix_entries)
691 adapter->msix_entries[vector].entry = vector;
694 err = pci_enable_msix_exact(pdev, adapter->msix_entries, num_msix);
696 if (!adapter->drv_tss_rings && !adapter->drv_rss_rings)
699 netdev_info(adapter->netdev,
703 num_msix = adapter->drv_tx_rings + adapter->drv_sds_rings;
706 adapter->drv_tss_rings = 0;
707 adapter->drv_rss_rings = 0;
709 if (qlcnic_83xx_check(adapter))
712 netdev_info(adapter->netdev,
714 adapter->drv_tx_rings, adapter->drv_sds_rings,
722 adapter->ahw->num_msix = num_msix;
723 if (adapter->drv_tss_rings > 0)
724 adapter->drv_tx_rings = adapter->drv_tss_rings;
726 if (adapter->drv_rss_rings > 0)
727 adapter->drv_sds_rings = adapter->drv_rss_rings;
732 int qlcnic_enable_msix(struct qlcnic_adapter *adapter, u32 num_msix)
734 struct pci_dev *pdev = adapter->pdev;
737 if (!adapter->msix_entries) {
738 adapter->msix_entries = kcalloc(num_msix,
741 if (!adapter->msix_entries)
745 adapter->flags &= ~(QLCNIC_MSI_ENABLED | QLCNIC_MSIX_ENABLED);
747 if (adapter->ahw->msix_supported) {
750 adapter->msix_entries[vector].entry = vector;
753 adapter->msix_entries, 1, num_msix);
756 adapter->flags |= QLCNIC_MSIX_ENABLED;
757 adapter->ahw->num_msix = num_msix;
767 if (qlcnic_82xx_check(adapter)) {
778 if (qlcnic_82xx_check(adapter) &&
779 !qlcnic_check_multi_tx(adapter)) {
780 adapter->drv_sds_rings = num_msix;
781 adapter->drv_tx_rings = QLCNIC_SINGLE_RING;
784 adapter->drv_tx_rings = num_msix / 2;
785 adapter->drv_sds_rings = adapter->drv_tx_rings;
805 static int qlcnic_82xx_calculate_msix_vector(struct qlcnic_adapter *adapter)
809 num_msix = adapter->drv_sds_rings;
811 if (qlcnic_check_multi_tx(adapter))
812 num_msix += adapter->drv_tx_rings;
819 static int qlcnic_enable_msi_legacy(struct qlcnic_adapter *adapter)
824 struct qlcnic_hardware_context *ahw = adapter->ahw;
825 struct pci_dev *pdev = adapter->pdev;
828 adapter->flags |= QLCNIC_MSI_ENABLED;
829 offset = msi_tgt_status[adapter->ahw->pci_func];
830 adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter->ahw,
833 adapter->msix_entries[0].vector = pdev->irq;
840 legacy_intrp = &legacy_intr[adapter->ahw->pci_func];
841 adapter->ahw->int_vec_bit = legacy_intrp->int_vec_bit;
843 adapter->tgt_status_reg = qlcnic_get_ioaddr(ahw, offset);
845 adapter->tgt_mask_reg = qlcnic_get_ioaddr(ahw, mask_reg);
846 adapter->isr_int_vec = qlcnic_get_ioaddr(ahw, ISR_INT_VECTOR);
847 adapter->crb_int_state_reg = qlcnic_get_ioaddr(ahw, ISR_INT_STATE_REG);
849 adapter->msix_entries[0].vector = pdev->irq;
853 static int qlcnic_82xx_setup_intr(struct qlcnic_adapter *adapter)
857 if (adapter->flags & QLCNIC_TSS_RSS) {
858 err = qlcnic_setup_tss_rss_intr(adapter);
861 num_msix = adapter->ahw->num_msix;
863 num_msix = qlcnic_82xx_calculate_msix_vector(adapter);
865 err = qlcnic_enable_msix(adapter, num_msix);
869 if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
870 qlcnic_disable_multi_tx(adapter);
871 adapter->drv_sds_rings = QLCNIC_SINGLE_RING;
873 err = qlcnic_enable_msi_legacy(adapter);
882 int qlcnic_82xx_mq_intrpt(struct qlcnic_adapter *adapter, int op_type)
884 struct qlcnic_hardware_context *ahw = adapter->ahw;
887 if (qlcnic_check_multi_tx(adapter) &&
889 (adapter->flags & QLCNIC_MSIX_ENABLED)) {
902 err = qlcnic_82xx_config_intrpt(adapter, 1);
904 dev_err(&adapter->pdev->dev,
913 void qlcnic_teardown_intr(struct qlcnic_adapter *adapter)
915 if (adapter->flags & QLCNIC_MSIX_ENABLED)
916 pci_disable_msix(adapter->pdev);
917 if (adapter->flags & QLCNIC_MSI_ENABLED)
918 pci_disable_msi(adapter->pdev);
920 kfree(adapter->msix_entries);
921 adapter->msix_entries = NULL;
923 if (adapter->ahw->intr_tbl) {
924 vfree(adapter->ahw->intr_tbl);
925 adapter->ahw->intr_tbl = NULL;
935 static int qlcnic_get_act_pci_func(struct qlcnic_adapter *adapter)
937 struct qlcnic_hardware_context *ahw = adapter->ahw;
941 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
960 ret = qlcnic_get_pci_info(adapter, pci_info);
965 static bool qlcnic_port_eswitch_cfg_capability(struct qlcnic_adapter *adapter)
969 if (qlcnic_84xx_check(adapter)) {
971 } else if (qlcnic_83xx_check(adapter)) {
972 if (adapter->ahw->extra_capability[0] &
982 int qlcnic_init_pci_info(struct qlcnic_adapter *adapter)
984 struct qlcnic_hardware_context *ahw = adapter->ahw;
994 ret = qlcnic_get_pci_info(adapter, pci_info);
1000 adapter->npars = kcalloc(act_pci_func,
1003 if (!adapter->npars) {
1008 adapter->eswitch = kcalloc(QLCNIC_NIU_MAX_XG_PORTS,
1011 if (!adapter->eswitch) {
1021 dev_err(&adapter->pdev->dev, "%s: Invalid function 0x%x, max 0x%x\n",
1030 if (qlcnic_port_eswitch_cfg_capability(adapter)) {
1031 if (!qlcnic_83xx_set_port_eswitch_status(adapter, pfn,
1033 adapter->npars[j].eswitch_status = true;
1037 adapter->npars[j].eswitch_status = true;
1040 adapter->npars[j].pci_func = pfn;
1041 adapter->npars[j].active = (u8)pci_info[i].active;
1042 adapter->npars[j].type = (u8)pci_info[i].type;
1043 adapter->npars[j].phy_port = (u8)pci_info[i].default_port;
1044 adapter->npars[j].min_bw = pci_info[i].tx_min_bw;
1045 adapter->npars[j].max_bw = pci_info[i].tx_max_bw;
1047 memcpy(&adapter->npars[j].mac, &pci_info[i].mac, ETH_ALEN);
1054 if (!qlcnic_port_eswitch_cfg_capability(adapter)) {
1056 adapter->eswitch[i].flags |= QLCNIC_SWITCH_ENABLE;
1063 kfree(adapter->eswitch);
1064 adapter->eswitch = NULL;
1066 kfree(adapter->npars);
1067 adapter->npars = NULL;
1075 qlcnic_set_function_modes(struct qlcnic_adapter *adapter)
1080 struct qlcnic_hardware_context *ahw = adapter->ahw;
1082 ret = qlcnic_api_lock(adapter);
1087 data = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
1090 QLC_SHARED_REG_WR32(adapter, QLCNIC_DRV_OP_MODE, data);
1091 qlcnic_api_unlock(adapter);
1096 static void qlcnic_check_vf(struct qlcnic_adapter *adapter,
1102 adapter->ahw->fw_hal_version = QLC_SHARED_REG_RD32(adapter,
1106 qlcnic_get_func_no(adapter);
1109 op_mode = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
1113 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
1116 adapter->ahw->op_mode = QLCNIC_NON_PRIV_FUNC;
1117 dev_info(&adapter->pdev->dev,
1119 adapter->ahw->fw_hal_version);
1120 adapter->nic_ops = &qlcnic_vf_ops;
1122 adapter->nic_ops = &qlcnic_ops;
1179 static bool qlcnic_validate_subsystem_id(struct qlcnic_adapter *adapter,
1182 struct pci_dev *pdev = adapter->pdev;
1200 static void qlcnic_get_board_name(struct qlcnic_adapter *adapter, char *name)
1202 struct pci_dev *pdev = adapter->pdev;
1208 qlcnic_validate_subsystem_id(adapter, i)) {
1215 sprintf(name, "%pM Gigabit Ethernet", adapter->mac_addr);
1217 sprintf(name, "%pM: %s" , adapter->mac_addr,
1222 qlcnic_check_options(struct qlcnic_adapter *adapter)
1226 struct pci_dev *pdev = adapter->pdev;
1227 struct qlcnic_hardware_context *ahw = adapter->ahw;
1230 prev_fw_version = adapter->fw_version;
1232 fw_major = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MAJOR);
1233 fw_minor = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MINOR);
1234 fw_build = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_SUB);
1236 adapter->fw_version = QLCNIC_VERSION_CODE(fw_major, fw_minor, fw_build);
1238 err = qlcnic_get_board_info(adapter);
1245 adapter->fw_version > prev_fw_version) {
1247 if (!qlcnic_fw_cmd_get_minidump_temp(adapter))
1256 if (adapter->ahw->port_type == QLCNIC_XGBE) {
1257 if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
1258 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_VF;
1259 adapter->max_rxd = MAX_RCV_DESCRIPTORS_VF;
1261 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
1262 adapter->max_rxd = MAX_RCV_DESCRIPTORS_10G;
1265 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
1266 adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
1268 } else if (adapter->ahw->port_type == QLCNIC_GBE) {
1269 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
1270 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
1271 adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
1272 adapter->max_rxd = MAX_RCV_DESCRIPTORS_1G;
1275 adapter->ahw->msix_supported = !!qlcnic_use_msi_x;
1277 adapter->num_txd = MAX_CMD_DESCRIPTORS;
1279 adapter->max_rds_rings = MAX_RDS_RINGS;
1283 qlcnic_initialize_nic(struct qlcnic_adapter *adapter)
1289 err = qlcnic_get_nic_info(adapter, &nic_info, adapter->ahw->pci_func);
1293 adapter->ahw->physical_port = (u8)nic_info.phys_port;
1294 adapter->ahw->switch_mode = nic_info.switch_mode;
1295 adapter->ahw->max_tx_ques = nic_info.max_tx_ques;
1296 adapter->ahw->max_rx_ques = nic_info.max_rx_ques;
1297 adapter->ahw->capabilities = nic_info.capabilities;
1299 if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_MORE_CAPS) {
1301 temp = QLCRD32(adapter, CRB_FW_CAPABILITIES_2, &err);
1304 adapter->ahw->extra_capability[0] = temp;
1306 adapter->ahw->extra_capability[0] = 0;
1309 adapter->ahw->max_mac_filters = nic_info.max_mac_filters;
1310 adapter->ahw->max_mtu = nic_info.max_mtu;
1312 if (adapter->ahw->capabilities & BIT_6) {
1313 adapter->flags |= QLCNIC_ESWITCH_ENABLED;
1314 adapter->ahw->nic_mode = QLCNIC_VNIC_MODE;
1315 adapter->max_tx_rings = QLCNIC_MAX_HW_VNIC_TX_RINGS;
1316 adapter->max_sds_rings = QLCNIC_MAX_VNIC_SDS_RINGS;
1318 dev_info(&adapter->pdev->dev, "vNIC mode enabled.\n");
1320 adapter->ahw->nic_mode = QLCNIC_DEFAULT_MODE;
1321 adapter->max_tx_rings = QLCNIC_MAX_HW_TX_RINGS;
1322 adapter->max_sds_rings = QLCNIC_MAX_SDS_RINGS;
1323 adapter->flags &= ~QLCNIC_ESWITCH_ENABLED;
1329 void qlcnic_set_vlan_config(struct qlcnic_adapter *adapter,
1333 adapter->flags &= ~QLCNIC_TAGGING_ENABLED;
1335 adapter->flags |= QLCNIC_TAGGING_ENABLED;
1338 adapter->rx_pvid = esw_cfg->vlan_id;
1339 adapter->tx_pvid = esw_cfg->vlan_id;
1341 adapter->rx_pvid = 0;
1342 adapter->tx_pvid = 0;
1349 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1352 if (qlcnic_sriov_vf_check(adapter)) {
1353 err = qlcnic_sriov_cfg_vf_guest_vlan(adapter, vid, 1);
1362 set_bit(vid, adapter->vlans);
1369 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1372 if (qlcnic_sriov_vf_check(adapter)) {
1373 err = qlcnic_sriov_cfg_vf_guest_vlan(adapter, vid, 0);
1383 clear_bit(vid, adapter->vlans);
1387 void qlcnic_set_eswitch_port_features(struct qlcnic_adapter *adapter,
1390 adapter->flags &= ~(QLCNIC_MACSPOOF | QLCNIC_MAC_OVERRIDE_DISABLED |
1394 adapter->flags |= QLCNIC_MACSPOOF;
1397 adapter->flags |= QLCNIC_MAC_OVERRIDE_DISABLED;
1400 adapter->flags |= QLCNIC_PROMISC_DISABLED;
1403 int qlcnic_set_eswitch_port_config(struct qlcnic_adapter *adapter)
1407 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
1410 esw_cfg.pci_func = adapter->ahw->pci_func;
1411 if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg))
1413 qlcnic_set_vlan_config(adapter, &esw_cfg);
1414 qlcnic_set_eswitch_port_features(adapter, &esw_cfg);
1415 qlcnic_set_netdev_features(adapter, &esw_cfg);
1420 void qlcnic_set_netdev_features(struct qlcnic_adapter *adapter,
1423 struct net_device *netdev = adapter->netdev;
1425 if (qlcnic_83xx_check(adapter))
1428 adapter->offload_flags = esw_cfg->offload_flags;
1429 adapter->flags |= QLCNIC_APP_CHANGED_FLAGS;
1431 adapter->flags &= ~QLCNIC_APP_CHANGED_FLAGS;
1435 qlcnic_check_eswitch_mode(struct qlcnic_adapter *adapter)
1440 err = qlcnic_initialize_nic(adapter);
1444 if (adapter->flags & QLCNIC_ADAPTER_INITIALIZED)
1447 op_mode = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
1448 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
1453 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
1455 if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
1457 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
1458 err = qlcnic_init_pci_info(adapter);
1462 qlcnic_set_function_modes(adapter);
1463 dev_info(&adapter->pdev->dev,
1465 adapter->ahw->fw_hal_version);
1467 adapter->ahw->op_mode = QLCNIC_PRIV_FUNC;
1468 dev_info(&adapter->pdev->dev,
1470 adapter->ahw->fw_hal_version);
1473 adapter->ahw->nic_mode = QLCNIC_DEFAULT_MODE;
1476 adapter->flags |= QLCNIC_ADAPTER_INITIALIZED;
1481 int qlcnic_set_default_offload_settings(struct qlcnic_adapter *adapter)
1487 if (adapter->need_fw_reset)
1490 for (i = 0; i < adapter->ahw->total_nic_func; i++) {
1491 if (!adapter->npars[i].eswitch_status)
1495 esw_cfg.pci_func = adapter->npars[i].pci_func;
1498 if (qlcnic_82xx_check(adapter)) {
1500 if (QLCNIC_IS_TSO_CAPABLE(adapter))
1503 if (qlcnic_config_switch_port(adapter, &esw_cfg))
1505 npar = &adapter->npars[i];
1519 qlcnic_reset_eswitch_config(struct qlcnic_adapter *adapter,
1531 if (qlcnic_config_switch_port(adapter, &esw_cfg))
1535 if (qlcnic_config_switch_port(adapter, &esw_cfg))
1541 int qlcnic_reset_npar_config(struct qlcnic_adapter *adapter)
1548 if (qlcnic_82xx_check(adapter))
1549 if (!adapter->need_fw_reset)
1553 for (i = 0; i < adapter->ahw->total_nic_func; i++) {
1554 npar = &adapter->npars[i];
1556 if (!adapter->npars[i].eswitch_status)
1560 err = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
1565 err = qlcnic_set_nic_info(adapter, &nic_info);
1570 err = qlcnic_config_port_mirroring(adapter,
1576 err = qlcnic_reset_eswitch_config(adapter, npar, pci_func);
1583 static int qlcnic_check_npar_opertional(struct qlcnic_adapter *adapter)
1588 if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
1591 npar_state = QLC_SHARED_REG_RD32(adapter,
1595 npar_state = QLC_SHARED_REG_RD32(adapter,
1599 dev_err(&adapter->pdev->dev,
1607 qlcnic_set_mgmt_operations(struct qlcnic_adapter *adapter)
1611 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
1612 adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
1615 err = qlcnic_set_default_offload_settings(adapter);
1619 err = qlcnic_reset_npar_config(adapter);
1623 qlcnic_dev_set_npar_ready(adapter);
1628 static int qlcnic_82xx_start_firmware(struct qlcnic_adapter *adapter)
1632 err = qlcnic_can_start_firmware(adapter);
1639 qlcnic_request_firmware(adapter);
1641 err = qlcnic_check_flash_fw_ver(adapter);
1645 adapter->ahw->fw_type = QLCNIC_FLASH_ROMIMAGE;
1648 err = qlcnic_need_fw_reset(adapter);
1652 err = qlcnic_pinit_from_rom(adapter);
1656 err = qlcnic_load_firmware(adapter);
1660 qlcnic_release_firmware(adapter);
1661 QLCWR32(adapter, CRB_DRIVER_VERSION, QLCNIC_DRIVER_VERSION);
1664 err = qlcnic_check_fw_status(adapter);
1668 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_READY);
1669 qlcnic_idc_debug_info(adapter, 1);
1670 err = qlcnic_check_eswitch_mode(adapter);
1672 dev_err(&adapter->pdev->dev,
1676 err = qlcnic_set_mgmt_operations(adapter);
1680 qlcnic_check_options(adapter);
1681 adapter->need_fw_reset = 0;
1683 qlcnic_release_firmware(adapter);
1687 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_FAILED);
1688 dev_err(&adapter->pdev->dev, "Device state set to failed\n");
1690 qlcnic_release_firmware(adapter);
1695 qlcnic_request_irq(struct qlcnic_adapter *adapter)
1703 struct net_device *netdev = adapter->netdev;
1704 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1706 if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
1707 if (qlcnic_82xx_check(adapter))
1711 if (!QLCNIC_IS_MSI_FAMILY(adapter))
1715 if (adapter->flags & QLCNIC_MSIX_ENABLED)
1717 else if (adapter->flags & QLCNIC_MSI_ENABLED)
1721 if (qlcnic_82xx_check(adapter))
1727 adapter->irq = netdev->irq;
1729 if (adapter->ahw->diag_test != QLCNIC_LOOPBACK_TEST) {
1730 if (qlcnic_82xx_check(adapter) ||
1731 (qlcnic_83xx_check(adapter) &&
1732 (adapter->flags & QLCNIC_MSIX_ENABLED))) {
1733 num_sds_rings = adapter->drv_sds_rings;
1736 if (qlcnic_82xx_check(adapter) &&
1737 !qlcnic_check_multi_tx(adapter) &&
1739 if (!(adapter->flags &
1761 if ((qlcnic_82xx_check(adapter) &&
1762 qlcnic_check_multi_tx(adapter)) ||
1763 (qlcnic_83xx_check(adapter) &&
1764 (adapter->flags & QLCNIC_MSIX_ENABLED) &&
1765 !(adapter->flags & QLCNIC_TX_INTR_SHARED))) {
1767 for (ring = 0; ring < adapter->drv_tx_rings;
1769 tx_ring = &adapter->tx_ring[ring];
1783 qlcnic_free_irq(struct qlcnic_adapter *adapter)
1789 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1791 if (adapter->ahw->diag_test != QLCNIC_LOOPBACK_TEST) {
1792 if (qlcnic_82xx_check(adapter) ||
1793 (qlcnic_83xx_check(adapter) &&
1794 (adapter->flags & QLCNIC_MSIX_ENABLED))) {
1795 for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
1800 if ((qlcnic_83xx_check(adapter) &&
1801 !(adapter->flags & QLCNIC_TX_INTR_SHARED)) ||
1802 (qlcnic_82xx_check(adapter) &&
1803 qlcnic_check_multi_tx(adapter))) {
1804 for (ring = 0; ring < adapter->drv_tx_rings;
1806 tx_ring = &adapter->tx_ring[ring];
1814 static void qlcnic_get_lro_mss_capability(struct qlcnic_adapter *adapter)
1818 if (qlcnic_82xx_check(adapter)) {
1819 if (adapter->ahw->extra_capability[0] &
1821 adapter->flags |= QLCNIC_FW_LRO_MSS_CAP;
1823 capab = adapter->ahw->capabilities;
1825 adapter->flags |= QLCNIC_FW_LRO_MSS_CAP;
1829 static int qlcnic_config_def_intr_coalesce(struct qlcnic_adapter *adapter)
1831 struct qlcnic_hardware_context *ahw = adapter->ahw;
1837 if (qlcnic_83xx_check(adapter)) {
1844 err = qlcnic_83xx_set_rx_tx_intr_coal(adapter);
1850 err = qlcnic_82xx_set_rx_coalesce(adapter);
1856 int __qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
1861 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1864 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
1867 if (qlcnic_set_eswitch_port_config(adapter))
1870 qlcnic_get_lro_mss_capability(adapter);
1872 if (qlcnic_fw_create_ctx(adapter))
1875 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1876 rds_ring = &adapter->recv_ctx->rds_rings[ring];
1877 qlcnic_post_rx_buffers(adapter, rds_ring, ring);
1881 qlcnic_fw_cmd_set_mtu(adapter, netdev->mtu);
1883 adapter->ahw->linkup = 0;
1885 if (adapter->drv_sds_rings > 1)
1886 qlcnic_config_rss(adapter, 1);
1888 qlcnic_config_def_intr_coalesce(adapter);
1891 qlcnic_config_hw_lro(adapter, QLCNIC_LRO_ENABLED);
1893 set_bit(__QLCNIC_DEV_UP, &adapter->state);
1894 qlcnic_napi_enable(adapter);
1896 qlcnic_linkevent_request(adapter, 1);
1898 adapter->ahw->reset_context = 0;
1903 int qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
1909 err = __qlcnic_up(adapter, netdev);
1915 void __qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1919 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1922 if (!test_and_clear_bit(__QLCNIC_DEV_UP, &adapter->state))
1927 adapter->ahw->linkup = 0;
1930 qlcnic_free_mac_list(adapter);
1932 if (adapter->fhash.fnum)
1933 qlcnic_delete_lb_filters(adapter);
1935 qlcnic_nic_set_promisc(adapter, QLCNIC_NIU_NON_PROMISC_MODE);
1936 if (qlcnic_sriov_vf_check(adapter))
1937 qlcnic_sriov_cleanup_async_list(&adapter->ahw->sriov->bc);
1939 qlcnic_napi_disable(adapter);
1941 qlcnic_fw_destroy_ctx(adapter);
1942 adapter->flags &= ~QLCNIC_FW_LRO_MSS_CAP;
1944 qlcnic_reset_rx_buffers_list(adapter);
1946 for (ring = 0; ring < adapter->drv_tx_rings; ring++)
1947 qlcnic_release_tx_buffers(adapter, &adapter->tx_ring[ring]);
1952 void qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1956 __qlcnic_down(adapter, netdev);
1962 qlcnic_attach(struct qlcnic_adapter *adapter)
1964 struct net_device *netdev = adapter->netdev;
1965 struct pci_dev *pdev = adapter->pdev;
1968 if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC)
1971 err = qlcnic_napi_add(adapter, netdev);
1975 err = qlcnic_alloc_sw_resources(adapter);
1981 err = qlcnic_alloc_hw_resources(adapter);
1987 err = qlcnic_request_irq(adapter);
1993 qlcnic_create_sysfs_entries(adapter);
1995 if (qlcnic_encap_rx_offload(adapter))
1998 adapter->is_up = QLCNIC_ADAPTER_UP_MAGIC;
2002 qlcnic_free_hw_resources(adapter);
2004 qlcnic_free_sw_resources(adapter);
2006 qlcnic_napi_del(adapter);
2010 void qlcnic_detach(struct qlcnic_adapter *adapter)
2012 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
2015 qlcnic_remove_sysfs_entries(adapter);
2017 qlcnic_free_hw_resources(adapter);
2018 qlcnic_release_rx_buffers(adapter);
2019 qlcnic_free_irq(adapter);
2020 qlcnic_napi_del(adapter);
2021 qlcnic_free_sw_resources(adapter);
2023 adapter->is_up = 0;
2028 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2030 int drv_tx_rings = adapter->drv_tx_rings;
2033 clear_bit(__QLCNIC_DEV_UP, &adapter->state);
2034 if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
2035 for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
2036 sds_ring = &adapter->recv_ctx->sds_rings[ring];
2037 qlcnic_disable_sds_intr(adapter, sds_ring);
2041 qlcnic_fw_destroy_ctx(adapter);
2043 qlcnic_detach(adapter);
2045 adapter->ahw->diag_test = 0;
2046 adapter->drv_sds_rings = drv_sds_rings;
2047 adapter->drv_tx_rings = drv_tx_rings;
2049 if (qlcnic_attach(adapter))
2053 __qlcnic_up(adapter, netdev);
2058 static int qlcnic_alloc_adapter_resources(struct qlcnic_adapter *adapter)
2060 struct qlcnic_hardware_context *ahw = adapter->ahw;
2063 adapter->recv_ctx = kzalloc(sizeof(struct qlcnic_recv_context),
2065 if (!adapter->recv_ctx) {
2070 if (qlcnic_83xx_check(adapter)) {
2083 memset(&adapter->stats, 0, sizeof(adapter->stats));
2088 static void qlcnic_free_adapter_resources(struct qlcnic_adapter *adapter)
2090 struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
2092 kfree(adapter->recv_ctx);
2093 adapter->recv_ctx = NULL;
2101 dma_free_coherent(&adapter->pdev->dev, QLC_PEX_DMA_READ_SIZE,
2106 kfree(adapter->ahw->reset.buff);
2107 adapter->ahw->fw_dump.tmpl_hdr = NULL;
2112 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2121 __qlcnic_down(adapter, netdev);
2123 qlcnic_detach(adapter);
2125 adapter->drv_sds_rings = QLCNIC_SINGLE_RING;
2126 adapter->ahw->diag_test = test;
2127 adapter->ahw->linkup = 0;
2129 ret = qlcnic_attach(adapter);
2135 ret = qlcnic_fw_create_ctx(adapter);
2137 qlcnic_detach(adapter);
2142 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
2143 rds_ring = &adapter->recv_ctx->rds_rings[ring];
2144 qlcnic_post_rx_buffers(adapter, rds_ring, ring);
2147 if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
2148 for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
2149 sds_ring = &adapter->recv_ctx->sds_rings[ring];
2150 qlcnic_enable_sds_intr(adapter, sds_ring);
2154 if (adapter->ahw->diag_test == QLCNIC_LOOPBACK_TEST) {
2155 adapter->ahw->loopback_state = 0;
2156 qlcnic_linkevent_request(adapter, 1);
2159 set_bit(__QLCNIC_DEV_UP, &adapter->state);
2166 qlcnic_reset_hw_context(struct qlcnic_adapter *adapter)
2168 struct net_device *netdev = adapter->netdev;
2170 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
2175 qlcnic_down(adapter, netdev);
2177 qlcnic_up(adapter, netdev);
2181 clear_bit(__QLCNIC_RESETTING, &adapter->state);
2182 netdev_info(adapter->netdev, "%s: soft reset complete\n", __func__);
2187 qlcnic_reset_context(struct qlcnic_adapter *adapter)
2190 struct net_device *netdev = adapter->netdev;
2192 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
2195 if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC) {
2200 __qlcnic_down(adapter, netdev);
2202 qlcnic_detach(adapter);
2205 err = qlcnic_attach(adapter);
2207 __qlcnic_up(adapter, netdev);
2215 clear_bit(__QLCNIC_RESETTING, &adapter->state);
2219 static void qlcnic_82xx_set_mac_filter_count(struct qlcnic_adapter *adapter)
2221 struct qlcnic_hardware_context *ahw = adapter->ahw;
2235 static int qlcnic_set_real_num_queues(struct qlcnic_adapter *adapter,
2238 struct net_device *netdev = adapter->netdev;
2261 qlcnic_setup_netdev(struct qlcnic_adapter *adapter, struct net_device *netdev)
2264 struct pci_dev *pdev = adapter->pdev;
2266 adapter->rx_csum = 1;
2267 adapter->ahw->mc_enabled = 0;
2268 qlcnic_set_mac_filter_count(adapter);
2275 netdev->ethtool_ops = (qlcnic_sriov_vf_check(adapter)) ?
2284 if (QLCNIC_IS_TSO_CAPABLE(adapter)) {
2289 if (qlcnic_vlan_tx_check(adapter))
2292 if (qlcnic_sriov_vf_check(adapter))
2295 if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
2298 if (qlcnic_encap_tx_offload(adapter)) {
2308 if (qlcnic_encap_rx_offload(adapter)) {
2316 netdev->irq = adapter->msix_entries[0].vector;
2322 err = qlcnic_set_real_num_queues(adapter, adapter->drv_tx_rings,
2323 adapter->drv_sds_rings);
2327 qlcnic_dcb_init_dcbnl_ops(adapter->dcb);
2338 void qlcnic_free_tx_rings(struct qlcnic_adapter *adapter)
2343 for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
2344 tx_ring = &adapter->tx_ring[ring];
2350 kfree(adapter->tx_ring);
2353 int qlcnic_alloc_tx_rings(struct qlcnic_adapter *adapter,
2360 tx_ring = kcalloc(adapter->drv_tx_rings,
2365 adapter->tx_ring = tx_ring;
2367 for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
2368 tx_ring = &adapter->tx_ring[ring];
2369 tx_ring->num_desc = adapter->num_txd;
2373 qlcnic_free_tx_rings(adapter);
2380 if (qlcnic_83xx_check(adapter) ||
2381 (qlcnic_82xx_check(adapter) && qlcnic_check_multi_tx(adapter))) {
2382 for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
2383 tx_ring = &adapter->tx_ring[ring];
2384 tx_ring->adapter = adapter;
2385 if (adapter->flags & QLCNIC_MSIX_ENABLED) {
2386 index = adapter->drv_sds_rings + ring;
2387 vector = adapter->msix_entries[index].vector;
2396 void qlcnic_set_drv_version(struct qlcnic_adapter *adapter)
2398 struct qlcnic_hardware_context *ahw = adapter->ahw;
2401 if (qlcnic_82xx_check(adapter))
2403 else if (qlcnic_83xx_check(adapter))
2407 qlcnic_fw_cmd_set_drv_version(adapter, fw_cmd);
2411 static void qlcnic_reset_api_lock(struct qlcnic_adapter *adapter)
2413 qlcnic_api_lock(adapter);
2414 qlcnic_api_unlock(adapter);
2422 struct qlcnic_adapter *adapter = NULL;
2487 adapter = netdev_priv(netdev);
2488 adapter->netdev = netdev;
2489 adapter->pdev = pdev;
2490 adapter->ahw = ahw;
2492 adapter->qlcnic_wq = create_singlethread_workqueue("qlcnic");
2493 if (adapter->qlcnic_wq == NULL) {
2499 err = qlcnic_alloc_adapter_resources(adapter);
2503 adapter->dev_rst_time = jiffies;
2505 ahw->max_vnic_func = qlcnic_get_vnic_func_count(adapter);
2507 adapter->fdb_mac_learn = true;
2509 adapter->drv_mac_learn = true;
2511 rwlock_init(&adapter->ahw->crb_lock);
2512 mutex_init(&adapter->ahw->mem_lock);
2514 INIT_LIST_HEAD(&adapter->mac_list);
2516 qlcnic_register_dcb(adapter);
2518 if (qlcnic_82xx_check(adapter)) {
2519 qlcnic_check_vf(adapter, ent);
2520 adapter->portnum = adapter->ahw->pci_func;
2521 qlcnic_reset_api_lock(adapter);
2522 err = qlcnic_start_firmware(adapter);
2530 if (adapter->ahw->msix_supported) {
2531 if (qlcnic_check_multi_tx_capability(adapter) == 1)
2532 qlcnic_set_tx_ring_count(adapter,
2535 qlcnic_set_tx_ring_count(adapter,
2537 qlcnic_set_sds_ring_count(adapter,
2540 qlcnic_set_tx_ring_count(adapter, QLCNIC_SINGLE_RING);
2541 qlcnic_set_sds_ring_count(adapter, QLCNIC_SINGLE_RING);
2544 err = qlcnic_setup_idc_param(adapter);
2548 adapter->flags |= QLCNIC_NEED_FLR;
2550 } else if (qlcnic_83xx_check(adapter)) {
2551 qlcnic_83xx_check_vf(adapter, ent);
2552 adapter->portnum = adapter->ahw->pci_func;
2553 err = qlcnic_83xx_init(adapter);
2558 dev_err(&pdev->dev, "Please replace the adapter with new one and return the faulty adapter for repair\n");
2567 dev_err(&pdev->dev, "Adapter initialization failed. Driver will load in maintenance mode to recover the adapter using the application\n");
2572 if (qlcnic_sriov_vf_check(adapter))
2581 if (qlcnic_read_mac_addr(adapter))
2584 qlcnic_read_phys_port_id(adapter);
2586 if (adapter->portnum == 0) {
2587 qlcnic_get_board_name(adapter, board_name);
2591 board_name, adapter->ahw->revision_id);
2594 if (qlcnic_83xx_check(adapter) && !qlcnic_use_msi_x &&
2599 if (qlcnic_82xx_check(adapter)) {
2600 err = qlcnic_dcb_enable(adapter->dcb);
2602 qlcnic_dcb_free(adapter->dcb);
2607 qlcnic_dcb_get_info(adapter->dcb);
2608 err = qlcnic_setup_intr(adapter);
2616 err = qlcnic_get_act_pci_func(adapter);
2620 if (adapter->portnum == 0)
2621 qlcnic_set_drv_version(adapter);
2623 err = qlcnic_setup_netdev(adapter, netdev);
2627 pci_set_drvdata(pdev, adapter);
2629 if (qlcnic_82xx_check(adapter))
2630 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
2633 switch (adapter->ahw->port_type) {
2635 dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
2636 adapter->netdev->name);
2639 dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
2640 adapter->netdev->name);
2644 if (adapter->drv_mac_learn)
2645 qlcnic_alloc_lb_filters_mem(adapter);
2647 qlcnic_add_sysfs(adapter);
2648 qlcnic_register_hwmon_dev(adapter);
2652 if (qlcnic_83xx_check(adapter))
2653 qlcnic_83xx_free_mbx_intr(adapter);
2656 qlcnic_teardown_intr(adapter);
2657 qlcnic_cancel_idc_work(adapter);
2658 qlcnic_clr_all_drv_state(adapter, 0);
2661 qlcnic_free_adapter_resources(adapter);
2664 destroy_workqueue(adapter->qlcnic_wq);
2683 set_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state);
2688 if (qlcnic_83xx_check(adapter))
2689 adapter->tgt_status_reg = NULL;
2697 qlcnic_clr_all_drv_state(adapter, 0);
2701 pci_set_drvdata(pdev, adapter);
2702 qlcnic_add_sysfs(adapter);
2709 struct qlcnic_adapter *adapter;
2713 adapter = pci_get_drvdata(pdev);
2714 if (adapter == NULL)
2717 netdev = adapter->netdev;
2719 qlcnic_cancel_idc_work(adapter);
2720 qlcnic_sriov_pf_disable(adapter);
2721 ahw = adapter->ahw;
2724 qlcnic_sriov_cleanup(adapter);
2726 if (qlcnic_83xx_check(adapter)) {
2727 qlcnic_83xx_initialize_nic(adapter, 0);
2728 cancel_delayed_work_sync(&adapter->idc_aen_work);
2729 qlcnic_83xx_free_mbx_intr(adapter);
2730 qlcnic_83xx_detach_mailbox_work(adapter);
2735 qlcnic_dcb_free(adapter->dcb);
2736 qlcnic_detach(adapter);
2737 kfree(adapter->npars);
2738 kfree(adapter->eswitch);
2740 if (qlcnic_82xx_check(adapter))
2741 qlcnic_clr_all_drv_state(adapter, 0);
2743 clear_bit(__QLCNIC_RESETTING, &adapter->state);
2745 qlcnic_free_lb_filters_mem(adapter);
2747 qlcnic_teardown_intr(adapter);
2749 qlcnic_remove_sysfs(adapter);
2751 qlcnic_unregister_hwmon_dev(adapter);
2753 qlcnic_cleanup_pci_map(adapter->ahw);
2755 qlcnic_release_firmware(adapter);
2760 if (adapter->qlcnic_wq) {
2761 destroy_workqueue(adapter->qlcnic_wq);
2762 adapter->qlcnic_wq = NULL;
2765 qlcnic_free_adapter_resources(adapter);
2785 struct qlcnic_adapter *adapter = dev_get_drvdata(dev_d);
2787 return __qlcnic_resume(adapter);
2792 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2795 if (test_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state)) {
2804 err = qlcnic_attach(adapter);
2808 err = __qlcnic_up(adapter, netdev);
2810 qlcnic_detach(adapter);
2820 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2822 __qlcnic_down(adapter, netdev);
2829 void qlcnic_alloc_lb_filters_mem(struct qlcnic_adapter *adapter)
2833 struct net_device *netdev = adapter->netdev;
2837 if (adapter->fhash.fmax && adapter->fhash.fhead)
2840 act_pci_func = adapter->ahw->total_nic_func;
2841 spin_lock_init(&adapter->mac_learn_lock);
2842 spin_lock_init(&adapter->rx_mac_learn_lock);
2844 if (qlcnic_sriov_vf_check(adapter)) {
2846 adapter->fhash.fbucket_size = QLCNIC_VF_LB_BUCKET_SIZE;
2847 } else if (qlcnic_82xx_check(adapter)) {
2849 adapter->fhash.fbucket_size = QLCNIC_LB_BUCKET_SIZE;
2852 adapter->fhash.fbucket_size = QLC_83XX_LB_BUCKET_SIZE;
2855 head = kcalloc(adapter->fhash.fbucket_size,
2861 adapter->fhash.fmax = (filter_size / act_pci_func);
2862 adapter->fhash.fhead = head;
2865 act_pci_func, adapter->fhash.fmax);
2867 for (i = 0; i < adapter->fhash.fbucket_size; i++)
2868 INIT_HLIST_HEAD(&adapter->fhash.fhead[i]);
2870 adapter->rx_fhash.fbucket_size = adapter->fhash.fbucket_size;
2872 head = kcalloc(adapter->rx_fhash.fbucket_size,
2878 adapter->rx_fhash.fmax = (filter_size / act_pci_func);
2879 adapter->rx_fhash.fhead = head;
2881 for (i = 0; i < adapter->rx_fhash.fbucket_size; i++)
2882 INIT_HLIST_HEAD(&adapter->rx_fhash.fhead[i]);
2885 static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter)
2887 if (adapter->fhash.fmax)
2888 kfree(adapter->fhash.fhead);
2890 adapter->fhash.fhead = NULL;
2891 adapter->fhash.fmax = 0;
2893 if (adapter->rx_fhash.fmax)
2894 kfree(adapter->rx_fhash.fhead);
2896 adapter->rx_fhash.fmax = 0;
2897 adapter->rx_fhash.fhead = NULL;
2900 int qlcnic_check_temp(struct qlcnic_adapter *adapter)
2902 struct net_device *netdev = adapter->netdev;
2906 if (qlcnic_83xx_check(adapter))
2907 temp = QLCRDX(adapter->ahw, QLC_83XX_ASIC_TEMP);
2909 if (qlcnic_82xx_check(adapter))
2910 temp = QLC_SHARED_REG_RD32(adapter, QLCNIC_ASIC_TEMP);
2922 if (adapter->ahw->temp == QLCNIC_TEMP_NORMAL) {
2930 if (adapter->ahw->temp == QLCNIC_TEMP_WARN) {
2936 adapter->ahw->temp = temp_state;
2952 static void qlcnic_dump_rings(struct qlcnic_adapter *adapter)
2954 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
2955 struct net_device *netdev = adapter->netdev;
2964 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
2974 for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
2985 for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
2986 tx_ring = &adapter->tx_ring[ring];
3011 if (netif_msg_tx_err(adapter->ahw))
3019 struct qlcnic_adapter *adapter = netdev_priv(netdev);
3021 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
3024 qlcnic_dump_rings(adapter);
3026 if (++adapter->tx_timeo_cnt >= QLCNIC_MAX_TX_TIMEOUTS ||
3027 netif_msg_tx_err(adapter->ahw)) {
3028 netdev_err(netdev, "Tx timeout, reset the adapter.\n");
3029 if (qlcnic_82xx_check(adapter))
3030 adapter->need_fw_reset = 1;
3031 else if (qlcnic_83xx_check(adapter))
3032 qlcnic_83xx_idc_request_reset(adapter,
3035 netdev_err(netdev, "Tx timeout, reset adapter context.\n");
3036 adapter->ahw->reset_context = 1;
3042 struct qlcnic_adapter *adapter = netdev_priv(netdev);
3045 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
3046 qlcnic_update_stats(adapter);
3048 stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
3049 stats->tx_packets = adapter->stats.xmitfinished;
3050 stats->rx_bytes = adapter->stats.rxbytes + adapter->stats.lrobytes;
3051 stats->tx_bytes = adapter->stats.txbytes;
3052 stats->rx_dropped = adapter->stats.rxdropped;
3053 stats->tx_dropped = adapter->stats.txdropped;
3058 static irqreturn_t qlcnic_82xx_clear_legacy_intr(struct qlcnic_adapter *adapter)
3062 status = readl(adapter->isr_int_vec);
3064 if (!(status & adapter->ahw->int_vec_bit))
3068 status = readl(adapter->crb_int_state_reg);
3072 writel(0xffffffff, adapter->tgt_status_reg);
3074 readl(adapter->isr_int_vec);
3075 readl(adapter->isr_int_vec);
3083 struct qlcnic_adapter *adapter = sds_ring->adapter;
3085 if (adapter->flags & QLCNIC_MSIX_ENABLED)
3087 else if (adapter->flags & QLCNIC_MSI_ENABLED) {
3088 writel(0xffffffff, adapter->tgt_status_reg);
3092 if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
3096 adapter->ahw->diag_cnt++;
3097 qlcnic_enable_sds_intr(adapter, sds_ring);
3104 struct qlcnic_adapter *adapter = sds_ring->adapter;
3106 if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
3117 struct qlcnic_adapter *adapter = sds_ring->adapter;
3120 writel(0xffffffff, adapter->tgt_status_reg);
3143 qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding)
3147 val = adapter->portnum & 0xf;
3149 val |= (jiffies - adapter->dev_rst_time) << 8;
3151 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_SCRATCH, val);
3152 adapter->dev_rst_time = jiffies;
3156 qlcnic_set_drv_state(struct qlcnic_adapter *adapter, u8 state)
3163 if (qlcnic_api_lock(adapter))
3166 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3169 QLC_DEV_SET_RST_RDY(val, adapter->portnum);
3171 QLC_DEV_SET_QSCNT_RDY(val, adapter->portnum);
3173 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
3175 qlcnic_api_unlock(adapter);
3181 qlcnic_clr_drv_state(struct qlcnic_adapter *adapter)
3185 if (qlcnic_api_lock(adapter))
3188 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3189 QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
3190 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
3192 qlcnic_api_unlock(adapter);
3197 void qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8 failed)
3201 if (qlcnic_api_lock(adapter))
3204 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
3205 QLC_DEV_CLR_REF_CNT(val, adapter->portnum);
3206 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
3209 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3211 dev_info(&adapter->pdev->dev,
3214 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3217 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3218 QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
3219 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
3221 qlcnic_api_unlock(adapter);
3223 adapter->fw_fail_cnt = 0;
3224 adapter->flags &= ~QLCNIC_FW_HANG;
3225 clear_bit(__QLCNIC_START_FW, &adapter->state);
3226 clear_bit(__QLCNIC_RESETTING, &adapter->state);
3231 qlcnic_check_drv_state(struct qlcnic_adapter *adapter)
3234 struct qlcnic_hardware_context *ahw = adapter->ahw;
3236 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3237 act = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
3239 if (adapter->flags & QLCNIC_FW_RESET_OWNER) {
3251 static int qlcnic_check_idc_ver(struct qlcnic_adapter *adapter)
3253 u32 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_IDC_VER);
3256 dev_warn(&adapter->pdev->dev, "IDC Version mismatch, driver's"
3264 qlcnic_can_start_firmware(struct qlcnic_adapter *adapter)
3267 u8 dev_init_timeo = adapter->dev_init_timeo;
3268 u8 portnum = adapter->portnum;
3271 if (test_and_clear_bit(__QLCNIC_START_FW, &adapter->state))
3274 if (qlcnic_api_lock(adapter))
3277 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
3280 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
3283 prev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3284 QLCDB(adapter, HW, "Device state = %u\n", prev_state);
3288 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3290 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_IDC_VER,
3292 qlcnic_idc_debug_info(adapter, 0);
3293 qlcnic_api_unlock(adapter);
3297 ret = qlcnic_check_idc_ver(adapter);
3298 qlcnic_api_unlock(adapter);
3302 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3304 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
3308 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3310 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
3314 dev_err(&adapter->pdev->dev, "Device in failed state.\n");
3315 qlcnic_api_unlock(adapter);
3323 qlcnic_api_unlock(adapter);
3327 prev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3331 dev_err(&adapter->pdev->dev,
3336 if (qlcnic_api_lock(adapter))
3339 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3341 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
3343 ret = qlcnic_check_idc_ver(adapter);
3344 qlcnic_api_unlock(adapter);
3352 struct qlcnic_adapter *adapter = container_of(work,
3357 if (qlcnic_api_lock(adapter))
3360 dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3363 qlcnic_api_unlock(adapter);
3364 qlcnic_schedule_work(adapter, qlcnic_fwinit_work,
3369 if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
3370 qlcnic_api_unlock(adapter);
3376 dev_info(&adapter->pdev->dev, "Detected state change from "
3381 if (adapter->fw_wait_cnt++ > adapter->reset_ack_timeo) {
3382 dev_info(&adapter->pdev->dev, "Reset:Failed to get ack %d sec\n",
3383 adapter->reset_ack_timeo);
3387 if (!qlcnic_check_drv_state(adapter)) {
3389 dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3392 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3394 set_bit(__QLCNIC_START_FW, &adapter->state);
3395 QLCDB(adapter, DRV, "Restarting fw\n");
3396 qlcnic_idc_debug_info(adapter, 0);
3397 val = QLC_SHARED_REG_RD32(adapter,
3399 QLC_DEV_SET_RST_RDY(val, adapter->portnum);
3400 QLC_SHARED_REG_WR32(adapter,
3404 qlcnic_api_unlock(adapter);
3407 if (qlcnic_check_fw_dump_state(adapter) &&
3408 (adapter->flags & QLCNIC_FW_RESET_OWNER)) {
3409 QLCDB(adapter, DRV, "Take FW dump\n");
3410 qlcnic_dump_fw(adapter);
3411 adapter->flags |= QLCNIC_FW_HANG;
3415 adapter->flags &= ~QLCNIC_FW_RESET_OWNER;
3416 if (!adapter->nic_ops->start_firmware(adapter)) {
3417 qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
3418 adapter->fw_wait_cnt = 0;
3424 qlcnic_api_unlock(adapter);
3427 dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3428 QLCDB(adapter, HW, "Func waiting: Device state=%u\n", dev_state);
3432 if (!qlcnic_start_firmware(adapter)) {
3433 qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
3434 adapter->fw_wait_cnt = 0;
3441 qlcnic_schedule_work(adapter,
3447 dev_err(&adapter->pdev->dev, "Fwinit work failed state=%u "
3448 "fw_wait_cnt=%u\n", dev_state, adapter->fw_wait_cnt);
3449 netif_device_attach(adapter->netdev);
3450 qlcnic_clr_all_drv_state(adapter, 0);
3456 struct qlcnic_adapter *adapter = container_of(work,
3458 struct net_device *netdev = adapter->netdev;
3464 if (adapter->dev_state == QLCNIC_DEV_NEED_QUISCENT) {
3466 __qlcnic_down(adapter, netdev);
3468 qlcnic_down(adapter, netdev);
3470 status = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS1);
3473 dev_err(&adapter->pdev->dev,
3478 dev_err(&adapter->pdev->dev,
3481 dev_err(&adapter->pdev->dev,
3482 "Replace the adapter.\n");
3488 if (adapter->ahw->temp == QLCNIC_TEMP_PANIC) {
3489 dev_err(&adapter->pdev->dev, "Detaching the device: temp=%d\n",
3490 adapter->ahw->temp);
3495 if (!(adapter->flags & QLCNIC_FW_RESET_OWNER)) {
3496 if (qlcnic_set_drv_state(adapter, adapter->dev_state)) {
3497 dev_err(&adapter->pdev->dev,
3504 adapter->fw_wait_cnt = 0;
3506 qlcnic_schedule_work(adapter, qlcnic_fwinit_work, FW_POLL_DELAY);
3512 qlcnic_clr_all_drv_state(adapter, 1);
3517 qlcnic_set_npar_non_operational(struct qlcnic_adapter *adapter)
3521 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
3525 if (qlcnic_api_lock(adapter))
3527 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
3529 qlcnic_api_unlock(adapter);
3532 static void qlcnic_82xx_dev_request_reset(struct qlcnic_adapter *adapter,
3539 QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, xg_val);
3544 QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, gb_val);
3545 dev_info(&adapter->pdev->dev, "Pause control frames disabled"
3547 adapter->need_fw_reset = 1;
3549 if (qlcnic_api_lock(adapter))
3552 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3554 if (test_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state)) {
3555 netdev_err(adapter->netdev, "%s: Device is in non-operational state\n",
3557 qlcnic_api_unlock(adapter);
3563 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3565 adapter->flags |= QLCNIC_FW_RESET_OWNER;
3566 QLCDB(adapter, DRV, "NEED_RESET state set\n");
3567 qlcnic_idc_debug_info(adapter, 0);
3570 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
3572 qlcnic_api_unlock(adapter);
3577 qlcnic_dev_set_npar_ready(struct qlcnic_adapter *adapter)
3579 if (qlcnic_api_lock(adapter))
3582 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
3584 QLCDB(adapter, DRV, "NPAR operational state set\n");
3586 qlcnic_api_unlock(adapter);
3589 void qlcnic_schedule_work(struct qlcnic_adapter *adapter,
3592 if (test_bit(__QLCNIC_AER, &adapter->state))
3595 INIT_DELAYED_WORK(&adapter->fw_work, func);
3596 queue_delayed_work(adapter->qlcnic_wq, &adapter->fw_work,
3603 struct qlcnic_adapter *adapter = container_of(work,
3605 struct net_device *netdev = adapter->netdev;
3608 if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC) {
3609 npar_state = QLC_SHARED_REG_RD32(adapter,
3611 if (adapter->fw_wait_cnt++ > QLCNIC_DEV_NPAR_OPER_TIMEO)
3612 qlcnic_clr_all_drv_state(adapter, 0);
3614 qlcnic_schedule_work(adapter, qlcnic_attach_work,
3618 QLCDB(adapter, DRV, "Waiting for NPAR state to operational\n");
3622 qlcnic_dcb_get_info(adapter->dcb);
3625 if (qlcnic_up(adapter, netdev))
3633 adapter->fw_fail_cnt = 0;
3634 adapter->flags &= ~QLCNIC_FW_HANG;
3635 clear_bit(__QLCNIC_RESETTING, &adapter->state);
3636 if (adapter->portnum == 0)
3637 qlcnic_set_drv_version(adapter);
3639 if (!qlcnic_clr_drv_state(adapter))
3640 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
3645 qlcnic_check_health(struct qlcnic_adapter *adapter)
3647 struct qlcnic_hardware_context *ahw = adapter->ahw;
3653 if (qlcnic_check_temp(adapter))
3656 if (adapter->need_fw_reset)
3657 qlcnic_dev_request_reset(adapter, 0);
3659 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3661 qlcnic_set_npar_non_operational(adapter);
3662 adapter->need_fw_reset = 1;
3666 heartbeat = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_ALIVE_COUNTER);
3667 if (heartbeat != adapter->heartbeat) {
3668 adapter->heartbeat = heartbeat;
3669 adapter->fw_fail_cnt = 0;
3670 if (adapter->need_fw_reset)
3674 qlcnic_reset_hw_context(adapter);
3679 if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
3682 adapter->flags |= QLCNIC_FW_HANG;
3684 qlcnic_dev_request_reset(adapter, 0);
3687 clear_bit(__QLCNIC_FW_ATTACHED, &adapter->state);
3689 dev_err(&adapter->pdev->dev, "firmware hang detected\n");
3690 peg_status = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS1);
3691 dev_err(&adapter->pdev->dev, "Dumping hw/fw registers\n"
3697 QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS2),
3698 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_0 + 0x3c, &err),
3699 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_1 + 0x3c, &err),
3700 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_2 + 0x3c, &err),
3701 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_3 + 0x3c, &err),
3702 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_4 + 0x3c, &err));
3704 dev_err(&adapter->pdev->dev,
3708 adapter->dev_state = (state == QLCNIC_DEV_NEED_QUISCENT) ? state :
3712 &adapter->state)) {
3714 qlcnic_schedule_work(adapter, qlcnic_detach_work, 0);
3715 QLCDB(adapter, DRV, "fw recovery scheduled.\n");
3717 adapter->flags & QLCNIC_FW_RESET_OWNER) {
3718 qlcnic_dump_fw(adapter);
3726 struct qlcnic_adapter *adapter = container_of(work,
3729 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
3733 if (qlcnic_check_health(adapter))
3736 if (adapter->fhash.fnum)
3737 qlcnic_prune_lb_filters(adapter);
3740 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
3767 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3768 struct net_device *netdev = adapter->netdev;
3781 if (qlcnic_api_lock(adapter))
3784 if (adapter->ahw->op_mode != QLCNIC_NON_PRIV_FUNC && first_func) {
3785 adapter->need_fw_reset = 1;
3786 set_bit(__QLCNIC_START_FW, &adapter->state);
3787 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3789 QLCDB(adapter, DRV, "Restarting fw\n");
3791 qlcnic_api_unlock(adapter);
3793 err = qlcnic_start_firmware(adapter);
3797 qlcnic_clr_drv_state(adapter);
3798 kfree(adapter->msix_entries);
3799 adapter->msix_entries = NULL;
3800 err = qlcnic_setup_intr(adapter);
3803 kfree(adapter->msix_entries);
3809 err = qlcnic_attach(adapter);
3811 qlcnic_clr_all_drv_state(adapter, 1);
3812 clear_bit(__QLCNIC_AER, &adapter->state);
3817 err = qlcnic_up(adapter, netdev);
3831 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3832 struct net_device *netdev = adapter->netdev;
3840 set_bit(__QLCNIC_AER, &adapter->state);
3843 cancel_delayed_work_sync(&adapter->fw_work);
3846 qlcnic_down(adapter, netdev);
3848 qlcnic_detach(adapter);
3849 qlcnic_teardown_intr(adapter);
3851 clear_bit(__QLCNIC_RESETTING, &adapter->state);
3874 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3876 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3878 &adapter->state))
3879 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
3886 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3887 struct qlcnic_hardware_ops *hw_ops = adapter->ahw->hw_ops;
3899 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3900 struct qlcnic_hardware_ops *hw_ops = adapter->ahw->hw_ops;
3912 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3913 struct qlcnic_hardware_ops *hw_ops = adapter->ahw->hw_ops;
3923 qlcnicvf_start_firmware(struct qlcnic_adapter *adapter)
3927 err = qlcnic_can_start_firmware(adapter);
3931 err = qlcnic_check_npar_opertional(adapter);
3935 err = qlcnic_initialize_nic(adapter);
3939 qlcnic_check_options(adapter);
3941 err = qlcnic_set_eswitch_port_config(adapter);
3945 adapter->need_fw_reset = 0;
3950 int qlcnic_validate_rings(struct qlcnic_adapter *adapter, __u32 ring_cnt,
3953 struct net_device *netdev = adapter->netdev;
3967 if (qlcnic_82xx_check(adapter) && (queue_type == QLCNIC_TX_QUEUE) &&
3968 !qlcnic_check_multi_tx(adapter)) {
3983 int qlcnic_setup_rings(struct qlcnic_adapter *adapter)
3985 struct net_device *netdev = adapter->netdev;
3989 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
3992 tx_rings = adapter->drv_tss_rings;
3993 rx_rings = adapter->drv_rss_rings;
3997 err = qlcnic_set_real_num_queues(adapter, tx_rings, rx_rings);
4002 __qlcnic_down(adapter, netdev);
4004 qlcnic_detach(adapter);
4006 if (qlcnic_83xx_check(adapter)) {
4007 qlcnic_83xx_free_mbx_intr(adapter);
4008 qlcnic_83xx_enable_mbx_poll(adapter);
4011 qlcnic_teardown_intr(adapter);
4013 err = qlcnic_setup_intr(adapter);
4015 kfree(adapter->msix_entries);
4023 if ((tx_rings != adapter->drv_tx_rings) ||
4024 (rx_rings != adapter->drv_sds_rings)) {
4025 err = qlcnic_set_real_num_queues(adapter,
4026 adapter->drv_tx_rings,
4027 adapter->drv_sds_rings);
4032 if (qlcnic_83xx_check(adapter)) {
4033 qlcnic_83xx_initialize_nic(adapter, 1);
4034 err = qlcnic_83xx_setup_mbx_intr(adapter);
4035 qlcnic_83xx_disable_mbx_poll(adapter);
4037 dev_err(&adapter->pdev->dev,
4044 err = qlcnic_attach(adapter);
4047 err = __qlcnic_up(adapter, netdev);
4054 clear_bit(__QLCNIC_RESETTING, &adapter->state);
4063 qlcnic_config_indev_addr(struct qlcnic_adapter *adapter,
4076 qlcnic_config_ipaddr(adapter,
4080 qlcnic_config_ipaddr(adapter,
4093 struct qlcnic_adapter *adapter = netdev_priv(netdev);
4097 qlcnic_config_indev_addr(adapter, netdev, event);
4100 for_each_set_bit(vid, adapter->vlans, VLAN_N_VID) {
4104 qlcnic_config_indev_addr(adapter, dev, event);
4112 struct qlcnic_adapter *adapter;
4127 adapter = netdev_priv(dev);
4129 if (!adapter)
4132 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
4135 qlcnic_config_indev_addr(adapter, dev, event);
4144 struct qlcnic_adapter *adapter;
4163 adapter = netdev_priv(dev);
4165 if (!adapter)
4168 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
4173 qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_UP);
4177 qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_DOWN);