drivers/net/ethernet/huawei/hinic/hinic_debugfs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Huawei HiNIC PCI Express Linux driver
   3  * Copyright(c) 2017 Huawei Technologies Co., Ltd
   4  */
   5
   6 #include <linux/debugfs.h>
   7 #include <linux/device.h>
   8
   9 #include "hinic_debugfs.h"
  10
  11 static struct dentry *hinic_dbgfs_root;
  12
  13 enum sq_dbg_info {
  14         GLB_SQ_ID,
  15         SQ_PI,
  16         SQ_CI,
  17         SQ_FI,
  18         SQ_MSIX_ENTRY,
  19 };
  20
  21 static char *sq_fields[] = {"glb_sq_id", "sq_pi", "sq_ci", "sq_fi", "sq_msix_entry"};
  22
  23 static u64 hinic_dbg_get_sq_info(struct hinic_dev *nic_dev, struct hinic_sq *sq, int idx)
  24 {
  25         struct hinic_wq *wq = sq->wq;
  26
  27         switch (idx) {
  28         case GLB_SQ_ID:
  29                 return nic_dev->hwdev->func_to_io.global_qpn + sq->qid;
  30         case SQ_PI:
  31                 return atomic_read(&wq->prod_idx) & wq->mask;
  32         case SQ_CI:
  33                 return atomic_read(&wq->cons_idx) & wq->mask;
  34         case SQ_FI:
  35                 return be16_to_cpu(*(__be16 *)(sq->hw_ci_addr)) & wq->mask;
  36         case SQ_MSIX_ENTRY:
  37                 return sq->msix_entry;
  38         }
  39
  40         return 0;
  41 }
  42
  43 enum rq_dbg_info {
  44         GLB_RQ_ID,
  45         RQ_HW_PI,
  46         RQ_SW_CI,
  47         RQ_SW_PI,
  48         RQ_MSIX_ENTRY,
  49 };
  50
  51 static char *rq_fields[] = {"glb_rq_id", "rq_hw_pi", "rq_sw_ci", "rq_sw_pi", "rq_msix_entry"};
  52
  53 static u64 hinic_dbg_get_rq_info(struct hinic_dev *nic_dev, struct hinic_rq *rq, int idx)
  54 {
  55         struct hinic_wq *wq = rq->wq;
  56
  57         switch (idx) {
  58         case GLB_RQ_ID:
  59                 return nic_dev->hwdev->func_to_io.global_qpn + rq->qid;
  60         case RQ_HW_PI:
  61                 return be16_to_cpu(*(__be16 *)(rq->pi_virt_addr)) & wq->mask;
  62         case RQ_SW_CI:
  63                 return atomic_read(&wq->cons_idx) & wq->mask;
  64         case RQ_SW_PI:
  65                 return atomic_read(&wq->prod_idx) & wq->mask;
  66         case RQ_MSIX_ENTRY:
  67                 return rq->msix_entry;
  68         }
  69
  70         return 0;
  71 }
  72
  73 enum func_tbl_info {
  74         VALID,
  75         RX_MODE,
  76         MTU,
  77         RQ_DEPTH,
  78         QUEUE_NUM,
  79 };
  80
  81 static char *func_table_fields[] = {"valid", "rx_mode", "mtu", "rq_depth", "cfg_q_num"};
  82
  83 static int hinic_dbg_get_func_table(struct hinic_dev *nic_dev, int idx)
  84 {
  85         struct tag_sml_funcfg_tbl *funcfg_table_elem;
  86         struct hinic_cmd_lt_rd *read_data;
  87         u16 out_size = sizeof(*read_data);
  88         int ret = ~0;
  89         int err;
  90
  91         read_data = kzalloc(sizeof(*read_data), GFP_KERNEL);
  92         if (!read_data)
  93                 return ~0;
  94
  95         read_data->node = TBL_ID_FUNC_CFG_SM_NODE;
  96         read_data->inst = TBL_ID_FUNC_CFG_SM_INST;
  97         read_data->entry_size = HINIC_FUNCTION_CONFIGURE_TABLE_SIZE;
  98         read_data->lt_index = HINIC_HWIF_FUNC_IDX(nic_dev->hwdev->hwif);
  99         read_data->len = HINIC_FUNCTION_CONFIGURE_TABLE_SIZE;
 100
 101         err = hinic_port_msg_cmd(nic_dev->hwdev, HINIC_PORT_CMD_RD_LINE_TBL, read_data,
 102                                  sizeof(*read_data), read_data, &out_size);
 103         if (err || out_size != sizeof(*read_data) || read_data->status) {
 104                 netif_err(nic_dev, drv, nic_dev->netdev,
 105                           "Failed to get func table, err: %d, status: 0x%x, out size: 0x%x\n",
 106                           err, read_data->status, out_size);
 107                 kfree(read_data);
 108                 return ~0;
 109         }
 110
 111         funcfg_table_elem = (struct tag_sml_funcfg_tbl *)read_data->data;
 112
 113         switch (idx) {
 114         case VALID:
 115                 ret = funcfg_table_elem->dw0.bs.valid;
 116                 break;
 117         case RX_MODE:
 118                 ret = funcfg_table_elem->dw0.bs.nic_rx_mode;
 119                 break;
 120         case MTU:
 121                 ret = funcfg_table_elem->dw1.bs.mtu;
 122                 break;
 123         case RQ_DEPTH:
 124                 ret = funcfg_table_elem->dw13.bs.cfg_rq_depth;
 125                 break;
 126         case QUEUE_NUM:
 127                 ret = funcfg_table_elem->dw13.bs.cfg_q_num;
 128                 break;
 129         }
 130
 131         kfree(read_data);
 132
 133         return ret;
 134 }
 135
 136 static ssize_t hinic_dbg_cmd_read(struct file *filp, char __user *buffer, size_t count,
 137                                   loff_t *ppos)
 138 {
 139         struct hinic_debug_priv *dbg;
 140         char ret_buf[20];
 141         int *desc;
 142         u64 out;
 143         int ret;
 144
 145         desc = filp->private_data;
 146         dbg = container_of(desc, struct hinic_debug_priv, field_id[*desc]);
 147
 148         switch (dbg->type) {
 149         case HINIC_DBG_SQ_INFO:
 150                 out = hinic_dbg_get_sq_info(dbg->dev, dbg->object, *desc);
 151                 break;
 152
 153         case HINIC_DBG_RQ_INFO:
 154                 out = hinic_dbg_get_rq_info(dbg->dev, dbg->object, *desc);
 155                 break;
 156
 157         case HINIC_DBG_FUNC_TABLE:
 158                 out = hinic_dbg_get_func_table(dbg->dev, *desc);
 159                 break;
 160
 161         default:
 162                 netif_warn(dbg->dev, drv, dbg->dev->netdev, "Invalid hinic debug cmd: %d\n",
 163                            dbg->type);
 164                 return -EINVAL;
 165         }
 166
 167         ret = snprintf(ret_buf, sizeof(ret_buf), "0x%llx\n", out);
 168
 169         return simple_read_from_buffer(buffer, count, ppos, ret_buf, ret);
 170 }
 171
 172 static const struct file_operations hinic_dbg_cmd_fops = {
 173         .owner = THIS_MODULE,
 174         .open  = simple_open,
 175         .read  = hinic_dbg_cmd_read,
 176 };
 177
 178 static int create_dbg_files(struct hinic_dev *dev, enum hinic_dbg_type type, void *data,
 179                             struct dentry *root, struct hinic_debug_priv **dbg, char **field,
 180                             int nfile)
 181 {
 182         struct hinic_debug_priv *tmp;
 183         int i;
 184
 185         tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
 186         if (!tmp)
 187                 return -ENOMEM;
 188
 189         tmp->dev = dev;
 190         tmp->object = data;
 191         tmp->type = type;
 192         tmp->root = root;
 193
 194         for (i = 0; i < nfile; i++) {
 195                 tmp->field_id[i] = i;
 196                 debugfs_create_file(field[i], 0400, root, &tmp->field_id[i], &hinic_dbg_cmd_fops);
 197         }
 198
 199         *dbg = tmp;
 200
 201         return 0;
 202 }
 203
 204 static void rem_dbg_files(struct hinic_debug_priv *dbg)
 205 {
 206         if (dbg->type != HINIC_DBG_FUNC_TABLE)
 207                 debugfs_remove_recursive(dbg->root);
 208
 209         kfree(dbg);
 210 }
 211
 212 int hinic_sq_debug_add(struct hinic_dev *dev, u16 sq_id)
 213 {
 214         struct hinic_sq *sq;
 215         struct dentry *root;
 216         char sub_dir[16];
 217
 218         sq = dev->txqs[sq_id].sq;
 219
 220         sprintf(sub_dir, "0x%x", sq_id);
 221
 222         root = debugfs_create_dir(sub_dir, dev->sq_dbgfs);
 223
 224         return create_dbg_files(dev, HINIC_DBG_SQ_INFO, sq, root, &sq->dbg, sq_fields,
 225                                 ARRAY_SIZE(sq_fields));
 226 }
 227
 228 void hinic_sq_debug_rem(struct hinic_sq *sq)
 229 {
 230         if (sq->dbg)
 231                 rem_dbg_files(sq->dbg);
 232 }
 233
 234 int hinic_rq_debug_add(struct hinic_dev *dev, u16 rq_id)
 235 {
 236         struct hinic_rq *rq;
 237         struct dentry *root;
 238         char sub_dir[16];
 239
 240         rq = dev->rxqs[rq_id].rq;
 241
 242         sprintf(sub_dir, "0x%x", rq_id);
 243
 244         root = debugfs_create_dir(sub_dir, dev->rq_dbgfs);
 245
 246         return create_dbg_files(dev, HINIC_DBG_RQ_INFO, rq, root, &rq->dbg, rq_fields,
 247                                 ARRAY_SIZE(rq_fields));
 248 }
 249
 250 void hinic_rq_debug_rem(struct hinic_rq *rq)
 251 {
 252         if (rq->dbg)
 253                 rem_dbg_files(rq->dbg);
 254 }
 255
 256 int hinic_func_table_debug_add(struct hinic_dev *dev)
 257 {
 258         if (HINIC_IS_VF(dev->hwdev->hwif))
 259                 return 0;
 260
 261         return create_dbg_files(dev, HINIC_DBG_FUNC_TABLE, dev, dev->func_tbl_dbgfs, &dev->dbg,
 262                                 func_table_fields, ARRAY_SIZE(func_table_fields));
 263 }
 264
 265 void hinic_func_table_debug_rem(struct hinic_dev *dev)
 266 {
 267         if (!HINIC_IS_VF(dev->hwdev->hwif) && dev->dbg)
 268                 rem_dbg_files(dev->dbg);
 269 }
 270
 271 void hinic_sq_dbgfs_init(struct hinic_dev *nic_dev)
 272 {
 273         nic_dev->sq_dbgfs = debugfs_create_dir("SQs", nic_dev->dbgfs_root);
 274 }
 275
 276 void hinic_sq_dbgfs_uninit(struct hinic_dev *nic_dev)
 277 {
 278         debugfs_remove_recursive(nic_dev->sq_dbgfs);
 279 }
 280
 281 void hinic_rq_dbgfs_init(struct hinic_dev *nic_dev)
 282 {
 283         nic_dev->rq_dbgfs = debugfs_create_dir("RQs", nic_dev->dbgfs_root);
 284 }
 285
 286 void hinic_rq_dbgfs_uninit(struct hinic_dev *nic_dev)
 287 {
 288         debugfs_remove_recursive(nic_dev->rq_dbgfs);
 289 }
 290
 291 void hinic_func_tbl_dbgfs_init(struct hinic_dev *nic_dev)
 292 {
 293         if (!HINIC_IS_VF(nic_dev->hwdev->hwif))
 294                 nic_dev->func_tbl_dbgfs = debugfs_create_dir("func_table", nic_dev->dbgfs_root);
 295 }
 296
 297 void hinic_func_tbl_dbgfs_uninit(struct hinic_dev *nic_dev)
 298 {
 299         if (!HINIC_IS_VF(nic_dev->hwdev->hwif))
 300                 debugfs_remove_recursive(nic_dev->func_tbl_dbgfs);
 301 }
 302
 303 void hinic_dbg_init(struct hinic_dev *nic_dev)
 304 {
 305         nic_dev->dbgfs_root = debugfs_create_dir(pci_name(nic_dev->hwdev->hwif->pdev),
 306                                                  hinic_dbgfs_root);
 307 }
 308
 309 void hinic_dbg_uninit(struct hinic_dev *nic_dev)
 310 {
 311         debugfs_remove_recursive(nic_dev->dbgfs_root);
 312         nic_dev->dbgfs_root = NULL;
 313 }
 314
 315 void hinic_dbg_register_debugfs(const char *debugfs_dir_name)
 316 {
 317         hinic_dbgfs_root = debugfs_create_dir(debugfs_dir_name, NULL);
 318 }
 319
 320 void hinic_dbg_unregister_debugfs(void)
 321 {
 322         debugfs_remove_recursive(hinic_dbgfs_root);
 323         hinic_dbgfs_root = NULL;
 324 }