[mirror_ubuntu-eoan-kernel.git] / drivers / infiniband / hw / bnxt_re / hw_counters.c

/*
 * Broadcom NetXtreme-E RoCE driver.
 *
 * Copyright (c) 2016 - 2017, Broadcom. All rights reserved.  The term
 * Broadcom refers to Broadcom Limited and/or its subsidiaries.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * BSD license below:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Description: Statistics
 *
 */

#include <linux/interrupt.h>
#include <linux/types.h>
#include <linux/spinlock.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/pci.h>
#include <linux/prefetch.h>
#include <linux/delay.h>

#include <rdma/ib_addr.h>

#include "bnxt_ulp.h"
#include "roce_hsi.h"
#include "qplib_res.h"
#include "qplib_sp.h"
#include "qplib_fp.h"
#include "qplib_rcfw.h"
#include "bnxt_re.h"
#include "hw_counters.h"

static const char * const bnxt_re_stat_name[] = {
	[BNXT_RE_ACTIVE_QP]		=  "active_qps",
	[BNXT_RE_ACTIVE_SRQ]		=  "active_srqs",
	[BNXT_RE_ACTIVE_CQ]		=  "active_cqs",
	[BNXT_RE_ACTIVE_MR]		=  "active_mrs",
	[BNXT_RE_ACTIVE_MW]		=  "active_mws",
	[BNXT_RE_RX_PKTS]		=  "rx_pkts",
	[BNXT_RE_RX_BYTES]		=  "rx_bytes",
	[BNXT_RE_TX_PKTS]		=  "tx_pkts",
	[BNXT_RE_TX_BYTES]		=  "tx_bytes",
	[BNXT_RE_RECOVERABLE_ERRORS]	=  "recoverable_errors",
	[BNXT_RE_TO_RETRANSMITS]        = "to_retransmits",
	[BNXT_RE_SEQ_ERR_NAKS_RCVD]     = "seq_err_naks_rcvd",
	[BNXT_RE_MAX_RETRY_EXCEEDED]    = "max_retry_exceeded",
	[BNXT_RE_RNR_NAKS_RCVD]         = "rnr_naks_rcvd",
	[BNXT_RE_MISSING_RESP]          = "missin_resp",
	[BNXT_RE_UNRECOVERABLE_ERR]     = "unrecoverable_err",
	[BNXT_RE_BAD_RESP_ERR]          = "bad_resp_err",
	[BNXT_RE_LOCAL_QP_OP_ERR]       = "local_qp_op_err",
	[BNXT_RE_LOCAL_PROTECTION_ERR]  = "local_protection_err",
	[BNXT_RE_MEM_MGMT_OP_ERR]       = "mem_mgmt_op_err",
	[BNXT_RE_REMOTE_INVALID_REQ_ERR] = "remote_invalid_req_err",
	[BNXT_RE_REMOTE_ACCESS_ERR]     = "remote_access_err",
	[BNXT_RE_REMOTE_OP_ERR]         = "remote_op_err",
	[BNXT_RE_DUP_REQ]               = "dup_req",
	[BNXT_RE_RES_EXCEED_MAX]        = "res_exceed_max",
	[BNXT_RE_RES_LENGTH_MISMATCH]   = "res_length_mismatch",
	[BNXT_RE_RES_EXCEEDS_WQE]       = "res_exceeds_wqe",
	[BNXT_RE_RES_OPCODE_ERR]        = "res_opcode_err",
	[BNXT_RE_RES_RX_INVALID_RKEY]   = "res_rx_invalid_rkey",
	[BNXT_RE_RES_RX_DOMAIN_ERR]     = "res_rx_domain_err",
	[BNXT_RE_RES_RX_NO_PERM]        = "res_rx_no_perm",
	[BNXT_RE_RES_RX_RANGE_ERR]      = "res_rx_range_err",
	[BNXT_RE_RES_TX_INVALID_RKEY]   = "res_tx_invalid_rkey",
	[BNXT_RE_RES_TX_DOMAIN_ERR]     = "res_tx_domain_err",
	[BNXT_RE_RES_TX_NO_PERM]        = "res_tx_no_perm",
	[BNXT_RE_RES_TX_RANGE_ERR]      = "res_tx_range_err",
	[BNXT_RE_RES_IRRQ_OFLOW]        = "res_irrq_oflow",
	[BNXT_RE_RES_UNSUP_OPCODE]      = "res_unsup_opcode",
	[BNXT_RE_RES_UNALIGNED_ATOMIC]  = "res_unaligned_atomic",
	[BNXT_RE_RES_REM_INV_ERR]       = "res_rem_inv_err",
	[BNXT_RE_RES_MEM_ERROR]         = "res_mem_err",
	[BNXT_RE_RES_SRQ_ERR]           = "res_srq_err",
	[BNXT_RE_RES_CMP_ERR]           = "res_cmp_err",
	[BNXT_RE_RES_INVALID_DUP_RKEY]  = "res_invalid_dup_rkey",
	[BNXT_RE_RES_WQE_FORMAT_ERR]    = "res_wqe_format_err",
	[BNXT_RE_RES_CQ_LOAD_ERR]       = "res_cq_load_err",
	[BNXT_RE_RES_SRQ_LOAD_ERR]      = "res_srq_load_err",
	[BNXT_RE_RES_TX_PCI_ERR]        = "res_tx_pci_err",
	[BNXT_RE_RES_RX_PCI_ERR]        = "res_rx_pci_err"
};

