Quelle  hbg_diagnose.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
// Copyright (c) 2025 Hisilicon Limited.

#include <linux/iopoll.h>
#include <linux/phy.h>
#include "hbg_common.h"
#include "hbg_ethtool.h"
#include "hbg_hw.h"
#include "hbg_diagnose.h"

#define HBG_MSG_DATA_MAX_NUM 64

struct hbg_diagnose_message {
 u32 opcode;
 u32 status;
 u32 data_num;
 struct hbg_priv *priv;

 u32 data[HBG_MSG_DATA_MAX_NUM];
};

#define HBG_HW_PUSH_WAIT_TIMEOUT_US (2 * 1000 * 1000)
#define HBG_HW_PUSH_WAIT_INTERVAL_US (1 * 1000)

enum hbg_push_cmd {
 HBG_PUSH_CMD_IRQ = 0,
 HBG_PUSH_CMD_STATS,
 HBG_PUSH_CMD_LINK,
};

struct hbg_push_stats_info {
 /* id is used to match the name of the current stats item.
 * and is used for pretty print on BMC
 */
 u32 id;
 u64 offset;
};

struct hbg_push_irq_info {
 /* id is used to match the name of the current irq.
 * and is used for pretty print on BMC
 */
 u32 id;
 u32 mask;
};

#define HBG_PUSH_IRQ_I(name, id) {id, HBG_INT_MSK_##name##_B}
static const struct hbg_push_irq_info hbg_push_irq_list[] = {
 HBG_PUSH_IRQ_I(RX, 0),
 HBG_PUSH_IRQ_I(TX, 1),
 HBG_PUSH_IRQ_I(TX_PKT_CPL, 2),
 HBG_PUSH_IRQ_I(MAC_MII_FIFO_ERR, 3),
 HBG_PUSH_IRQ_I(MAC_PCS_RX_FIFO_ERR, 4),
 HBG_PUSH_IRQ_I(MAC_PCS_TX_FIFO_ERR, 5),
 HBG_PUSH_IRQ_I(MAC_APP_RX_FIFO_ERR, 6),
 HBG_PUSH_IRQ_I(MAC_APP_TX_FIFO_ERR, 7),
 HBG_PUSH_IRQ_I(SRAM_PARITY_ERR, 8),
 HBG_PUSH_IRQ_I(TX_AHB_ERR, 9),
 HBG_PUSH_IRQ_I(RX_BUF_AVL, 10),
 HBG_PUSH_IRQ_I(REL_BUF_ERR, 11),
 HBG_PUSH_IRQ_I(TXCFG_AVL, 12),
 HBG_PUSH_IRQ_I(TX_DROP, 13),
 HBG_PUSH_IRQ_I(RX_DROP, 14),
 HBG_PUSH_IRQ_I(RX_AHB_ERR, 15),
 HBG_PUSH_IRQ_I(MAC_FIFO_ERR, 16),
 HBG_PUSH_IRQ_I(RBREQ_ERR, 17),
 HBG_PUSH_IRQ_I(WE_ERR, 18),
};

