#include <linux/netdevice.h>
#include <linux/pci.h>
#include <linux/aer.h>
#include "wx_type.h"
#include "wx_lib.h"
#include "wx_err.h"
static pci_ers_result_t wx_io_error_detected(struct pci_dev *pdev,
pci_channel_state_t state)
{
struct wx *wx = pci_get_drvdata(pdev);
struct net_device *netdev;
if (!wx)
return PCI_ERS_RESULT_DISCONNECT;
netdev = wx->netdev;
if (!netif_device_present(netdev))
return PCI_ERS_RESULT_DISCONNECT;
rtnl_lock();
netif_device_detach(netdev);
set_bit(WX_FLAG_NEED_PCIE_RECOVERY, wx->flags);
wx_soft_quiesce(wx);
if (state == pci_channel_io_perm_failure) {
rtnl_unlock();
return PCI_ERS_RESULT_DISCONNECT;
}
if (!test_and_set_bit(WX_STATE_DISABLED, wx->state))
pci_disable_device(pdev);
rtnl_unlock();
return PCI_ERS_RESULT_NEED_RESET;
}
static pci_ers_result_t wx_io_slot_reset(struct pci_dev *pdev)
{
struct wx *wx = pci_get_drvdata(pdev);
if (pci_enable_device_mem(pdev)) {
wx_err(wx, "Cannot re-enable PCI device after reset.\n");
return PCI_ERS_RESULT_DISCONNECT;
}
smp_mb__before_atomic();
clear_bit(WX_STATE_DISABLED, wx->state);
clear_bit(WX_FLAG_NEED_PCIE_RECOVERY, wx->flags);
pci_set_master(pdev);
pci_restore_state(pdev);
pci_wake_from_d3(pdev, false);
rtnl_lock();
if (netif_running(wx->netdev) && wx->down_suspend)
wx->down_suspend(wx);
if (wx->do_reset)
wx->do_reset(wx->netdev, false);
rtnl_unlock();
return PCI_ERS_RESULT_RECOVERED;
}
static void wx_io_resume(struct pci_dev *pdev)
{
struct wx *wx = pci_get_drvdata(pdev);
struct net_device *netdev;
int err;
netdev = wx->netdev;
rtnl_lock();
if (netif_running(netdev)) {
err = netdev->netdev_ops->ndo_open(netdev);
if (err) {
wx_err(wx, "Failed to open netdev after reset\n");
goto out;
}
}
netif_device_attach(netdev);
out:
rtnl_unlock();
}
const struct pci_error_handlers wx_err_handler = {
.error_detected = wx_io_error_detected,
.slot_reset = wx_io_slot_reset,
.resume = wx_io_resume,
};
EXPORT_SYMBOL(wx_err_handler);
static bool wx_check_pcie_error(struct wx *wx)
{
u16 vid, pci_cmd;
pci_read_config_word(wx->pdev, PCI_VENDOR_ID, &vid);
pci_read_config_word(wx->pdev, PCI_COMMAND, &pci_cmd);
if (vid == U16_MAX || !(pci_cmd & PCI_COMMAND_MEMORY))
return true;
return false;
}
static void wx_pf_reset_subtask(struct wx *wx)
{
if (!test_and_clear_bit(WX_FLAG_NEED_DO_RESET, wx->flags))
return;
wx_warn(wx, "Reset adapter.\n");
if (wx->do_reset)
wx->do_reset(wx->netdev, true);
}
static void wx_reset_task(struct work_struct *work)
{
struct wx *wx = container_of(work, struct wx, reset_task);
rtnl_lock();
if (!netif_device_present(wx->netdev))
goto out;
if (test_bit(WX_FLAG_NEED_PCIE_RECOVERY, wx->flags)) {
if (wx_check_pcie_error(wx))
wx_soft_quiesce(wx);
else
clear_bit(WX_FLAG_NEED_PCIE_RECOVERY, wx->flags);
goto out;
}
if (test_bit(WX_STATE_DOWN, wx->state) ||
test_bit(WX_STATE_RESETTING, wx->state))
goto out;
wx_pf_reset_subtask(wx);
out:
rtnl_unlock();
}
void wx_check_err_subtask(struct wx *wx)
{
if (test_bit(WX_FLAG_NEED_DO_RESET, wx->flags))
queue_work(wx->reset_wq, &wx->reset_task);
}
EXPORT_SYMBOL(wx_check_err_subtask);
int wx_init_err_task(struct wx *wx)
{
wx->reset_wq = alloc_workqueue("%s_reset_wq_%x", WQ_UNBOUND | WQ_HIGHPRI,
1, wx->driver_name, pci_dev_id(wx->pdev));
if (!wx->reset_wq) {
wx_err(wx, "Failed to create wx_reset_wq workqueue\n");
return -ENOMEM;
}
INIT_WORK(&wx->reset_task, wx_reset_task);
return 0;
}
EXPORT_SYMBOL(wx_init_err_task);
static bool wx_ring_tx_pending(struct wx *wx)
{
int i;
for (i = 0; i < wx->num_tx_queues; i++) {
struct wx_ring *tx_ring = wx->tx_ring[i];
if (tx_ring->next_to_use != tx_ring->next_to_clean)
return true;
}
return false;
}
static bool wx_vf_tx_pending(struct wx *wx)
{
struct wx_ring_feature *vmdq = &wx->ring_feature[RING_F_VMDQ];
u32 q_per_pool = __ALIGN_MASK(1, ~vmdq->mask);
u32 i, j;
if (!wx->num_vfs)
return false;
for (i = 0; i < wx->num_vfs; i++) {
for (j = 0; j < q_per_pool; j++) {
u32 h, t;
h = rd32(wx, WX_PX_TR_RP_PV(q_per_pool, i, j));
t = rd32(wx, WX_PX_TR_WP_PV(q_per_pool, i, j));
if (h != t)
return true;
}
}
return false;
}
static void wx_watchdog_flush_tx(struct wx *wx)
{
if (!netif_running(wx->netdev))
return;
if (netif_carrier_ok(wx->netdev))
return;
if (wx_ring_tx_pending(wx) || wx_vf_tx_pending(wx)) {
wx_warn(wx, "initiating reset due to lost link with pending Tx work\n");
set_bit(WX_FLAG_NEED_DO_RESET, wx->flags);
}
}
static void wx_detect_tx_hang(struct wx *wx)
{
int i;
if (!netif_running(wx->netdev) ||
test_bit(WX_STATE_RESETTING, wx->state))
return;
if (netif_carrier_ok(wx->netdev)) {
for (i = 0; i < wx->num_tx_queues; i++)
set_bit(WX_TX_DETECT_HANG, wx->tx_ring[i]->state);
}
}
void wx_check_hang_subtask(struct wx *wx)
{
if (test_bit(WX_STATE_DOWN, wx->state) ||
test_bit(WX_STATE_RESETTING, wx->state))
return;
wx_watchdog_flush_tx(wx);
wx_detect_tx_hang(wx);
}
EXPORT_SYMBOL(wx_check_hang_subtask);
static void wx_tx_timeout_recovery(struct wx *wx)
{
set_bit(WX_FLAG_NEED_PCIE_RECOVERY, wx->flags);
wx_err(wx, "PCIe error detected during tx timeout\n");
queue_work(wx->reset_wq, &wx->reset_task);
}
static void wx_tx_timeout_reset(struct wx *wx)
{
if (test_bit(WX_STATE_DOWN, wx->state))
return;
set_bit(WX_FLAG_NEED_DO_RESET, wx->flags);
wx_warn(wx, "initiating reset due to tx timeout\n");
wx_service_event_schedule(wx);
}
void wx_tx_timeout(struct net_device *netdev, unsigned int __always_unused txqueue)
{
struct wx *wx = netdev_priv(netdev);
if (wx_check_pcie_error(wx))
wx_tx_timeout_recovery(wx);
else
wx_tx_timeout_reset(wx);
}
EXPORT_SYMBOL(wx_tx_timeout);
void wx_handle_tx_hang(struct wx_ring *tx_ring, unsigned int next)
{
struct wx *wx = netdev_priv(tx_ring->netdev);
wx_warn(wx,
"Detected Tx Unit Hang: Queue %d, TDH %x, TDT %x, ntu %x, ntc %x, ntc.time_stamp %lx, jiffies %lx\n",
tx_ring->queue_index,
rd32(wx, WX_PX_TR_RP(tx_ring->reg_idx)),
rd32(wx, WX_PX_TR_WP(tx_ring->reg_idx)),
tx_ring->next_to_use, next,
tx_ring->tx_buffer_info[next].time_stamp, jiffies);
netif_stop_subqueue(tx_ring->netdev, tx_ring->queue_index);
wx_tx_timeout_reset(wx);
}