int bnxt_re_ib_get_hw_stats(struct ib_device *ibdev,
			    struct rdma_hw_stats *stats,
			    u8 port, int index)
{
	struct bnxt_re_dev *rdev = to_bnxt_re_dev(ibdev, ibdev);
	struct ctx_hw_stats *bnxt_re_stats = rdev->qplib_ctx.stats.dma;
	int rc  = 0;

	if (!port || !stats)
		return -EINVAL;

	stats->value[BNXT_RE_ACTIVE_QP] = atomic_read(&rdev->qp_count);
	stats->value[BNXT_RE_ACTIVE_SRQ] = atomic_read(&rdev->srq_count);
	stats->value[BNXT_RE_ACTIVE_CQ] = atomic_read(&rdev->cq_count);
	stats->value[BNXT_RE_ACTIVE_MR] = atomic_read(&rdev->mr_count);
	stats->value[BNXT_RE_ACTIVE_MW] = atomic_read(&rdev->mw_count);
	if (bnxt_re_stats) {
		stats->value[BNXT_RE_RECOVERABLE_ERRORS] =
			le64_to_cpu(bnxt_re_stats->tx_bcast_pkts);
		stats->value[BNXT_RE_RX_PKTS] =
			le64_to_cpu(bnxt_re_stats->rx_ucast_pkts);
		stats->value[BNXT_RE_RX_BYTES] =
			le64_to_cpu(bnxt_re_stats->rx_ucast_bytes);
		stats->value[BNXT_RE_TX_PKTS] =
			le64_to_cpu(bnxt_re_stats->tx_ucast_pkts);
		stats->value[BNXT_RE_TX_BYTES] =
			le64_to_cpu(bnxt_re_stats->tx_ucast_bytes);
	}
	if (test_bit(BNXT_RE_FLAG_ISSUE_ROCE_STATS, &rdev->flags)) {
		rc = bnxt_qplib_get_roce_stats(&rdev->rcfw, &rdev->stats);
		if (rc)
			clear_bit(BNXT_RE_FLAG_ISSUE_ROCE_STATS,
				  &rdev->flags);
		stats->value[BNXT_RE_TO_RETRANSMITS] =
					rdev->stats.to_retransmits;
		stats->value[BNXT_RE_SEQ_ERR_NAKS_RCVD] =
					rdev->stats.seq_err_naks_rcvd;
		stats->value[BNXT_RE_MAX_RETRY_EXCEEDED] =
					rdev->stats.max_retry_exceeded;
		stats->value[BNXT_RE_RNR_NAKS_RCVD] =
					rdev->stats.rnr_naks_rcvd;
		stats->value[BNXT_RE_MISSING_RESP] =
					rdev->stats.missing_resp;
		stats->value[BNXT_RE_UNRECOVERABLE_ERR] =
					rdev->stats.unrecoverable_err;
		stats->value[BNXT_RE_BAD_RESP_ERR] =
					rdev->stats.bad_resp_err;
		stats->value[BNXT_RE_LOCAL_QP_OP_ERR]	=
				rdev->stats.local_qp_op_err;
		stats->value[BNXT_RE_LOCAL_PROTECTION_ERR] =
				rdev->stats.local_protection_err;
		stats->value[BNXT_RE_MEM_MGMT_OP_ERR] =
				rdev->stats.mem_mgmt_op_err;
		stats->value[BNXT_RE_REMOTE_INVALID_REQ_ERR] =
				rdev->stats.remote_invalid_req_err;
		stats->value[BNXT_RE_REMOTE_ACCESS_ERR] =
				rdev->stats.remote_access_err;
		stats->value[BNXT_RE_REMOTE_OP_ERR] =
				rdev->stats.remote_op_err;
		stats->value[BNXT_RE_DUP_REQ] =
				rdev->stats.dup_req;
		stats->value[BNXT_RE_RES_EXCEED_MAX] =
				rdev->stats.res_exceed_max;
		stats->value[BNXT_RE_RES_LENGTH_MISMATCH] =
				rdev->stats.res_length_mismatch;
		stats->value[BNXT_RE_RES_EXCEEDS_WQE] =
				rdev->stats.res_exceeds_wqe;
		stats->value[BNXT_RE_RES_OPCODE_ERR] =
				rdev->stats.res_opcode_err;
		stats->value[BNXT_RE_RES_RX_INVALID_RKEY] =
				rdev->stats.res_rx_invalid_rkey;
		stats->value[BNXT_RE_RES_RX_DOMAIN_ERR] =
				rdev->stats.res_rx_domain_err;
		stats->value[BNXT_RE_RES_RX_NO_PERM] =
				rdev->stats.res_rx_no_perm;
		stats->value[BNXT_RE_RES_RX_RANGE_ERR]  =
				rdev->stats.res_rx_range_err;
		stats->value[BNXT_RE_RES_TX_INVALID_RKEY] =
				rdev->stats.res_tx_invalid_rkey;
		stats->value[BNXT_RE_RES_TX_DOMAIN_ERR] =
				rdev->stats.res_tx_domain_err;
		stats->value[BNXT_RE_RES_TX_NO_PERM] =
				rdev->stats.res_tx_no_perm;
		stats->value[BNXT_RE_RES_TX_RANGE_ERR]  =
				rdev->stats.res_tx_range_err;
		stats->value[BNXT_RE_RES_IRRQ_OFLOW] =
				rdev->stats.res_irrq_oflow;
		stats->value[BNXT_RE_RES_UNSUP_OPCODE]  =
				rdev->stats.res_unsup_opcode;
		stats->value[BNXT_RE_RES_UNALIGNED_ATOMIC] =
				rdev->stats.res_unaligned_atomic;
		stats->value[BNXT_RE_RES_REM_INV_ERR]   =
				rdev->stats.res_rem_inv_err;
		stats->value[BNXT_RE_RES_MEM_ERROR] =
				rdev->stats.res_mem_error;
		stats->value[BNXT_RE_RES_SRQ_ERR] =
				rdev->stats.res_srq_err;
		stats->value[BNXT_RE_RES_CMP_ERR] =
				rdev->stats.res_cmp_err;
		stats->value[BNXT_RE_RES_INVALID_DUP_RKEY] =
				rdev->stats.res_invalid_dup_rkey;
		stats->value[BNXT_RE_RES_WQE_FORMAT_ERR] =
				rdev->stats.res_wqe_format_err;
		stats->value[BNXT_RE_RES_CQ_LOAD_ERR]   =
				rdev->stats.res_cq_load_err;
		stats->value[BNXT_RE_RES_SRQ_LOAD_ERR]  =
				rdev->stats.res_srq_load_err;
		stats->value[BNXT_RE_RES_TX_PCI_ERR]    =
				rdev->stats.res_tx_pci_err;
		stats->value[BNXT_RE_RES_RX_PCI_ERR]    =
				rdev->stats.res_rx_pci_err;
	}

	return ARRAY_SIZE(bnxt_re_stat_name);
}

