| @@ -133,23 +133,12 @@ static int qede_probe(struct pci_dev *pdev, const struct pci_device_id *id); · 132 unmodified lines |
| 133 | static void qede_remove(struct pci_dev *pdev); | 133 | static void qede_remove(struct pci_dev *pdev); |
| 134 | static void qede_shutdown(struct pci_dev *pdev); | 134 | static void qede_shutdown(struct pci_dev *pdev); |
| 135 | static void qede_link_update(void *dev, struct qed_link_output *link); | 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 | static void qede_get_eth_tlv_data(void *edev, void *data); | 138 | static void qede_get_eth_tlv_data(void *edev, void *data); |
| 137 | static void qede_get_generic_tlv_data(void *edev, | 139 | static void qede_get_generic_tlv_data(void *edev, |
| 138 | struct qed_generic_tlvs *data); | 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 | #ifdef CONFIG_QED_SRIOV | 142 | #ifdef CONFIG_QED_SRIOV |
| 154 | static int qede_set_vf_vlan(struct net_device *ndev, int vf, u16 vlan, u8 qos, | 143 | static int qede_set_vf_vlan(struct net_device *ndev, int vf, u16 vlan, u8 qos, |
| 155 | __be16 vlan_proto) | 144 | __be16 vlan_proto) |
| @@ -231,6 +220,7 @@ static struct qed_eth_cb_ops qede_ll_ops = { · 75 unmodified lines |
| 231 | .arfs_filter_op = qede_arfs_filter_op, | 220 | .arfs_filter_op = qede_arfs_filter_op, |
| 232 | #endif | 221 | #endif |
| 233 | .link_update = qede_link_update, | 222 | .link_update = qede_link_update, |
| | 223 | .schedule_recovery_handler = qede_schedule_recovery_handler, |
| 234 | .get_generic_tlv_data = qede_get_generic_tlv_data, | 224 | .get_generic_tlv_data = qede_get_generic_tlv_data, |
| 235 | .get_protocol_tlv_data = qede_get_eth_tlv_data, | 225 | .get_protocol_tlv_data = qede_get_eth_tlv_data, |
| 236 | }, | 226 | }, |
| @@ -950,11 +940,57 @@ err: · 713 unmodified lines |
| 950 | return -ENOMEM; | 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 | static void qede_sp_task(struct work_struct *work) | 971 | static void qede_sp_task(struct work_struct *work) |
| 954 | { | 972 | { |
| 955 | struct qede_dev *edev = container_of(work, struct qede_dev, | 973 | struct qede_dev *edev = container_of(work, struct qede_dev, |
| 956 | sp_task.work); | 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 | __qede_lock(edev); | 994 | __qede_lock(edev); |
| 959 | | 995 | |
| 960 | if (test_and_clear_bit(QEDE_SP_RX_MODE, &edev->sp_flags)) | 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 | enum qede_probe_mode { | 1068 | enum qede_probe_mode { |
| 1033 | QEDE_PROBE_NORMAL, | 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 | static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, | 1077 | static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level, |
| 1037 | bool is_vf, enum qede_probe_mode mode) | 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 | probe_params.dp_module = dp_module; | 1092 | probe_params.dp_module = dp_module; |
| 1052 | probe_params.dp_level = dp_level; | 1093 | probe_params.dp_level = dp_level; |
| 1053 | probe_params.is_vf = is_vf; | 1094 | probe_params.is_vf = is_vf; |
| | 1095 | probe_params.recov_in_prog = (mode == QEDE_PROBE_RECOVERY); |
| 1054 | cdev = qed_ops->common->probe(pdev, &probe_params); | 1096 | cdev = qed_ops->common->probe(pdev, &probe_params); |
| 1055 | if (!cdev) { | 1097 | if (!cdev) { |
| 1056 | rc = -ENODEV; | 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 | if (rc) | 1120 | if (rc) |
| 1079 | goto err2; | 1121 | goto err2; |
| 1080 | | 1122 | |
| 1081 | edev = qede_alloc_etherdev(cdev, pdev, &dev_info, dp_module, | 1123 | if (mode != QEDE_PROBE_RECOVERY) { |
| 1082 | dp_level); | 1124 | edev = qede_alloc_etherdev(cdev, pdev, &dev_info, dp_module, |
| 1083 | if (!edev) { | 1125 | dp_level); |
| 1084 | rc = -ENOMEM; | 1126 | if (!edev) { |
| 1085 | goto err2; | 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 | if (is_vf) | 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 | qede_init_ndev(edev); | 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 | if (rc) | 1145 | if (rc) |
| 1095 | goto err3; | 1146 | goto err3; |
| 1096 | | 1147 | |
| 1097 | /* Prepare the lock prior to the registration of the netdev, | 1148 | if (mode != QEDE_PROBE_RECOVERY) { |
| 1098 | * as once it's registered we might reach flows requiring it | 1149 | /* Prepare the lock prior to the registration of the netdev, |
| 1099 | * [it's even possible to reach a flow needing it directly | 1150 | * as once it's registered we might reach flows requiring it |
| 1100 | * from there, although it's unlikely]. | 1151 | * [it's even possible to reach a flow needing it directly |
| 1101 | */ | 1152 | * from there, although it's unlikely]. |
| 1102 | INIT_DELAYED_WORK(&edev->sp_task, qede_sp_task); | 1153 | */ |
| 1103 | mutex_init(&edev->qede_lock); | 1154 | INIT_DELAYED_WORK(&edev->sp_task, qede_sp_task); |
| 1104 | rc = register_netdev(edev->ndev); | 1155 | mutex_init(&edev->qede_lock); |
| 1105 | if (rc) { | 1156 | |
| 1106 | DP_NOTICE(edev, "Cannot register net-device\n"); | 1157 | rc = register_netdev(edev->ndev); |
| 1107 | goto err4; | 1158 | if (rc) { |
| | 1159 | DP_NOTICE(edev, "Cannot register net-device\n"); |
| | 1160 | goto err4; |
| | 1161 | } |
| 1108 | } | 1162 | } |
| 1109 | | 1163 | |
| 1110 | edev->ops->common->set_name(cdev, edev->ndev->name); | 1164 | edev->ops->common->set_name(cdev, edev->ndev->name); |
| 1111 | | 1165 | |
| 1112 | /* PTP not supported on VFs */ | 1166 | /* PTP not supported on VFs */ |
| 1113 | if (!is_vf) | 1167 | if (!is_vf) |
| 1114 | qede_ptp_enable(edev, true); | 1168 | qede_ptp_enable(edev, (mode == QEDE_PROBE_NORMAL)); |
| 1115 | | 1169 | |
| 1116 | edev->ops->register_ops(cdev, &qede_ll_ops, edev); | 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 | return 0; | 1180 | return 0; |
| 1127 | | 1181 | |
| 1128 | err4: | 1182 | err4: |
| 1129 | qede_rdma_dev_remove(edev); | 1183 | qede_rdma_dev_remove(edev, QEDE_RDMA_PROBE_MODE(mode)); |
| 1130 | err3: | 1184 | err3: |
| 1131 | free_netdev(edev->ndev); | 1185 | free_netdev(edev->ndev); |
| 1132 | err2: | 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 | enum qede_remove_mode { | 1217 | enum qede_remove_mode { |
| 1164 | QEDE_REMOVE_NORMAL, | 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 | static void __qede_remove(struct pci_dev *pdev, enum qede_remove_mode mode) | 1226 | static void __qede_remove(struct pci_dev *pdev, enum qede_remove_mode mode) |
| 1168 | { | 1227 | { |
| 1169 | struct net_device *ndev = pci_get_drvdata(pdev); | 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 | DP_INFO(edev, "Starting qede_remove\n"); | 1232 | DP_INFO(edev, "Starting qede_remove\n"); |
| 1174 | | 1233 | |
| 1175 | qede_rdma_dev_remove(edev); | 1234 | qede_rdma_dev_remove(edev, QEDE_RDMA_REMOVE_MODE(mode)); |
| 1176 | unregister_netdev(ndev); | | |
| 1177 | cancel_delayed_work_sync(&edev->sp_task); | | |
| 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 | /* Use global ops since we've freed edev */ | 1248 | /* Use global ops since we've freed edev */ |
| 1186 | qed_ops->common->slowpath_stop(cdev); | 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 | * [e.g., QED register callbacks] won't break anything when | 1257 | * [e.g., QED register callbacks] won't break anything when |
| 1195 | * accessing the netdevice. | 1258 | * accessing the netdevice. |
| 1196 | */ | 1259 | */ |
| 1197 | free_netdev(ndev); | 1260 | if (mode != QEDE_REMOVE_RECOVERY) |
| | 1261 | free_netdev(ndev); |
| 1198 | | 1262 | |
| 1199 | dev_info(&pdev->dev, "Ending qede_remove successfully\n"); | 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 | return 0; | 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 | /* This function inits fp content and resets the SB, RXQ and TXQ structures */ | 1658 | /* This function inits fp content and resets the SB, RXQ and TXQ structures */ |
| 1543 | static void qede_init_fp(struct qede_dev *edev) | 1659 | static void qede_init_fp(struct qede_dev *edev) |
| 1544 | { | 1660 | { |
| @@ -2053,6 +2169,7 @@ out: · 508 unmodified lines |
| 2053 | | 2169 | |
| 2054 | enum qede_unload_mode { | 2170 | enum qede_unload_mode { |
| 2055 | QEDE_UNLOAD_NORMAL, | 2171 | QEDE_UNLOAD_NORMAL, |
| | 2172 | QEDE_UNLOAD_RECOVERY, |
| 2056 | }; | 2173 | }; |
| 2057 | | 2174 | |
| 2058 | static void qede_unload(struct qede_dev *edev, enum qede_unload_mode mode, | 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 | clear_bit(QEDE_FLAGS_LINK_REQUESTED, &edev->flags); | 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 | qede_rdma_dev_event_close(edev); | 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 | netif_tx_disable(edev->ndev); | 2194 | netif_tx_disable(edev->ndev); |
| 2077 | netif_carrier_off(edev->ndev); | 2195 | netif_carrier_off(edev->ndev); |
| 2078 | | 2196 | |
| 2079 | /* Reset the link */ | 2197 | if (mode != QEDE_UNLOAD_RECOVERY) { |
| 2080 | memset(&link_params, 0, sizeof(link_params)); | 2198 | /* Reset the link */ |
| 2081 | link_params.link_up = false; | 2199 | memset(&link_params, 0, sizeof(link_params)); |
| 2082 | edev->ops->common->set_link(edev->cdev, &link_params); | 2200 | link_params.link_up = false; |
| 2083 | rc = qede_stop_queues(edev); | 2201 | edev->ops->common->set_link(edev->cdev, &link_params); |
| 2084 | if (rc) { | | |
| 2085 | qede_sync_free_irqs(edev); | | |
| 2086 | goto out; | | |
| 2087 | } | | |
| 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 | qede_vlan_mark_nonconfigured(edev); | 2212 | qede_vlan_mark_nonconfigured(edev); |
| 2092 | edev->ops->fastpath_stop(edev->cdev); | 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 | qede_napi_disable_remove(edev); | 2224 | qede_napi_disable_remove(edev); |
| 2104 | | 2225 | |
| | 2226 | if (mode == QEDE_UNLOAD_RECOVERY) |
| | 2227 | qede_empty_tx_queues(edev); |
| | 2228 | |
| 2105 | qede_free_mem_load(edev); | 2229 | qede_free_mem_load(edev); |
| 2106 | qede_free_fp_array(edev); | 2230 | qede_free_fp_array(edev); |
| 2107 | | 2231 | |
| 2108 | out: | 2232 | out: |
| 2109 | if (!is_locked) | 2233 | if (!is_locked) |
| 2110 | __qede_unlock(edev); | 2234 | __qede_unlock(edev); |
| | 2235 | |
| | 2236 | if (mode != QEDE_UNLOAD_RECOVERY) |
| | 2237 | DP_NOTICE(edev, "Link is down\n"); |
| | 2238 | |
| 2111 | DP_INFO(edev, "Ending qede unload\n"); | 2239 | DP_INFO(edev, "Ending qede unload\n"); |
| 2112 | } | 2240 | } |
| 2113 | | 2241 | |
| 2114 | enum qede_load_mode { | 2242 | enum qede_load_mode { |
| 2115 | QEDE_LOAD_NORMAL, | 2243 | QEDE_LOAD_NORMAL, |
| 2116 | QEDE_LOAD_RELOAD, | 2244 | QEDE_LOAD_RELOAD, |
| | 2245 | QEDE_LOAD_RECOVERY, |
| 2117 | }; | 2246 | }; |
| 2118 | | 2247 | |
| 2119 | static int qede_load(struct qede_dev *edev, enum qede_load_mode mode, | 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 | static bool qede_is_txq_full(struct qede_dev *edev, struct qede_tx_queue *txq) | 2496 | static bool qede_is_txq_full(struct qede_dev *edev, struct qede_tx_queue *txq) |
| 2297 | { | 2497 | { |
| 2298 | struct netdev_queue *netdev_txq; | 2498 | struct netdev_queue *netdev_txq; |