| @@ -133,23 +133,12 @@ static int qede_probe(struct pci_dev *pdev, const struct pci_device_id *id); · 132 unmodified lines |
| 133 | 133 | static void qede_remove(struct pci_dev *pdev); |
| 134 | 134 | static void qede_shutdown(struct pci_dev *pdev); |
| 135 | 135 | static void qede_link_update(void *dev, struct qed_link_output *link); |
| 136 | +static void qede_schedule_recovery_handler(void *dev); |
| 137 | +static void qede_recovery_handler(struct qede_dev *edev); |
| 136 | 138 | static void qede_get_eth_tlv_data(void *edev, void *data); |
| 137 | 139 | static void qede_get_generic_tlv_data(void *edev, |
| 138 | 140 | struct qed_generic_tlvs *data); |
| 139 | 141 | |
| 140 | | −/* The qede lock is used to protect driver state change and driver flows that |
| 141 | | − * are not reentrant. |
| 142 | | − */ |
| 143 | | −void __qede_lock(struct qede_dev *edev) |
| 144 | | −{ |
| 145 | | − mutex_lock(&edev->qede_lock); |
| 146 | | −} |
| 147 | | − |
| 148 | | −void __qede_unlock(struct qede_dev *edev) |
| 149 | | −{ |
| 150 | | − mutex_unlock(&edev->qede_lock); |
| 151 | | −} |
| 152 | | − |
| 153 | 142 | #ifdef CONFIG_QED_SRIOV |
| 154 | 143 | static int qede_set_vf_vlan(struct net_device *ndev, int vf, u16 vlan, u8 qos, |
| 155 | 144 | __be16 vlan_proto) |
| @@ -231,6 +220,7 @@ static struct qed_eth_cb_ops qede_ll_ops = { · 75 unmodified lines |
| 231 | 220 | .arfs_filter_op = qede_arfs_filter_op, |
| 232 | 221 | #endif |
| 233 | 222 | .link_update = qede_link_update, |
| 223 | + .schedule_recovery_handler = qede_schedule_recovery_handler, |
| 234 | 224 | .get_generic_tlv_data = qede_get_generic_tlv_data, |
| 235 | 225 | .get_protocol_tlv_data = qede_get_eth_tlv_data, |
| 236 | 226 | }, |
| @@ -950,11 +940,57 @@ err: · 713 unmodified lines |
| 950 | 940 | return -ENOMEM; |
| 951 | 941 | } |
| 952 | 942 | |
| 943 | +/* The qede lock is used to protect driver state change and driver flows that |
| 944 | + * are not reentrant. |
| 945 | + */ |
| 946 | +void __qede_lock(struct qede_dev *edev) |
| 947 | +{ |
| 948 | + mutex_lock(&edev->qede_lock); |
| 949 | +} |
| 950 | + |
| 951 | +void __qede_unlock(struct qede_dev *edev) |
| 952 | +{ |
| 953 | + mutex_unlock(&edev->qede_lock); |
| 954 | +} |
| 955 | + |
| 956 | +/* This version of the lock should be used when acquiring the RTNL lock is also |
| 957 | + * needed in addition to the internal qede lock. |
| 958 | + */ |
| 959 | +void qede_lock(struct qede_dev *edev) |
| 960 | +{ |
| 961 | + rtnl_lock(); |
| 962 | + __qede_lock(edev); |
| 963 | +} |
| 964 | + |
| 965 | +void qede_unlock(struct qede_dev *edev) |
| 966 | +{ |
| 967 | + __qede_unlock(edev); |
| 968 | + rtnl_unlock(); |
| 969 | +} |
| 970 | + |
| 953 | 971 | static void qede_sp_task(struct work_struct *work) |
| 954 | 972 | { |
| 955 | 973 | struct qede_dev *edev = container_of(work, struct qede_dev, |
| 956 | 974 | sp_task.work); |
| 957 | 975 | |
| 976 | + /* The locking scheme depends on the specific flag: |
| 977 | + * In case of QEDE_SP_RECOVERY, acquiring the RTNL lock is required to |
| 978 | + * ensure that ongoing flows are ended and new ones are not started. |
| 979 | + * In other cases - only the internal qede lock should be acquired. |
| 980 | + */ |
| 981 | + |
| 982 | + if (test_and_clear_bit(QEDE_SP_RECOVERY, &edev->sp_flags)) { |
| 983 | +#ifdef CONFIG_QED_SRIOV |
| 984 | + /* SRIOV must be disabled outside the lock to avoid a deadlock. |
| 985 | + * The recovery of the active VFs is currently not supported. |
| 986 | + */ |
| 987 | + qede_sriov_configure(edev->pdev, 0); |
| 988 | +#endif |
| 989 | + qede_lock(edev); |
| 990 | + qede_recovery_handler(edev); |
| 991 | + qede_unlock(edev); |
| 992 | + } |
| 993 | + |
| 958 | 994 | __qede_lock(edev); |
| 959 | 995 | |
| 960 | 996 | if (test_and_clear_bit(QEDE_SP_RX_MODE, &edev->sp_flags)) |
| @@ -1031,8 +1067,13 @@ static void qede_log_probe(struct qede_dev *edev) · 70 unmodified lines |
| 1031 | 1067 | |
| 1032 | 1068 | enum qede_probe_mode { |
| 1033 | 1069 | QEDE_PROBE_NORMAL, |
| 1070 | + QEDE_PROBE_RECOVERY, |
| 1034 | 1071 | }; |
| 1035 | 1072 | |
| 1073 | +#define QEDE_RDMA_PROBE_MODE(mode) \ |
| 1074 | + ((mode) == QEDE_PROBE_NORMAL ? QEDE_RDMA_PROBE_NORMAL \ |
| 1075 | + : QEDE_RDMA_PROBE_RECOVERY) |
| 1076 | + |
| 1036 | 1077 | static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, |
| 1037 | 1078 | bool is_vf, enum qede_probe_mode mode) |
| 1038 | 1079 | { |
| @@ -1051,6 +1092,7 @@ static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, · 12 unmodified lines |
| 1051 | 1092 | probe_params.dp_module = dp_module; |
| 1052 | 1093 | probe_params.dp_level = dp_level; |
| 1053 | 1094 | probe_params.is_vf = is_vf; |
| 1095 | + probe_params.recov_in_prog = (mode == QEDE_PROBE_RECOVERY); |
| 1054 | 1096 | cdev = qed_ops->common->probe(pdev, &probe_params); |
| 1055 | 1097 | if (!cdev) { |
| 1056 | 1098 | rc = -ENODEV; |
| @@ -1078,11 +1120,20 @@ static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, · 21 unmodified lines |
| 1078 | 1120 | if (rc) |
| 1079 | 1121 | goto err2; |
| 1080 | 1122 | |
| 1081 | | − edev = qede_alloc_etherdev(cdev, pdev, &dev_info, dp_module, |
| 1082 | | − dp_level); |
| 1083 | | − if (!edev) { |
| 1084 | | − rc = -ENOMEM; |
| 1085 | | − goto err2; |
| 1123 | + if (mode != QEDE_PROBE_RECOVERY) { |
| 1124 | + edev = qede_alloc_etherdev(cdev, pdev, &dev_info, dp_module, |
| 1125 | + dp_level); |
| 1126 | + if (!edev) { |
| 1127 | + rc = -ENOMEM; |
| 1128 | + goto err2; |
| 1129 | + } |
| 1130 | + } else { |
| 1131 | + struct net_device *ndev = pci_get_drvdata(pdev); |
| 1132 | + |
| 1133 | + edev = netdev_priv(ndev); |
| 1134 | + edev->cdev = cdev; |
| 1135 | + memset(&edev->stats, 0, sizeof(edev->stats)); |
| 1136 | + memcpy(&edev->dev_info, &dev_info, sizeof(dev_info)); |
| 1086 | 1137 | } |
| 1087 | 1138 | |
| 1088 | 1139 | if (is_vf) |
| @@ -1090,28 +1141,31 @@ static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, · 1 unmodified line |
| 1090 | 1141 | |
| 1091 | 1142 | qede_init_ndev(edev); |
| 1092 | 1143 | |
| 1093 | | − rc = qede_rdma_dev_add(edev); |
| 1144 | + rc = qede_rdma_dev_add(edev, QEDE_RDMA_PROBE_MODE(mode)); |
| 1094 | 1145 | if (rc) |
| 1095 | 1146 | goto err3; |
| 1096 | 1147 | |
| 1097 | | − /* Prepare the lock prior to the registration of the netdev, |
| 1098 | | − * as once it's registered we might reach flows requiring it |
| 1099 | | − * [it's even possible to reach a flow needing it directly |
| 1100 | | − * from there, although it's unlikely]. |
| 1101 | | − */ |
| 1102 | | − INIT_DELAYED_WORK(&edev->sp_task, qede_sp_task); |
| 1103 | | − mutex_init(&edev->qede_lock); |
| 1104 | | − rc = register_netdev(edev->ndev); |
| 1105 | | − if (rc) { |
| 1106 | | − DP_NOTICE(edev, "Cannot register net-device\n"); |
| 1107 | | − goto err4; |
| 1148 | + if (mode != QEDE_PROBE_RECOVERY) { |
| 1149 | + /* Prepare the lock prior to the registration of the netdev, |
| 1150 | + * as once it's registered we might reach flows requiring it |
| 1151 | + * [it's even possible to reach a flow needing it directly |
| 1152 | + * from there, although it's unlikely]. |
| 1153 | + */ |
| 1154 | + INIT_DELAYED_WORK(&edev->sp_task, qede_sp_task); |
| 1155 | + mutex_init(&edev->qede_lock); |
| 1156 | + |
| 1157 | + rc = register_netdev(edev->ndev); |
| 1158 | + if (rc) { |
| 1159 | + DP_NOTICE(edev, "Cannot register net-device\n"); |
| 1160 | + goto err4; |
| 1161 | + } |
| 1108 | 1162 | } |
| 1109 | 1163 | |
| 1110 | 1164 | edev->ops->common->set_name(cdev, edev->ndev->name); |
| 1111 | 1165 | |
| 1112 | 1166 | /* PTP not supported on VFs */ |
| 1113 | 1167 | if (!is_vf) |
| 1114 | | − qede_ptp_enable(edev, true); |
| 1168 | + qede_ptp_enable(edev, (mode == QEDE_PROBE_NORMAL)); |
| 1115 | 1169 | |
| 1116 | 1170 | edev->ops->register_ops(cdev, &qede_ll_ops, edev); |
| 1117 | 1171 | |
| @@ -1126,7 +1180,7 @@ static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, · 8 unmodified lines |
| 1126 | 1180 | return 0; |
| 1127 | 1181 | |
| 1128 | 1182 | err4: |
| 1129 | | − qede_rdma_dev_remove(edev); |
| 1183 | + qede_rdma_dev_remove(edev, QEDE_RDMA_PROBE_MODE(mode)); |
| 1130 | 1184 | err3: |
| 1131 | 1185 | free_netdev(edev->ndev); |
| 1132 | 1186 | err2: |
| @@ -1162,8 +1216,13 @@ static int qede_probe(struct pci_dev *pdev, const struct pci_device_id *id) · 29 unmodified lines |
| 1162 | 1216 | |
| 1163 | 1217 | enum qede_remove_mode { |
| 1164 | 1218 | QEDE_REMOVE_NORMAL, |
| 1219 | + QEDE_REMOVE_RECOVERY, |
| 1165 | 1220 | }; |
| 1166 | 1221 | |
| 1222 | +#define QEDE_RDMA_REMOVE_MODE(mode) \ |
| 1223 | + ((mode) == QEDE_REMOVE_NORMAL ? QEDE_RDMA_REMOVE_NORMAL \ |
| 1224 | + : QEDE_RDMA_REMOVE_RECOVERY) |
| 1225 | + |
| 1167 | 1226 | static void __qede_remove(struct pci_dev *pdev, enum qede_remove_mode mode) |
| 1168 | 1227 | { |
| 1169 | 1228 | struct net_device *ndev = pci_get_drvdata(pdev); |
| @@ -1172,15 +1231,19 @@ static void __qede_remove(struct pci_dev *pdev, enum qede_remove_mode mode) · 2 unmodified lines |
| 1172 | 1231 | |
| 1173 | 1232 | DP_INFO(edev, "Starting qede_remove\n"); |
| 1174 | 1233 | |
| 1175 | | − qede_rdma_dev_remove(edev); |
| 1176 | | − unregister_netdev(ndev); |
| 1177 | | − cancel_delayed_work_sync(&edev->sp_task); |
| 1234 | + qede_rdma_dev_remove(edev, QEDE_RDMA_REMOVE_MODE(mode)); |
| 1178 | 1235 | |
| 1179 | | − qede_ptp_disable(edev); |
| 1236 | + if (mode != QEDE_REMOVE_RECOVERY) { |
| 1237 | + unregister_netdev(ndev); |
| 1180 | 1238 | |
| 1181 | | − edev->ops->common->set_power_state(cdev, PCI_D0); |
| 1239 | + cancel_delayed_work_sync(&edev->sp_task); |
| 1182 | 1240 | |
| 1183 | | − pci_set_drvdata(pdev, NULL); |
| 1241 | + edev->ops->common->set_power_state(cdev, PCI_D0); |
| 1242 | + |
| 1243 | + pci_set_drvdata(pdev, NULL); |
| 1244 | + } |
| 1245 | + |
| 1246 | + qede_ptp_disable(edev); |
| 1184 | 1247 | |
| 1185 | 1248 | /* Use global ops since we've freed edev */ |
| 1186 | 1249 | qed_ops->common->slowpath_stop(cdev); |
| @@ -1194,7 +1257,8 @@ static void __qede_remove(struct pci_dev *pdev, enum qede_remove_mode mode) · 7 unmodified lines |
| 1194 | 1257 | * [e.g., QED register callbacks] won't break anything when |
| 1195 | 1258 | * accessing the netdevice. |
| 1196 | 1259 | */ |
| 1197 | | − free_netdev(ndev); |
| 1260 | + if (mode != QEDE_REMOVE_RECOVERY) |
| 1261 | + free_netdev(ndev); |
| 1198 | 1262 | |
| 1199 | 1263 | dev_info(&pdev->dev, "Ending qede_remove successfully\n"); |
| 1200 | 1264 | } |
| @@ -1539,6 +1603,58 @@ static int qede_alloc_mem_load(struct qede_dev *edev) · 338 unmodified lines |
| 1539 | 1603 | return 0; |
| 1540 | 1604 | } |
| 1541 | 1605 | |
| 1606 | +static void qede_empty_tx_queue(struct qede_dev *edev, |
| 1607 | + struct qede_tx_queue *txq) |
| 1608 | +{ |
| 1609 | + unsigned int pkts_compl = 0, bytes_compl = 0; |
| 1610 | + struct netdev_queue *netdev_txq; |
| 1611 | + int rc, len = 0; |
| 1612 | + |
| 1613 | + netdev_txq = netdev_get_tx_queue(edev->ndev, txq->ndev_txq_id); |
| 1614 | + |
| 1615 | + while (qed_chain_get_cons_idx(&txq->tx_pbl) != |
| 1616 | + qed_chain_get_prod_idx(&txq->tx_pbl)) { |
| 1617 | + DP_VERBOSE(edev, NETIF_MSG_IFDOWN, |
| 1618 | + "Freeing a packet on tx queue[%d]: chain_cons 0x%x, chain_prod 0x%x\n", |
| 1619 | + txq->index, qed_chain_get_cons_idx(&txq->tx_pbl), |
| 1620 | + qed_chain_get_prod_idx(&txq->tx_pbl)); |
| 1621 | + |
| 1622 | + rc = qede_free_tx_pkt(edev, txq, &len); |
| 1623 | + if (rc) { |
| 1624 | + DP_NOTICE(edev, |
| 1625 | + "Failed to free a packet on tx queue[%d]: chain_cons 0x%x, chain_prod 0x%x\n", |
| 1626 | + txq->index, |
| 1627 | + qed_chain_get_cons_idx(&txq->tx_pbl), |
| 1628 | + qed_chain_get_prod_idx(&txq->tx_pbl)); |
| 1629 | + break; |
| 1630 | + } |
| 1631 | + |
| 1632 | + bytes_compl += len; |
| 1633 | + pkts_compl++; |
| 1634 | + txq->sw_tx_cons++; |
| 1635 | + } |
| 1636 | + |
| 1637 | + netdev_tx_completed_queue(netdev_txq, pkts_compl, bytes_compl); |
| 1638 | +} |
| 1639 | + |
| 1640 | +static void qede_empty_tx_queues(struct qede_dev *edev) |
| 1641 | +{ |
| 1642 | + int i; |
| 1643 | + |
| 1644 | + for_each_queue(i) |
| 1645 | + if (edev->fp_array[i].type & QEDE_FASTPATH_TX) { |
| 1646 | + int cos; |
| 1647 | + |
| 1648 | + for_each_cos_in_txq(edev, cos) { |
| 1649 | + struct qede_fastpath *fp; |
| 1650 | + |
| 1651 | + fp = &edev->fp_array[i]; |
| 1652 | + qede_empty_tx_queue(edev, |
| 1653 | + &fp->txq[cos]); |
| 1654 | + } |
| 1655 | + } |
| 1656 | +} |
| 1657 | + |
| 1542 | 1658 | /* This function inits fp content and resets the SB, RXQ and TXQ structures */ |
| 1543 | 1659 | static void qede_init_fp(struct qede_dev *edev) |
| 1544 | 1660 | { |
| @@ -2053,6 +2169,7 @@ out: · 508 unmodified lines |
| 2053 | 2169 | |
| 2054 | 2170 | enum qede_unload_mode { |
| 2055 | 2171 | QEDE_UNLOAD_NORMAL, |
| 2172 | + QEDE_UNLOAD_RECOVERY, |
| 2056 | 2173 | }; |
| 2057 | 2174 | |
| 2058 | 2175 | static void qede_unload(struct qede_dev *edev, enum qede_unload_mode mode, |
| @@ -2068,7 +2185,8 @@ static void qede_unload(struct qede_dev *edev, enum qede_unload_mode mode, · 9 unmodified lines |
| 2068 | 2185 | |
| 2069 | 2186 | clear_bit(QEDE_FLAGS_LINK_REQUESTED, &edev->flags); |
| 2070 | 2187 | |
| 2071 | | − edev->state = QEDE_STATE_CLOSED; |
| 2188 | + if (mode != QEDE_UNLOAD_RECOVERY) |
| 2189 | + edev->state = QEDE_STATE_CLOSED; |
| 2072 | 2190 | |
| 2073 | 2191 | qede_rdma_dev_event_close(edev); |
| 2074 | 2192 | |
| @@ -2076,17 +2194,20 @@ static void qede_unload(struct qede_dev *edev, enum qede_unload_mode mode, · 1 unmodified line |
| 2076 | 2194 | netif_tx_disable(edev->ndev); |
| 2077 | 2195 | netif_carrier_off(edev->ndev); |
| 2078 | 2196 | |
| 2079 | | − /* Reset the link */ |
| 2080 | | − memset(&link_params, 0, sizeof(link_params)); |
| 2081 | | − link_params.link_up = false; |
| 2082 | | − edev->ops->common->set_link(edev->cdev, &link_params); |
| 2083 | | − rc = qede_stop_queues(edev); |
| 2084 | | − if (rc) { |
| 2085 | | − qede_sync_free_irqs(edev); |
| 2086 | | − goto out; |
| 2087 | | − } |
| 2197 | + if (mode != QEDE_UNLOAD_RECOVERY) { |
| 2198 | + /* Reset the link */ |
| 2199 | + memset(&link_params, 0, sizeof(link_params)); |
| 2200 | + link_params.link_up = false; |
| 2201 | + edev->ops->common->set_link(edev->cdev, &link_params); |
| 2088 | 2202 | |
| 2089 | | − DP_INFO(edev, "Stopped Queues\n"); |
| 2203 | + rc = qede_stop_queues(edev); |
| 2204 | + if (rc) { |
| 2205 | + qede_sync_free_irqs(edev); |
| 2206 | + goto out; |
| 2207 | + } |
| 2208 | + |
| 2209 | + DP_INFO(edev, "Stopped Queues\n"); |
| 2210 | + } |
| 2090 | 2211 | |
| 2091 | 2212 | qede_vlan_mark_nonconfigured(edev); |
| 2092 | 2213 | edev->ops->fastpath_stop(edev->cdev); |
| @@ -2102,18 +2223,26 @@ static void qede_unload(struct qede_dev *edev, enum qede_unload_mode mode, · 9 unmodified lines |
| 2102 | 2223 | |
| 2103 | 2224 | qede_napi_disable_remove(edev); |
| 2104 | 2225 | |
| 2226 | + if (mode == QEDE_UNLOAD_RECOVERY) |
| 2227 | + qede_empty_tx_queues(edev); |
| 2228 | + |
| 2105 | 2229 | qede_free_mem_load(edev); |
| 2106 | 2230 | qede_free_fp_array(edev); |
| 2107 | 2231 | |
| 2108 | 2232 | out: |
| 2109 | 2233 | if (!is_locked) |
| 2110 | 2234 | __qede_unlock(edev); |
| 2235 | + |
| 2236 | + if (mode != QEDE_UNLOAD_RECOVERY) |
| 2237 | + DP_NOTICE(edev, "Link is down\n"); |
| 2238 | + |
| 2111 | 2239 | DP_INFO(edev, "Ending qede unload\n"); |
| 2112 | 2240 | } |
| 2113 | 2241 | |
| 2114 | 2242 | enum qede_load_mode { |
| 2115 | 2243 | QEDE_LOAD_NORMAL, |
| 2116 | 2244 | QEDE_LOAD_RELOAD, |
| 2245 | + QEDE_LOAD_RECOVERY, |
| 2117 | 2246 | }; |
| 2118 | 2247 | |
| 2119 | 2248 | static int qede_load(struct qede_dev *edev, enum qede_load_mode mode, |
| @@ -2293,6 +2422,77 @@ static void qede_link_update(void *dev, struct qed_link_output *link) · 173 unmodified lines |
| 2293 | 2422 | } |
| 2294 | 2423 | } |
| 2295 | 2424 | |
| 2425 | +static void qede_schedule_recovery_handler(void *dev) |
| 2426 | +{ |
| 2427 | + struct qede_dev *edev = dev; |
| 2428 | + |
| 2429 | + if (edev->state == QEDE_STATE_RECOVERY) { |
| 2430 | + DP_NOTICE(edev, |
| 2431 | + "Avoid scheduling a recovery handling since already in recovery state\n"); |
| 2432 | + return; |
| 2433 | + } |
| 2434 | + |
| 2435 | + set_bit(QEDE_SP_RECOVERY, &edev->sp_flags); |
| 2436 | + schedule_delayed_work(&edev->sp_task, 0); |
| 2437 | + |
| 2438 | + DP_INFO(edev, "Scheduled a recovery handler\n"); |
| 2439 | +} |
| 2440 | + |
| 2441 | +static void qede_recovery_failed(struct qede_dev *edev) |
| 2442 | +{ |
| 2443 | + netdev_err(edev->ndev, "Recovery handling has failed. Power cycle is needed.\n"); |
| 2444 | + |
| 2445 | + netif_device_detach(edev->ndev); |
| 2446 | + |
| 2447 | + if (edev->cdev) |
| 2448 | + edev->ops->common->set_power_state(edev->cdev, PCI_D3hot); |
| 2449 | +} |
| 2450 | + |
| 2451 | +static void qede_recovery_handler(struct qede_dev *edev) |
| 2452 | +{ |
| 2453 | + u32 curr_state = edev->state; |
| 2454 | + int rc; |
| 2455 | + |
| 2456 | + DP_NOTICE(edev, "Starting a recovery process\n"); |
| 2457 | + |
| 2458 | + /* No need to acquire first the qede_lock since is done by qede_sp_task |
| 2459 | + * before calling this function. |
| 2460 | + */ |
| 2461 | + edev->state = QEDE_STATE_RECOVERY; |
| 2462 | + |
| 2463 | + edev->ops->common->recovery_prolog(edev->cdev); |
| 2464 | + |
| 2465 | + if (curr_state == QEDE_STATE_OPEN) |
| 2466 | + qede_unload(edev, QEDE_UNLOAD_RECOVERY, true); |
| 2467 | + |
| 2468 | + __qede_remove(edev->pdev, QEDE_REMOVE_RECOVERY); |
| 2469 | + |
| 2470 | + rc = __qede_probe(edev->pdev, edev->dp_module, edev->dp_level, |
| 2471 | + IS_VF(edev), QEDE_PROBE_RECOVERY); |
| 2472 | + if (rc) { |
| 2473 | + edev->cdev = NULL; |
| 2474 | + goto err; |
| 2475 | + } |
| 2476 | + |
| 2477 | + if (curr_state == QEDE_STATE_OPEN) { |
| 2478 | + rc = qede_load(edev, QEDE_LOAD_RECOVERY, true); |
| 2479 | + if (rc) |
| 2480 | + goto err; |
| 2481 | + |
| 2482 | + qede_config_rx_mode(edev->ndev); |
| 2483 | + udp_tunnel_get_rx_info(edev->ndev); |
| 2484 | + } |
| 2485 | + |
| 2486 | + edev->state = curr_state; |
| 2487 | + |
| 2488 | + DP_NOTICE(edev, "Recovery handling is done\n"); |
| 2489 | + |
| 2490 | + return; |
| 2491 | + |
| 2492 | +err: |
| 2493 | + qede_recovery_failed(edev); |
| 2494 | +} |
| 2495 | + |
| 2296 | 2496 | static bool qede_is_txq_full(struct qede_dev *edev, struct qede_tx_queue *txq) |
| 2297 | 2497 | { |
| 2298 | 2498 | struct netdev_queue *netdev_txq; |