#define HBG_PUSH_STATS_I(name, id) {id, HBG_STATS_FIELD_OFF(name)}
static const struct hbg_push_stats_info hbg_push_stats_list[] = {
 HBG_PUSH_STATS_I(rx_desc_drop, 0),
 HBG_PUSH_STATS_I(rx_desc_l2_err_cnt, 1),
 HBG_PUSH_STATS_I(rx_desc_pkt_len_err_cnt, 2),
 HBG_PUSH_STATS_I(rx_desc_l3_wrong_head_cnt, 3),
 HBG_PUSH_STATS_I(rx_desc_l3_csum_err_cnt, 4),
 HBG_PUSH_STATS_I(rx_desc_l3_len_err_cnt, 5),
 HBG_PUSH_STATS_I(rx_desc_l3_zero_ttl_cnt, 6),
 HBG_PUSH_STATS_I(rx_desc_l3_other_cnt, 7),
 HBG_PUSH_STATS_I(rx_desc_l4_err_cnt, 8),
 HBG_PUSH_STATS_I(rx_desc_l4_wrong_head_cnt, 9),
 HBG_PUSH_STATS_I(rx_desc_l4_len_err_cnt, 10),
 HBG_PUSH_STATS_I(rx_desc_l4_csum_err_cnt, 11),
 HBG_PUSH_STATS_I(rx_desc_l4_zero_port_num_cnt, 12),
 HBG_PUSH_STATS_I(rx_desc_l4_other_cnt, 13),
 HBG_PUSH_STATS_I(rx_desc_frag_cnt, 14),
 HBG_PUSH_STATS_I(rx_desc_ip_ver_err_cnt, 15),
 HBG_PUSH_STATS_I(rx_desc_ipv4_pkt_cnt, 16),
 HBG_PUSH_STATS_I(rx_desc_ipv6_pkt_cnt, 17),
 HBG_PUSH_STATS_I(rx_desc_no_ip_pkt_cnt, 18),
 HBG_PUSH_STATS_I(rx_desc_ip_pkt_cnt, 19),
 HBG_PUSH_STATS_I(rx_desc_tcp_pkt_cnt, 20),
 HBG_PUSH_STATS_I(rx_desc_udp_pkt_cnt, 21),
 HBG_PUSH_STATS_I(rx_desc_vlan_pkt_cnt, 22),
 HBG_PUSH_STATS_I(rx_desc_icmp_pkt_cnt, 23),
 HBG_PUSH_STATS_I(rx_desc_arp_pkt_cnt, 24),
 HBG_PUSH_STATS_I(rx_desc_rarp_pkt_cnt, 25),
 HBG_PUSH_STATS_I(rx_desc_multicast_pkt_cnt, 26),
 HBG_PUSH_STATS_I(rx_desc_broadcast_pkt_cnt, 27),
 HBG_PUSH_STATS_I(rx_desc_ipsec_pkt_cnt, 28),
 HBG_PUSH_STATS_I(rx_desc_ip_opt_pkt_cnt, 29),
 HBG_PUSH_STATS_I(rx_desc_key_not_match_cnt, 30),
 HBG_PUSH_STATS_I(rx_octets_total_ok_cnt, 31),
 HBG_PUSH_STATS_I(rx_uc_pkt_cnt, 32),
 HBG_PUSH_STATS_I(rx_mc_pkt_cnt, 33),
 HBG_PUSH_STATS_I(rx_bc_pkt_cnt, 34),
 HBG_PUSH_STATS_I(rx_vlan_pkt_cnt, 35),
 HBG_PUSH_STATS_I(rx_octets_bad_cnt, 36),
 HBG_PUSH_STATS_I(rx_octets_total_filt_cnt, 37),
 HBG_PUSH_STATS_I(rx_filt_pkt_cnt, 38),
 HBG_PUSH_STATS_I(rx_trans_pkt_cnt, 39),
 HBG_PUSH_STATS_I(rx_framesize_64, 40),
 HBG_PUSH_STATS_I(rx_framesize_65_127, 41),
 HBG_PUSH_STATS_I(rx_framesize_128_255, 42),
 HBG_PUSH_STATS_I(rx_framesize_256_511, 43),
 HBG_PUSH_STATS_I(rx_framesize_512_1023, 44),
 HBG_PUSH_STATS_I(rx_framesize_1024_1518, 45),
 HBG_PUSH_STATS_I(rx_framesize_bt_1518, 46),
 HBG_PUSH_STATS_I(rx_fcs_error_cnt, 47),
 HBG_PUSH_STATS_I(rx_data_error_cnt, 48),
 HBG_PUSH_STATS_I(rx_align_error_cnt, 49),
 HBG_PUSH_STATS_I(rx_frame_long_err_cnt, 50),
 HBG_PUSH_STATS_I(rx_jabber_err_cnt, 51),
 HBG_PUSH_STATS_I(rx_pause_macctl_frame_cnt, 52),
 HBG_PUSH_STATS_I(rx_unknown_macctl_frame_cnt, 53),
 HBG_PUSH_STATS_I(rx_frame_very_long_err_cnt, 54),
 HBG_PUSH_STATS_I(rx_frame_runt_err_cnt, 55),
 HBG_PUSH_STATS_I(rx_frame_short_err_cnt, 56),
 HBG_PUSH_STATS_I(rx_overflow_cnt, 57),
 HBG_PUSH_STATS_I(rx_bufrq_err_cnt, 58),
 HBG_PUSH_STATS_I(rx_we_err_cnt, 59),
 HBG_PUSH_STATS_I(rx_overrun_cnt, 60),
 HBG_PUSH_STATS_I(rx_lengthfield_err_cnt, 61),
 HBG_PUSH_STATS_I(rx_fail_comma_cnt, 62),
 HBG_PUSH_STATS_I(rx_dma_err_cnt, 63),
 HBG_PUSH_STATS_I(rx_fifo_less_empty_thrsld_cnt, 64),
 HBG_PUSH_STATS_I(tx_octets_total_ok_cnt, 65),
 HBG_PUSH_STATS_I(tx_uc_pkt_cnt, 66),
 HBG_PUSH_STATS_I(tx_mc_pkt_cnt, 67),
 HBG_PUSH_STATS_I(tx_bc_pkt_cnt, 68),
 HBG_PUSH_STATS_I(tx_vlan_pkt_cnt, 69),
 HBG_PUSH_STATS_I(tx_octets_bad_cnt, 70),
 HBG_PUSH_STATS_I(tx_trans_pkt_cnt, 71),
 HBG_PUSH_STATS_I(tx_pause_frame_cnt, 72),
 HBG_PUSH_STATS_I(tx_framesize_64, 73),
 HBG_PUSH_STATS_I(tx_framesize_65_127, 74),
 HBG_PUSH_STATS_I(tx_framesize_128_255, 75),
 HBG_PUSH_STATS_I(tx_framesize_256_511, 76),
 HBG_PUSH_STATS_I(tx_framesize_512_1023, 77),
 HBG_PUSH_STATS_I(tx_framesize_1024_1518, 78),
 HBG_PUSH_STATS_I(tx_framesize_bt_1518, 79),
 HBG_PUSH_STATS_I(tx_underrun_err_cnt, 80),
 HBG_PUSH_STATS_I(tx_add_cs_fail_cnt, 81),
 HBG_PUSH_STATS_I(tx_bufrl_err_cnt, 82),
 HBG_PUSH_STATS_I(tx_crc_err_cnt, 83),
 HBG_PUSH_STATS_I(tx_drop_cnt, 84),
 HBG_PUSH_STATS_I(tx_excessive_length_drop_cnt, 85),
 HBG_PUSH_STATS_I(tx_dma_err_cnt, 86),
 HBG_PUSH_STATS_I(reset_fail_cnt, 87),
};

