X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fbnxt%2Fbnxt_cpr.c;h=a43b22a8f8b1d7bc860e54aa7334bca279673a55;hb=369ce46248c0605d31bd29ebaa4474309a875176;hp=1b046bbfacc11e61639c49c5f1be731b89287626;hpb=6391aeb8fb8094054af56062e584f7ac98049f1c;p=dpdk.git diff --git a/drivers/net/bnxt/bnxt_cpr.c b/drivers/net/bnxt/bnxt_cpr.c index 1b046bbfac..a43b22a8f8 100644 --- a/drivers/net/bnxt/bnxt_cpr.c +++ b/drivers/net/bnxt/bnxt_cpr.c @@ -1,17 +1,112 @@ /* SPDX-License-Identifier: BSD-3-Clause - * Copyright(c) 2014-2018 Broadcom + * Copyright(c) 2014-2021 Broadcom * All rights reserved. */ #include #include +#include #include "bnxt.h" -#include "bnxt_cpr.h" #include "bnxt_hwrm.h" #include "bnxt_ring.h" #include "hsi_struct_def_dpdk.h" +void bnxt_wait_for_device_shutdown(struct bnxt *bp) +{ + uint32_t val, timeout; + + /* if HWRM_FUNC_QCAPS_OUTPUT_FLAGS_ERR_RECOVER_RELOAD is set + * in HWRM_FUNC_QCAPS command, wait for FW_STATUS to set + * the SHUTDOWN bit in health register + */ + if (!(bp->recovery_info && + (bp->fw_cap & BNXT_FW_CAP_ERR_RECOVER_RELOAD))) + return; + + /* Driver has to wait for fw_reset_max_msecs or shutdown bit which comes + * first for FW to collect crash dump. + */ + timeout = bp->fw_reset_max_msecs; + + /* Driver has to poll for shutdown bit in fw_status register + * + * 1. in case of hot fw upgrade, this bit will be set after all + * function drivers unregistered with fw. + * 2. in case of fw initiated error recovery, this bit will be + * set after fw has collected the core dump + */ + do { + val = bnxt_read_fw_status_reg(bp, BNXT_FW_STATUS_REG); + if (val & BNXT_FW_STATUS_SHUTDOWN) + return; + + rte_delay_ms(100); + timeout -= 100; + } while (timeout); +} + +static void +bnxt_process_default_vnic_change(struct bnxt *bp, + struct hwrm_async_event_cmpl *async_cmp) +{ + uint16_t vnic_state, vf_fid, vf_id; + struct bnxt_representor *vf_rep_bp; + struct rte_eth_dev *eth_dev; + bool vfr_found = false; + uint32_t event_data; + + if (!BNXT_TRUFLOW_EN(bp)) + return; + + PMD_DRV_LOG(INFO, "Default vnic change async event received\n"); + event_data = rte_le_to_cpu_32(async_cmp->event_data1); + + vnic_state = (event_data & BNXT_DEFAULT_VNIC_STATE_MASK) >> + BNXT_DEFAULT_VNIC_STATE_SFT; + if (vnic_state != BNXT_DEFAULT_VNIC_ALLOC) + return; + + if (!bp->rep_info) + return; + + vf_fid = (event_data & BNXT_DEFAULT_VNIC_CHANGE_VF_ID_MASK) >> + BNXT_DEFAULT_VNIC_CHANGE_VF_ID_SFT; + PMD_DRV_LOG(INFO, "async event received vf_id 0x%x\n", vf_fid); + + for (vf_id = 0; vf_id < BNXT_MAX_VF_REPS(bp); vf_id++) { + eth_dev = bp->rep_info[vf_id].vfr_eth_dev; + if (!eth_dev) + continue; + vf_rep_bp = eth_dev->data->dev_private; + if (vf_rep_bp && + vf_rep_bp->fw_fid == vf_fid) { + vfr_found = true; + break; + } + } + if (!vfr_found) + return; + + bnxt_rep_dev_start_op(eth_dev); +} + +static void bnxt_handle_event_error_report(struct bnxt *bp, + uint32_t data1, + uint32_t data2) +{ + switch (BNXT_EVENT_ERROR_REPORT_TYPE(data1)) { + case HWRM_ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_PAUSE_STORM: + PMD_DRV_LOG(WARNING, "Port:%d Pause Storm detected!\n", + bp->eth_dev->data->port_id); + break; + default: + PMD_DRV_LOG(INFO, "FW reported unknown error type data1 %d" + " data2: %d\n", data1, data2); + break; + } +} + /* * Async event handling */ @@ -21,17 +116,23 @@ void bnxt_handle_async_event(struct bnxt *bp, struct hwrm_async_event_cmpl *async_cmp = (struct hwrm_async_event_cmpl *)cmp; uint16_t event_id = rte_le_to_cpu_16(async_cmp->event_id); + uint16_t port_id = bp->eth_dev->data->port_id; struct bnxt_error_recovery_info *info; uint32_t event_data; + uint32_t data1, data2; + uint32_t status; + + data1 = rte_le_to_cpu_32(async_cmp->event_data1); + data2 = rte_le_to_cpu_32(async_cmp->event_data2); - /* TODO: HWRM async events are not defined yet */ - /* Needs to handle: link events, error events, etc. */ switch (event_id) { case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_STATUS_CHANGE: case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_SPEED_CHANGE: case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_SPEED_CFG_CHANGE: /* FALLTHROUGH */ - bnxt_link_update_op(bp->eth_dev, 1); + bnxt_link_update_op(bp->eth_dev, 0); + rte_eth_dev_callback_process(bp->eth_dev, + RTE_ETH_EVENT_INTR_LSC, NULL); break; case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PF_DRVR_UNLOAD: PMD_DRV_LOG(INFO, "Async event: PF driver unloaded\n"); @@ -44,7 +145,20 @@ void bnxt_handle_async_event(struct bnxt *bp, PMD_DRV_LOG(INFO, "Port conn async event\n"); break; case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_RESET_NOTIFY: - event_data = rte_le_to_cpu_32(async_cmp->event_data1); + /* + * Avoid any rx/tx packet processing during firmware reset + * operation. + */ + bnxt_stop_rxtx(bp); + + /* Ignore reset notify async events when stopping the port */ + if (!bp->eth_dev->data->dev_started) { + bp->flags |= BNXT_FLAG_FATAL_ERROR; + return; + } + + pthread_mutex_lock(&bp->err_recovery_lock); + event_data = data1; /* timestamp_lo/hi values are in units of 100ms */ bp->fw_reset_max_msecs = async_cmp->timestamp_hi ? rte_le_to_cpu_16(async_cmp->timestamp_hi) * 100 : @@ -55,14 +169,17 @@ void bnxt_handle_async_event(struct bnxt *bp, if ((event_data & EVENT_DATA1_REASON_CODE_MASK) == EVENT_DATA1_REASON_CODE_FW_EXCEPTION_FATAL) { PMD_DRV_LOG(INFO, - "Firmware fatal reset event received\n"); + "Port %u: Firmware fatal reset event received\n", + port_id); bp->flags |= BNXT_FLAG_FATAL_ERROR; } else { PMD_DRV_LOG(INFO, - "Firmware non-fatal reset event received\n"); + "Port %u: Firmware non-fatal reset event received\n", + port_id); } bp->flags |= BNXT_FLAG_FW_RESET; + pthread_mutex_unlock(&bp->err_recovery_lock); rte_eal_alarm_set(US_PER_MS, bnxt_dev_reset_and_resume, (void *)bp); break; @@ -72,27 +189,56 @@ void bnxt_handle_async_event(struct bnxt *bp, if (!info) return; - PMD_DRV_LOG(INFO, "Error recovery async event received\n"); + event_data = data1 & EVENT_DATA1_FLAGS_MASK; - event_data = rte_le_to_cpu_32(async_cmp->event_data1) & - EVENT_DATA1_FLAGS_MASK; + if (event_data & EVENT_DATA1_FLAGS_RECOVERY_ENABLED) { + info->flags |= BNXT_FLAG_RECOVERY_ENABLED; + } else { + info->flags &= ~BNXT_FLAG_RECOVERY_ENABLED; + PMD_DRV_LOG(INFO, "Driver recovery watchdog is disabled\n"); + return; + } if (event_data & EVENT_DATA1_FLAGS_MASTER_FUNC) - info->flags |= BNXT_FLAG_MASTER_FUNC; + info->flags |= BNXT_FLAG_PRIMARY_FUNC; else - info->flags &= ~BNXT_FLAG_MASTER_FUNC; + info->flags &= ~BNXT_FLAG_PRIMARY_FUNC; - if (event_data & EVENT_DATA1_FLAGS_RECOVERY_ENABLED) - info->flags |= BNXT_FLAG_RECOVERY_ENABLED; - else - info->flags &= ~BNXT_FLAG_RECOVERY_ENABLED; + status = bnxt_read_fw_status_reg(bp, BNXT_FW_STATUS_REG); + PMD_DRV_LOG(INFO, + "Port: %u Driver recovery watchdog, role: %s, FW status: 0x%x (%s)\n", + port_id, bnxt_is_primary_func(bp) ? "primary" : "backup", status, + (status == BNXT_FW_STATUS_HEALTHY) ? "healthy" : "unhealthy"); + + if (bp->flags & BNXT_FLAG_FW_HEALTH_CHECK_SCHEDULED) + return; + + info->last_heart_beat = + bnxt_read_fw_status_reg(bp, BNXT_FW_HEARTBEAT_CNT_REG); + info->last_reset_counter = + bnxt_read_fw_status_reg(bp, BNXT_FW_RECOVERY_CNT_REG); - PMD_DRV_LOG(INFO, "recovery enabled(%d), master function(%d)\n", - bnxt_is_recovery_enabled(bp), - bnxt_is_master_func(bp)); + bnxt_schedule_fw_health_check(bp); + break; + case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_DEBUG_NOTIFICATION: + PMD_DRV_LOG(INFO, "Port: %u DNC event: data1 %#x data2 %#x\n", + port_id, data1, data2); + break; + case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_DEFAULT_VNIC_CHANGE: + bnxt_process_default_vnic_change(bp, async_cmp); + break; + case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_ECHO_REQUEST: + PMD_DRV_LOG(INFO, + "Port %u: Received fw echo request: data1 %#x data2 %#x\n", + port_id, data1, data2); + if (bp->recovery_info) + bnxt_hwrm_fw_echo_reply(bp, data1, data2); + break; + case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_ERROR_REPORT: + bnxt_handle_event_error_report(bp, data1, data2); break; default: - PMD_DRV_LOG(INFO, "handle_async_event id = 0x%x\n", event_id); + PMD_DRV_LOG(DEBUG, "handle_async_event id = 0x%x\n", event_id); break; } } @@ -107,14 +253,14 @@ void bnxt_handle_fwd_req(struct bnxt *bp, struct cmpl_base *cmpl) uint16_t req_len; int rc; - if (bp->pf.active_vfs <= 0) { + if (bp->pf->active_vfs <= 0) { PMD_DRV_LOG(ERR, "Forwarded VF with no active VFs\n"); return; } /* Qualify the fwd request */ fw_vf_id = rte_le_to_cpu_16(fwd_cmpl->source_id); - vf_id = fw_vf_id - bp->pf.first_vf_id; + vf_id = fw_vf_id - bp->pf->first_vf_id; req_len = (rte_le_to_cpu_16(fwd_cmpl->req_len_type) & HWRM_FWD_REQ_CMPL_REQ_LEN_MASK) >> @@ -123,19 +269,19 @@ void bnxt_handle_fwd_req(struct bnxt *bp, struct cmpl_base *cmpl) req_len = sizeof(fwreq->encap_request); /* Locate VF's forwarded command */ - fwd_cmd = (struct input *)bp->pf.vf_info[vf_id].req_buf; + fwd_cmd = (struct input *)bp->pf->vf_info[vf_id].req_buf; - if (fw_vf_id < bp->pf.first_vf_id || - fw_vf_id >= (bp->pf.first_vf_id) + bp->pf.active_vfs) { + if (fw_vf_id < bp->pf->first_vf_id || + fw_vf_id >= bp->pf->first_vf_id + bp->pf->active_vfs) { PMD_DRV_LOG(ERR, "FWD req's source_id 0x%x out of range 0x%x - 0x%x (%d %d)\n", - fw_vf_id, bp->pf.first_vf_id, - (bp->pf.first_vf_id) + bp->pf.active_vfs - 1, - bp->pf.first_vf_id, bp->pf.active_vfs); + fw_vf_id, bp->pf->first_vf_id, + (bp->pf->first_vf_id) + bp->pf->active_vfs - 1, + bp->pf->first_vf_id, bp->pf->active_vfs); goto reject; } - if (bnxt_rcv_msg_from_vf(bp, vf_id, fwd_cmd) == true) { + if (bnxt_rcv_msg_from_vf(bp, vf_id, fwd_cmd)) { /* * In older firmware versions, the MAC had to be all zeros for * the VF to set it's MAC via hwrm_func_vf_cfg. Set to all @@ -150,6 +296,7 @@ void bnxt_handle_fwd_req(struct bnxt *bp, struct cmpl_base *cmpl) (const uint8_t *)"\x00\x00\x00\x00\x00"); } } + if (fwd_cmd->req_type == HWRM_CFA_L2_SET_RX_MASK) { struct hwrm_cfa_l2_set_rx_mask_input *srm = (void *)fwd_cmd; @@ -161,12 +308,13 @@ void bnxt_handle_fwd_req(struct bnxt *bp, struct cmpl_base *cmpl) HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_VLAN_NONVLAN | HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ANYVLAN_NONVLAN); } + /* Forward */ rc = bnxt_hwrm_exec_fwd_resp(bp, fw_vf_id, fwd_cmd, req_len); if (rc) { PMD_DRV_LOG(ERR, "Failed to send FWD req VF 0x%x, type 0x%x.\n", - fw_vf_id - bp->pf.first_vf_id, + fw_vf_id - bp->pf->first_vf_id, rte_le_to_cpu_16(fwd_cmd->req_type)); } return; @@ -177,7 +325,7 @@ reject: if (rc) { PMD_DRV_LOG(ERR, "Failed to send REJECT req VF 0x%x, type 0x%x.\n", - fw_vf_id - bp->pf.first_vf_id, + fw_vf_id - bp->pf->first_vf_id, rte_le_to_cpu_16(fwd_cmd->req_type)); } @@ -202,23 +350,23 @@ int bnxt_event_hwrm_resp_handler(struct bnxt *bp, struct cmpl_base *cmp) bnxt_handle_async_event(bp, cmp); evt = 1; break; - case CMPL_BASE_TYPE_HWRM_FWD_RESP: + case CMPL_BASE_TYPE_HWRM_FWD_REQ: /* Handle HWRM forwarded responses */ bnxt_handle_fwd_req(bp, cmp); evt = 1; break; default: /* Ignore any other events */ - PMD_DRV_LOG(INFO, "Ignoring %02x completion\n", CMP_TYPE(cmp)); + PMD_DRV_LOG(DEBUG, "Ignoring %02x completion\n", CMP_TYPE(cmp)); break; } return evt; } -bool bnxt_is_master_func(struct bnxt *bp) +bool bnxt_is_primary_func(struct bnxt *bp) { - if (bp->recovery_info->flags & BNXT_FLAG_MASTER_FUNC) + if (bp->recovery_info->flags & BNXT_FLAG_PRIMARY_FUNC) return true; return false; @@ -234,3 +382,18 @@ bool bnxt_is_recovery_enabled(struct bnxt *bp) return false; } + +void bnxt_stop_rxtx(struct bnxt *bp) +{ + bp->eth_dev->rx_pkt_burst = &bnxt_dummy_recv_pkts; + bp->eth_dev->tx_pkt_burst = &bnxt_dummy_xmit_pkts; + + rte_eth_fp_ops[bp->eth_dev->data->port_id].rx_pkt_burst = + bp->eth_dev->rx_pkt_burst; + rte_eth_fp_ops[bp->eth_dev->data->port_id].tx_pkt_burst = + bp->eth_dev->tx_pkt_burst; + rte_mb(); + + /* Allow time for threads to exit the real burst functions. */ + rte_delay_ms(100); +}