struct rdma_hw_stats *bnxt_re_ib_alloc_hw_stats(struct ib_device *ibdev,
						u8 port_num)
{
	BUILD_BUG_ON(ARRAY_SIZE(bnxt_re_stat_name) != BNXT_RE_NUM_COUNTERS);
	/* We support only per port stats */
	if (!port_num)
		return NULL;

	return rdma_alloc_hw_stats_struct(bnxt_re_stat_name,
					  ARRAY_SIZE(bnxt_re_stat_name),
					  RDMA_HW_STATS_DEFAULT_LIFESPAN);
}
Commit	Line	Data
225937d6 SK	1	/*
	2	* Broadcom NetXtreme-E RoCE driver.
	3	*
	4	* Copyright (c) 2016 - 2017, Broadcom. All rights reserved. The term
	5	* Broadcom refers to Broadcom Limited and/or its subsidiaries.
	6	*
	7	* This software is available to you under a choice of one of two
	8	* licenses. You may choose to be licensed under the terms of the GNU
	9	* General Public License (GPL) Version 2, available from the file
	10	* COPYING in the main directory of this source tree, or the
	11	* BSD license below:
	12	*
	13	* Redistribution and use in source and binary forms, with or without
	14	* modification, are permitted provided that the following conditions
	15	* are met:
	16	*
	17	* 1. Redistributions of source code must retain the above copyright
	18	* notice, this list of conditions and the following disclaimer.
	19	* 2. Redistributions in binary form must reproduce the above copyright
	20	* notice, this list of conditions and the following disclaimer in
	21	* the documentation and/or other materials provided with the
	22	* distribution.
	23	*
	24	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''
	25	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	26	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	27	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
	28	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	29	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	30	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
	31	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	32	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
	33	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
	34	* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	35	*
	36	* Description: Statistics
	37	*
	38	*/
	39
	40	#include <linux/interrupt.h>
	41	#include <linux/types.h>
	42	#include <linux/spinlock.h>
	43	#include <linux/sched.h>
	44	#include <linux/slab.h>
	45	#include <linux/pci.h>
	46	#include <linux/prefetch.h>
	47	#include <linux/delay.h>
	48
	49	#include <rdma/ib_addr.h>
	50
	51	#include "bnxt_ulp.h"
	52	#include "roce_hsi.h"
	53	#include "qplib_res.h"
	54	#include "qplib_sp.h"
	55	#include "qplib_fp.h"
	56	#include "qplib_rcfw.h"
	57	#include "bnxt_re.h"
	58	#include "hw_counters.h"
	59
	60	static const char * const bnxt_re_stat_name[] = {
89f81008 SX	61	[BNXT_RE_ACTIVE_QP] = "active_qps",
	62	[BNXT_RE_ACTIVE_SRQ] = "active_srqs",
	63	[BNXT_RE_ACTIVE_CQ] = "active_cqs",
	64	[BNXT_RE_ACTIVE_MR] = "active_mrs",
	65	[BNXT_RE_ACTIVE_MW] = "active_mws",
	66	[BNXT_RE_RX_PKTS] = "rx_pkts",
	67	[BNXT_RE_RX_BYTES] = "rx_bytes",
	68	[BNXT_RE_TX_PKTS] = "tx_pkts",
	69	[BNXT_RE_TX_BYTES] = "tx_bytes",
	70	[BNXT_RE_RECOVERABLE_ERRORS] = "recoverable_errors",
	71	[BNXT_RE_TO_RETRANSMITS] = "to_retransmits",
	72	[BNXT_RE_SEQ_ERR_NAKS_RCVD] = "seq_err_naks_rcvd",
	73	[BNXT_RE_MAX_RETRY_EXCEEDED] = "max_retry_exceeded",
	74	[BNXT_RE_RNR_NAKS_RCVD] = "rnr_naks_rcvd",
	75	[BNXT_RE_MISSING_RESP] = "missin_resp",
	76	[BNXT_RE_UNRECOVERABLE_ERR] = "unrecoverable_err",
	77	[BNXT_RE_BAD_RESP_ERR] = "bad_resp_err",
	78	[BNXT_RE_LOCAL_QP_OP_ERR] = "local_qp_op_err",
	79	[BNXT_RE_LOCAL_PROTECTION_ERR] = "local_protection_err",
	80	[BNXT_RE_MEM_MGMT_OP_ERR] = "mem_mgmt_op_err",
	81	[BNXT_RE_REMOTE_INVALID_REQ_ERR] = "remote_invalid_req_err",
	82	[BNXT_RE_REMOTE_ACCESS_ERR] = "remote_access_err",
	83	[BNXT_RE_REMOTE_OP_ERR] = "remote_op_err",
	84	[BNXT_RE_DUP_REQ] = "dup_req",
	85	[BNXT_RE_RES_EXCEED_MAX] = "res_exceed_max",
	86	[BNXT_RE_RES_LENGTH_MISMATCH] = "res_length_mismatch",
	87	[BNXT_RE_RES_EXCEEDS_WQE] = "res_exceeds_wqe",
	88	[BNXT_RE_RES_OPCODE_ERR] = "res_opcode_err",
	89	[BNXT_RE_RES_RX_INVALID_RKEY] = "res_rx_invalid_rkey",
	90	[BNXT_RE_RES_RX_DOMAIN_ERR] = "res_rx_domain_err",
	91	[BNXT_RE_RES_RX_NO_PERM] = "res_rx_no_perm",
	92	[BNXT_RE_RES_RX_RANGE_ERR] = "res_rx_range_err",
	93	[BNXT_RE_RES_TX_INVALID_RKEY] = "res_tx_invalid_rkey",
	94	[BNXT_RE_RES_TX_DOMAIN_ERR] = "res_tx_domain_err",
	95	[BNXT_RE_RES_TX_NO_PERM] = "res_tx_no_perm",
	96	[BNXT_RE_RES_TX_RANGE_ERR] = "res_tx_range_err",
	97	[BNXT_RE_RES_IRRQ_OFLOW] = "res_irrq_oflow",
	98	[BNXT_RE_RES_UNSUP_OPCODE] = "res_unsup_opcode",
	99	[BNXT_RE_RES_UNALIGNED_ATOMIC] = "res_unaligned_atomic",
	100	[BNXT_RE_RES_REM_INV_ERR] = "res_rem_inv_err",
	101	[BNXT_RE_RES_MEM_ERROR] = "res_mem_err",
	102	[BNXT_RE_RES_SRQ_ERR] = "res_srq_err",
	103	[BNXT_RE_RES_CMP_ERR] = "res_cmp_err",
	104	[BNXT_RE_RES_INVALID_DUP_RKEY] = "res_invalid_dup_rkey",
	105	[BNXT_RE_RES_WQE_FORMAT_ERR] = "res_wqe_format_err",
	106	[BNXT_RE_RES_CQ_LOAD_ERR] = "res_cq_load_err",
	107	[BNXT_RE_RES_SRQ_LOAD_ERR] = "res_srq_load_err",
	108	[BNXT_RE_RES_TX_PCI_ERR] = "res_tx_pci_err",
	109	[BNXT_RE_RES_RX_PCI_ERR] = "res_rx_pci_err"
225937d6 SK	110	};
	111
	112	int bnxt_re_ib_get_hw_stats(struct ib_device *ibdev,
	113	struct rdma_hw_stats *stats,
	114	u8 port, int index)
	115	{
	116	struct bnxt_re_dev *rdev = to_bnxt_re_dev(ibdev, ibdev);
	117	struct ctx_hw_stats *bnxt_re_stats = rdev->qplib_ctx.stats.dma;
89f81008	118	int rc = 0;
225937d6 SK	119
	120	if (!port \|\| !stats)
	121	return -EINVAL;
	122
	123	stats->value[BNXT_RE_ACTIVE_QP] = atomic_read(&rdev->qp_count);
	124	stats->value[BNXT_RE_ACTIVE_SRQ] = atomic_read(&rdev->srq_count);
	125	stats->value[BNXT_RE_ACTIVE_CQ] = atomic_read(&rdev->cq_count);
	126	stats->value[BNXT_RE_ACTIVE_MR] = atomic_read(&rdev->mr_count);
	127	stats->value[BNXT_RE_ACTIVE_MW] = atomic_read(&rdev->mw_count);
	128	if (bnxt_re_stats) {
	129	stats->value[BNXT_RE_RECOVERABLE_ERRORS] =
	130	le64_to_cpu(bnxt_re_stats->tx_bcast_pkts);
	131	stats->value[BNXT_RE_RX_PKTS] =
	132	le64_to_cpu(bnxt_re_stats->rx_ucast_pkts);
	133	stats->value[BNXT_RE_RX_BYTES] =
	134	le64_to_cpu(bnxt_re_stats->rx_ucast_bytes);
	135	stats->value[BNXT_RE_TX_PKTS] =
	136	le64_to_cpu(bnxt_re_stats->tx_ucast_pkts);
	137	stats->value[BNXT_RE_TX_BYTES] =
	138	le64_to_cpu(bnxt_re_stats->tx_ucast_bytes);
	139	}
89f81008 SX	140	if (test_bit(BNXT_RE_FLAG_ISSUE_ROCE_STATS, &rdev->flags)) {
	141	rc = bnxt_qplib_get_roce_stats(&rdev->rcfw, &rdev->stats);
	142	if (rc)
	143	clear_bit(BNXT_RE_FLAG_ISSUE_ROCE_STATS,
	144	&rdev->flags);
	145	stats->value[BNXT_RE_TO_RETRANSMITS] =
	146	rdev->stats.to_retransmits;
	147	stats->value[BNXT_RE_SEQ_ERR_NAKS_RCVD] =
	148	rdev->stats.seq_err_naks_rcvd;
	149	stats->value[BNXT_RE_MAX_RETRY_EXCEEDED] =
	150	rdev->stats.max_retry_exceeded;
	151	stats->value[BNXT_RE_RNR_NAKS_RCVD] =
	152	rdev->stats.rnr_naks_rcvd;
	153	stats->value[BNXT_RE_MISSING_RESP] =
	154	rdev->stats.missing_resp;
	155	stats->value[BNXT_RE_UNRECOVERABLE_ERR] =
	156	rdev->stats.unrecoverable_err;
	157	stats->value[BNXT_RE_BAD_RESP_ERR] =
	158	rdev->stats.bad_resp_err;
	159	stats->value[BNXT_RE_LOCAL_QP_OP_ERR] =
	160	rdev->stats.local_qp_op_err;
	161	stats->value[BNXT_RE_LOCAL_PROTECTION_ERR] =
	162	rdev->stats.local_protection_err;
	163	stats->value[BNXT_RE_MEM_MGMT_OP_ERR] =
	164	rdev->stats.mem_mgmt_op_err;
	165	stats->value[BNXT_RE_REMOTE_INVALID_REQ_ERR] =
	166	rdev->stats.remote_invalid_req_err;
	167	stats->value[BNXT_RE_REMOTE_ACCESS_ERR] =
	168	rdev->stats.remote_access_err;
	169	stats->value[BNXT_RE_REMOTE_OP_ERR] =
	170	rdev->stats.remote_op_err;
	171	stats->value[BNXT_RE_DUP_REQ] =
	172	rdev->stats.dup_req;
	173	stats->value[BNXT_RE_RES_EXCEED_MAX] =
	174	rdev->stats.res_exceed_max;
	175	stats->value[BNXT_RE_RES_LENGTH_MISMATCH] =
	176	rdev->stats.res_length_mismatch;
	177	stats->value[BNXT_RE_RES_EXCEEDS_WQE] =
	178	rdev->stats.res_exceeds_wqe;
	179	stats->value[BNXT_RE_RES_OPCODE_ERR] =
	180	rdev->stats.res_opcode_err;
	181	stats->value[BNXT_RE_RES_RX_INVALID_RKEY] =
	182	rdev->stats.res_rx_invalid_rkey;
	183	stats->value[BNXT_RE_RES_RX_DOMAIN_ERR] =
	184	rdev->stats.res_rx_domain_err;
	185	stats->value[BNXT_RE_RES_RX_NO_PERM] =
	186	rdev->stats.res_rx_no_perm;
	187	stats->value[BNXT_RE_RES_RX_RANGE_ERR] =
	188	rdev->stats.res_rx_range_err;
	189	stats->value[BNXT_RE_RES_TX_INVALID_RKEY] =
	190	rdev->stats.res_tx_invalid_rkey;
	191	stats->value[BNXT_RE_RES_TX_DOMAIN_ERR] =
	192	rdev->stats.res_tx_domain_err;
	193	stats->value[BNXT_RE_RES_TX_NO_PERM] =
	194	rdev->stats.res_tx_no_perm;
	195	stats->value[BNXT_RE_RES_TX_RANGE_ERR] =
	196	rdev->stats.res_tx_range_err;
	197	stats->value[BNXT_RE_RES_IRRQ_OFLOW] =
	198	rdev->stats.res_irrq_oflow;
	199	stats->value[BNXT_RE_RES_UNSUP_OPCODE] =
	200	rdev->stats.res_unsup_opcode;
	201	stats->value[BNXT_RE_RES_UNALIGNED_ATOMIC] =
	202	rdev->stats.res_unaligned_atomic;
	203	stats->value[BNXT_RE_RES_REM_INV_ERR] =
204	rdev->stats.res_rem_inv_err;
205	stats->value[BNXT_RE_RES_MEM_ERROR] =
206	rdev->stats.res_mem_error;
207	stats->value[BNXT_RE_RES_SRQ_ERR] =
208	rdev->stats.res_srq_err;
209	stats->value[BNXT_RE_RES_CMP_ERR] =
210	rdev->stats.res_cmp_err;
211	stats->value[BNXT_RE_RES_INVALID_DUP_RKEY] =
212	rdev->stats.res_invalid_dup_rkey;
213	stats->value[BNXT_RE_RES_WQE_FORMAT_ERR] =
214	rdev->stats.res_wqe_format_err;
215	stats->value[BNXT_RE_RES_CQ_LOAD_ERR] =
216	rdev->stats.res_cq_load_err;
217	stats->value[BNXT_RE_RES_SRQ_LOAD_ERR] =
218	rdev->stats.res_srq_load_err;
219	stats->value[BNXT_RE_RES_TX_PCI_ERR] =
220	rdev->stats.res_tx_pci_err;
221	stats->value[BNXT_RE_RES_RX_PCI_ERR] =
222	rdev->stats.res_rx_pci_err;
223	}
224
225937d6 SK	225	return ARRAY_SIZE(bnxt_re_stat_name);
	226	}
	227
	228	struct rdma_hw_stats bnxt_re_ib_alloc_hw_stats(struct ib_device ibdev,
	229	u8 port_num)
	230	{
	231	BUILD_BUG_ON(ARRAY_SIZE(bnxt_re_stat_name) != BNXT_RE_NUM_COUNTERS);
	232	/* We support only per port stats */
	233	if (!port_num)
	234	return NULL;
	235
	236	return rdma_alloc_hw_stats_struct(bnxt_re_stat_name,
	237	ARRAY_SIZE(bnxt_re_stat_name),
	238	RDMA_HW_STATS_DEFAULT_LIFESPAN);
	239	}