static int hbg_push_msg_send(struct hbg_priv *priv,
        struct hbg_diagnose_message *msg)
{
 u32 header = 0;
 u32 i;

 if (msg->data_num == 0)
  return 0;

 for (i = 0; i < msg->data_num && i < HBG_MSG_DATA_MAX_NUM; i++)
  hbg_reg_write(priv,
         HBG_REG_MSG_DATA_BASE_ADDR + i * sizeof(u32),
         msg->data[i]);

 hbg_field_modify(header, HBG_REG_MSG_HEADER_OPCODE_M, msg->opcode);
 hbg_field_modify(header, HBG_REG_MSG_HEADER_DATA_NUM_M,  msg->data_num);
 hbg_field_modify(header, HBG_REG_MSG_HEADER_RESP_CODE_M, ETIMEDOUT);

 /* start status */
 hbg_field_modify(header, HBG_REG_MSG_HEADER_STATUS_M, 1);

 /* write header msg to start push */
 hbg_reg_write(priv, HBG_REG_MSG_HEADER_ADDR, header);

 /* wait done */
 readl_poll_timeout(priv->io_base + HBG_REG_MSG_HEADER_ADDR, header,
      !FIELD_GET(HBG_REG_MSG_HEADER_STATUS_M, header),
      HBG_HW_PUSH_WAIT_INTERVAL_US,
      HBG_HW_PUSH_WAIT_TIMEOUT_US);

 msg->status = FIELD_GET(HBG_REG_MSG_HEADER_STATUS_M, header);
 return -(int)FIELD_GET(HBG_REG_MSG_HEADER_RESP_CODE_M, header);
}

static int hbg_push_data(struct hbg_priv *priv,
    u32 opcode, u32 *data, u32 data_num)
{
 struct hbg_diagnose_message msg = {0};
 u32 data_left_num;
 u32 i, j;
 int ret;

 msg.priv = priv;
 msg.opcode = opcode;
 for (i = 0; i < data_num / HBG_MSG_DATA_MAX_NUM + 1; i++) {
  if (i * HBG_MSG_DATA_MAX_NUM >= data_num)
   break;

  data_left_num = data_num - i * HBG_MSG_DATA_MAX_NUM;
  for (j = 0; j < data_left_num && j < HBG_MSG_DATA_MAX_NUM; j++)
   msg.data[j] = data[i * HBG_MSG_DATA_MAX_NUM + j];

  msg.data_num = j;
  ret = hbg_push_msg_send(priv, &msg);
  if (ret)
   return ret;
 }

 return 0;
}

static int hbg_push_data_u64(struct hbg_priv *priv, u32 opcode,
        u64 *data, u32 data_num)
{
 /* The length of u64 is twice that of u32,
 * the data_num must be multiplied by 2.
 */
 return hbg_push_data(priv, opcode, (u32 *)data, data_num * 2);
}

static u64 hbg_get_irq_stats(struct hbg_vector *vectors, u32 mask)
{
 u32 i = 0;

 for (i = 0; i < vectors->info_array_len; i++)
  if (vectors->info_array[i].mask == mask)
   return vectors->stats_array[i];

 return 0;
}

static int hbg_push_irq_cnt(struct hbg_priv *priv)
{
 /* An id needs to be added for each data.
 * Therefore, the data_num must be multiplied by 2.
 */
 u32 data_num = ARRAY_SIZE(hbg_push_irq_list) * 2;
 struct hbg_vector *vectors = &priv->vectors;
 const struct hbg_push_irq_info *info;
 u32 i, j = 0;
 u64 *data;
 int ret;

 data = kcalloc(data_num, sizeof(u64), GFP_KERNEL);
 if (!data)
  return -ENOMEM;

 /* An id needs to be added for each data.
 * So i + 2 for each loop.
 */
 for (i = 0; i < data_num; i += 2) {
  info = &hbg_push_irq_list[j++];
  data[i] = info->id;
  data[i + 1] = hbg_get_irq_stats(vectors, info->mask);
 }

 ret = hbg_push_data_u64(priv, HBG_PUSH_CMD_IRQ, data, data_num);
 kfree(data);
 return ret;
}

static int hbg_push_link_status(struct hbg_priv *priv)
{
 u32 link_status[2];

 /* phy link status */
 link_status[0] = priv->mac.phydev->link;
 /* mac link status */
 link_status[1] = hbg_reg_read_field(priv, HBG_REG_AN_NEG_STATE_ADDR,
         HBG_REG_AN_NEG_STATE_NP_LINK_OK_B);

 return hbg_push_data(priv, HBG_PUSH_CMD_LINK,
        link_status, ARRAY_SIZE(link_status));
}

static int hbg_push_stats(struct hbg_priv *priv)
{
 /* An id needs to be added for each data.
 * Therefore, the data_num must be multiplied by 2.
 */
 u64 data_num = ARRAY_SIZE(hbg_push_stats_list) * 2;
 struct hbg_stats *stats = &priv->stats;
 const struct hbg_push_stats_info *info;
 u32 i, j = 0;
 u64 *data;
 int ret;

 data = kcalloc(data_num, sizeof(u64), GFP_KERNEL);
 if (!data)
  return -ENOMEM;

 /* An id needs to be added for each data.
 * So i + 2 for each loop.
 */
 for (i = 0; i < data_num; i += 2) {
  info = &hbg_push_stats_list[j++];
  data[i] = info->id;
  data[i + 1] = HBG_STATS_R(stats, info->offset);
 }

 ret = hbg_push_data_u64(priv, HBG_PUSH_CMD_STATS, data, data_num);
 kfree(data);
 return ret;
}

void hbg_diagnose_message_push(struct hbg_priv *priv)
{
 int ret;

 if (test_bit(HBG_NIC_STATE_RESETTING, &priv->state))
  return;

 /* only 1 is the right value */
 if (hbg_reg_read(priv, HBG_REG_PUSH_REQ_ADDR) != 1)
  return;

 ret = hbg_push_irq_cnt(priv);
 if (ret) {
  dev_err(&priv->pdev->dev,
   "failed to push irq cnt, ret = %d\n", ret);
  goto push_done;
 }

 ret = hbg_push_link_status(priv);
 if (ret) {
  dev_err(&priv->pdev->dev,
   "failed to push link status, ret = %d\n", ret);
  goto push_done;
 }

 ret = hbg_push_stats(priv);
 if (ret)
  dev_err(&priv->pdev->dev,
   "failed to push stats, ret = %d\n", ret);

push_done:
 hbg_reg_write(priv, HBG_REG_PUSH_REQ_ADDR, 0);
}