1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2022 HiSilicon Limited. */ 3 #include <linux/hisi_acc_qm.h> 4 #include "qm_common.h" 5 6 #define QM_DFX_BASE 0x0100000 7 #define QM_DFX_STATE1 0x0104000 8 #define QM_DFX_STATE2 0x01040C8 9 #define QM_DFX_COMMON 0x0000 10 #define QM_DFX_BASE_LEN 0x5A 11 #define QM_DFX_STATE1_LEN 0x2E 12 #define QM_DFX_STATE2_LEN 0x11 13 #define QM_DFX_COMMON_LEN 0xC3 14 #define QM_DFX_REGS_LEN 4UL 15 #define QM_DBG_TMP_BUF_LEN 22 16 #define CURRENT_FUN_MASK GENMASK(5, 0) 17 #define CURRENT_Q_MASK GENMASK(31, 16) 18 #define QM_SQE_ADDR_MASK GENMASK(7, 0) 19 20 #define QM_DFX_MB_CNT_VF 0x104010 21 #define QM_DFX_DB_CNT_VF 0x104020 22 #define QM_DFX_SQE_CNT_VF_SQN 0x104030 23 #define QM_DFX_CQE_CNT_VF_CQN 0x104040 24 #define QM_DFX_QN_SHIFT 16 25 #define QM_DFX_CNT_CLR_CE 0x100118 26 #define QM_DBG_WRITE_LEN 1024 27 28 static const char * const qm_debug_file_name[] = { 29 [CURRENT_QM] = "current_qm", 30 [CURRENT_Q] = "current_q", 31 [CLEAR_ENABLE] = "clear_enable", 32 }; 33 34 struct qm_dfx_item { 35 const char *name; 36 u32 offset; 37 }; 38 39 struct qm_cmd_dump_item { 40 const char *cmd; 41 char *info_name; 42 int (*dump_fn)(struct hisi_qm *qm, char *cmd, char *info_name); 43 }; 44 45 static struct qm_dfx_item qm_dfx_files[] = { 46 {"err_irq", offsetof(struct qm_dfx, err_irq_cnt)}, 47 {"aeq_irq", offsetof(struct qm_dfx, aeq_irq_cnt)}, 48 {"abnormal_irq", offsetof(struct qm_dfx, abnormal_irq_cnt)}, 49 {"create_qp_err", offsetof(struct qm_dfx, create_qp_err_cnt)}, 50 {"mb_err", offsetof(struct qm_dfx, mb_err_cnt)}, 51 }; 52 53 #define CNT_CYC_REGS_NUM 10 54 static const struct debugfs_reg32 qm_dfx_regs[] = { 55 /* XXX_CNT are reading clear register */ 56 {"QM_ECC_1BIT_CNT ", 0x104000ull}, 57 {"QM_ECC_MBIT_CNT ", 0x104008ull}, 58 {"QM_DFX_MB_CNT ", 0x104018ull}, 59 {"QM_DFX_DB_CNT ", 0x104028ull}, 60 {"QM_DFX_SQE_CNT ", 0x104038ull}, 61 {"QM_DFX_CQE_CNT ", 0x104048ull}, 62 {"QM_DFX_SEND_SQE_TO_ACC_CNT ", 0x104050ull}, 63 {"QM_DFX_WB_SQE_FROM_ACC_CNT ", 0x104058ull}, 64 {"QM_DFX_ACC_FINISH_CNT ", 0x104060ull}, 65 {"QM_DFX_CQE_ERR_CNT ", 0x1040b4ull}, 66 {"QM_DFX_FUNS_ACTIVE_ST ", 0x200ull}, 67 {"QM_ECC_1BIT_INF ", 0x104004ull}, 68 {"QM_ECC_MBIT_INF ", 0x10400cull}, 69 {"QM_DFX_ACC_RDY_VLD0 ", 0x1040a0ull}, 70 {"QM_DFX_ACC_RDY_VLD1 ", 0x1040a4ull}, 71 {"QM_DFX_AXI_RDY_VLD ", 0x1040a8ull}, 72 {"QM_DFX_FF_ST0 ", 0x1040c8ull}, 73 {"QM_DFX_FF_ST1 ", 0x1040ccull}, 74 {"QM_DFX_FF_ST2 ", 0x1040d0ull}, 75 {"QM_DFX_FF_ST3 ", 0x1040d4ull}, 76 {"QM_DFX_FF_ST4 ", 0x1040d8ull}, 77 {"QM_DFX_FF_ST5 ", 0x1040dcull}, 78 {"QM_DFX_FF_ST6 ", 0x1040e0ull}, 79 {"QM_IN_IDLE_ST ", 0x1040e4ull}, 80 }; 81 82 static const struct debugfs_reg32 qm_vf_dfx_regs[] = { 83 {"QM_DFX_FUNS_ACTIVE_ST ", 0x200ull}, 84 }; 85 86 /* define the QM's dfx regs region and region length */ 87 static struct dfx_diff_registers qm_diff_regs[] = { 88 { 89 .reg_offset = QM_DFX_BASE, 90 .reg_len = QM_DFX_BASE_LEN, 91 }, { 92 .reg_offset = QM_DFX_STATE1, 93 .reg_len = QM_DFX_STATE1_LEN, 94 }, { 95 .reg_offset = QM_DFX_STATE2, 96 .reg_len = QM_DFX_STATE2_LEN, 97 }, { 98 .reg_offset = QM_DFX_COMMON, 99 .reg_len = QM_DFX_COMMON_LEN, 100 }, 101 }; 102 103 static struct hisi_qm *file_to_qm(struct debugfs_file *file) 104 { 105 struct qm_debug *debug = file->debug; 106 107 return container_of(debug, struct hisi_qm, debug); 108 } 109 110 static ssize_t qm_cmd_read(struct file *filp, char __user *buffer, 111 size_t count, loff_t *pos) 112 { 113 char buf[QM_DBG_READ_LEN]; 114 int len; 115 116 len = scnprintf(buf, QM_DBG_READ_LEN, "%s\n", 117 "Please echo help to cmd to get help information"); 118 119 return simple_read_from_buffer(buffer, count, pos, buf, len); 120 } 121 122 static void dump_show(struct hisi_qm *qm, void *info, 123 unsigned int info_size, char *info_name) 124 { 125 struct device *dev = &qm->pdev->dev; 126 u8 *info_curr = info; 127 u32 i; 128 #define BYTE_PER_DW 4 129 130 dev_info(dev, "%s DUMP\n", info_name); 131 for (i = 0; i < info_size; i += BYTE_PER_DW, info_curr += BYTE_PER_DW) { 132 pr_info("DW%u: %02X%02X %02X%02X\n", i / BYTE_PER_DW, 133 *(info_curr + 3), *(info_curr + 2), *(info_curr + 1), *(info_curr)); 134 } 135 } 136 137 static int qm_sqc_dump(struct hisi_qm *qm, char *s, char *name) 138 { 139 struct device *dev = &qm->pdev->dev; 140 struct qm_sqc *sqc, *sqc_curr; 141 dma_addr_t sqc_dma; 142 u32 qp_id; 143 int ret; 144 145 if (!s) 146 return -EINVAL; 147 148 ret = kstrtou32(s, 0, &qp_id); 149 if (ret || qp_id >= qm->qp_num) { 150 dev_err(dev, "Please input qp num (0-%u)", qm->qp_num - 1); 151 return -EINVAL; 152 } 153 154 sqc = hisi_qm_ctx_alloc(qm, sizeof(*sqc), &sqc_dma); 155 if (IS_ERR(sqc)) 156 return PTR_ERR(sqc); 157 158 ret = hisi_qm_mb(qm, QM_MB_CMD_SQC, sqc_dma, qp_id, 1); 159 if (ret) { 160 down_read(&qm->qps_lock); 161 if (qm->sqc) { 162 sqc_curr = qm->sqc + qp_id; 163 164 dump_show(qm, sqc_curr, sizeof(*sqc), "SOFT SQC"); 165 } 166 up_read(&qm->qps_lock); 167 168 goto free_ctx; 169 } 170 171 dump_show(qm, sqc, sizeof(*sqc), name); 172 173 free_ctx: 174 hisi_qm_ctx_free(qm, sizeof(*sqc), sqc, &sqc_dma); 175 return 0; 176 } 177 178 static int qm_cqc_dump(struct hisi_qm *qm, char *s, char *name) 179 { 180 struct device *dev = &qm->pdev->dev; 181 struct qm_cqc *cqc, *cqc_curr; 182 dma_addr_t cqc_dma; 183 u32 qp_id; 184 int ret; 185 186 if (!s) 187 return -EINVAL; 188 189 ret = kstrtou32(s, 0, &qp_id); 190 if (ret || qp_id >= qm->qp_num) { 191 dev_err(dev, "Please input qp num (0-%u)", qm->qp_num - 1); 192 return -EINVAL; 193 } 194 195 cqc = hisi_qm_ctx_alloc(qm, sizeof(*cqc), &cqc_dma); 196 if (IS_ERR(cqc)) 197 return PTR_ERR(cqc); 198 199 ret = hisi_qm_mb(qm, QM_MB_CMD_CQC, cqc_dma, qp_id, 1); 200 if (ret) { 201 down_read(&qm->qps_lock); 202 if (qm->cqc) { 203 cqc_curr = qm->cqc + qp_id; 204 205 dump_show(qm, cqc_curr, sizeof(*cqc), "SOFT CQC"); 206 } 207 up_read(&qm->qps_lock); 208 209 goto free_ctx; 210 } 211 212 dump_show(qm, cqc, sizeof(*cqc), name); 213 214 free_ctx: 215 hisi_qm_ctx_free(qm, sizeof(*cqc), cqc, &cqc_dma); 216 return 0; 217 } 218 219 static int qm_eqc_aeqc_dump(struct hisi_qm *qm, char *s, char *name) 220 { 221 struct device *dev = &qm->pdev->dev; 222 dma_addr_t xeqc_dma; 223 size_t size; 224 void *xeqc; 225 int ret; 226 u8 cmd; 227 228 if (strsep(&s, " ")) { 229 dev_err(dev, "Please do not input extra characters!\n"); 230 return -EINVAL; 231 } 232 233 if (!strcmp(name, "EQC")) { 234 cmd = QM_MB_CMD_EQC; 235 size = sizeof(struct qm_eqc); 236 } else { 237 cmd = QM_MB_CMD_AEQC; 238 size = sizeof(struct qm_aeqc); 239 } 240 241 xeqc = hisi_qm_ctx_alloc(qm, size, &xeqc_dma); 242 if (IS_ERR(xeqc)) 243 return PTR_ERR(xeqc); 244 245 ret = hisi_qm_mb(qm, cmd, xeqc_dma, 0, 1); 246 if (ret) 247 goto err_free_ctx; 248 249 dump_show(qm, xeqc, size, name); 250 251 err_free_ctx: 252 hisi_qm_ctx_free(qm, size, xeqc, &xeqc_dma); 253 return ret; 254 } 255 256 static int q_dump_param_parse(struct hisi_qm *qm, char *s, 257 u32 *e_id, u32 *q_id, u16 q_depth) 258 { 259 struct device *dev = &qm->pdev->dev; 260 unsigned int qp_num = qm->qp_num; 261 char *presult; 262 int ret; 263 264 presult = strsep(&s, " "); 265 if (!presult) { 266 dev_err(dev, "Please input qp number!\n"); 267 return -EINVAL; 268 } 269 270 ret = kstrtou32(presult, 0, q_id); 271 if (ret || *q_id >= qp_num) { 272 dev_err(dev, "Please input qp num (0-%u)", qp_num - 1); 273 return -EINVAL; 274 } 275 276 presult = strsep(&s, " "); 277 if (!presult) { 278 dev_err(dev, "Please input sqe number!\n"); 279 return -EINVAL; 280 } 281 282 ret = kstrtou32(presult, 0, e_id); 283 if (ret || *e_id >= q_depth) { 284 dev_err(dev, "Please input sqe num (0-%u)", q_depth - 1); 285 return -EINVAL; 286 } 287 288 if (strsep(&s, " ")) { 289 dev_err(dev, "Please do not input extra characters!\n"); 290 return -EINVAL; 291 } 292 293 return 0; 294 } 295 296 static int qm_sq_dump(struct hisi_qm *qm, char *s, char *name) 297 { 298 u16 sq_depth = qm->qp_array->cq_depth; 299 void *sqe, *sqe_curr; 300 struct hisi_qp *qp; 301 u32 qp_id, sqe_id; 302 int ret; 303 304 ret = q_dump_param_parse(qm, s, &sqe_id, &qp_id, sq_depth); 305 if (ret) 306 return ret; 307 308 sqe = kzalloc(qm->sqe_size * sq_depth, GFP_KERNEL); 309 if (!sqe) 310 return -ENOMEM; 311 312 qp = &qm->qp_array[qp_id]; 313 memcpy(sqe, qp->sqe, qm->sqe_size * sq_depth); 314 sqe_curr = sqe + (u32)(sqe_id * qm->sqe_size); 315 memset(sqe_curr + qm->debug.sqe_mask_offset, QM_SQE_ADDR_MASK, 316 qm->debug.sqe_mask_len); 317 318 dump_show(qm, sqe_curr, qm->sqe_size, name); 319 320 kfree(sqe); 321 322 return 0; 323 } 324 325 static int qm_cq_dump(struct hisi_qm *qm, char *s, char *name) 326 { 327 struct qm_cqe *cqe_curr; 328 struct hisi_qp *qp; 329 u32 qp_id, cqe_id; 330 int ret; 331 332 ret = q_dump_param_parse(qm, s, &cqe_id, &qp_id, qm->qp_array->cq_depth); 333 if (ret) 334 return ret; 335 336 qp = &qm->qp_array[qp_id]; 337 cqe_curr = qp->cqe + cqe_id; 338 dump_show(qm, cqe_curr, sizeof(struct qm_cqe), name); 339 340 return 0; 341 } 342 343 static int qm_eq_aeq_dump(struct hisi_qm *qm, char *s, char *name) 344 { 345 struct device *dev = &qm->pdev->dev; 346 u16 xeq_depth; 347 size_t size; 348 void *xeqe; 349 u32 xeqe_id; 350 int ret; 351 352 if (!s) 353 return -EINVAL; 354 355 ret = kstrtou32(s, 0, &xeqe_id); 356 if (ret) 357 return -EINVAL; 358 359 if (!strcmp(name, "EQE")) { 360 xeq_depth = qm->eq_depth; 361 size = sizeof(struct qm_eqe); 362 } else { 363 xeq_depth = qm->aeq_depth; 364 size = sizeof(struct qm_aeqe); 365 } 366 367 if (xeqe_id >= xeq_depth) { 368 dev_err(dev, "Please input eqe or aeqe num (0-%u)", xeq_depth - 1); 369 return -EINVAL; 370 } 371 372 down_read(&qm->qps_lock); 373 374 if (qm->eqe && !strcmp(name, "EQE")) { 375 xeqe = qm->eqe + xeqe_id; 376 } else if (qm->aeqe && !strcmp(name, "AEQE")) { 377 xeqe = qm->aeqe + xeqe_id; 378 } else { 379 ret = -EINVAL; 380 goto err_unlock; 381 } 382 383 dump_show(qm, xeqe, size, name); 384 385 err_unlock: 386 up_read(&qm->qps_lock); 387 return ret; 388 } 389 390 static int qm_dbg_help(struct hisi_qm *qm, char *s) 391 { 392 struct device *dev = &qm->pdev->dev; 393 394 if (strsep(&s, " ")) { 395 dev_err(dev, "Please do not input extra characters!\n"); 396 return -EINVAL; 397 } 398 399 dev_info(dev, "available commands:\n"); 400 dev_info(dev, "sqc <num>\n"); 401 dev_info(dev, "cqc <num>\n"); 402 dev_info(dev, "eqc\n"); 403 dev_info(dev, "aeqc\n"); 404 dev_info(dev, "sq <num> <e>\n"); 405 dev_info(dev, "cq <num> <e>\n"); 406 dev_info(dev, "eq <e>\n"); 407 dev_info(dev, "aeq <e>\n"); 408 409 return 0; 410 } 411 412 static const struct qm_cmd_dump_item qm_cmd_dump_table[] = { 413 { 414 .cmd = "sqc", 415 .info_name = "SQC", 416 .dump_fn = qm_sqc_dump, 417 }, { 418 .cmd = "cqc", 419 .info_name = "CQC", 420 .dump_fn = qm_cqc_dump, 421 }, { 422 .cmd = "eqc", 423 .info_name = "EQC", 424 .dump_fn = qm_eqc_aeqc_dump, 425 }, { 426 .cmd = "aeqc", 427 .info_name = "AEQC", 428 .dump_fn = qm_eqc_aeqc_dump, 429 }, { 430 .cmd = "sq", 431 .info_name = "SQE", 432 .dump_fn = qm_sq_dump, 433 }, { 434 .cmd = "cq", 435 .info_name = "CQE", 436 .dump_fn = qm_cq_dump, 437 }, { 438 .cmd = "eq", 439 .info_name = "EQE", 440 .dump_fn = qm_eq_aeq_dump, 441 }, { 442 .cmd = "aeq", 443 .info_name = "AEQE", 444 .dump_fn = qm_eq_aeq_dump, 445 }, 446 }; 447 448 static int qm_cmd_write_dump(struct hisi_qm *qm, const char *cmd_buf) 449 { 450 struct device *dev = &qm->pdev->dev; 451 char *presult, *s, *s_tmp; 452 int table_size, i, ret; 453 454 s = kstrdup(cmd_buf, GFP_KERNEL); 455 if (!s) 456 return -ENOMEM; 457 458 s_tmp = s; 459 presult = strsep(&s, " "); 460 if (!presult) { 461 ret = -EINVAL; 462 goto err_buffer_free; 463 } 464 465 if (!strcmp(presult, "help")) { 466 ret = qm_dbg_help(qm, s); 467 goto err_buffer_free; 468 } 469 470 table_size = ARRAY_SIZE(qm_cmd_dump_table); 471 for (i = 0; i < table_size; i++) { 472 if (!strcmp(presult, qm_cmd_dump_table[i].cmd)) { 473 ret = qm_cmd_dump_table[i].dump_fn(qm, s, 474 qm_cmd_dump_table[i].info_name); 475 break; 476 } 477 } 478 479 if (i == table_size) { 480 dev_info(dev, "Please echo help\n"); 481 ret = -EINVAL; 482 } 483 484 err_buffer_free: 485 kfree(s_tmp); 486 487 return ret; 488 } 489 490 static ssize_t qm_cmd_write(struct file *filp, const char __user *buffer, 491 size_t count, loff_t *pos) 492 { 493 struct hisi_qm *qm = filp->private_data; 494 char *cmd_buf, *cmd_buf_tmp; 495 int ret; 496 497 if (*pos) 498 return 0; 499 500 ret = hisi_qm_get_dfx_access(qm); 501 if (ret) 502 return ret; 503 504 /* Judge if the instance is being reset. */ 505 if (unlikely(atomic_read(&qm->status.flags) == QM_STOP)) { 506 ret = 0; 507 goto put_dfx_access; 508 } 509 510 if (count > QM_DBG_WRITE_LEN) { 511 ret = -ENOSPC; 512 goto put_dfx_access; 513 } 514 515 cmd_buf = memdup_user_nul(buffer, count); 516 if (IS_ERR(cmd_buf)) { 517 ret = PTR_ERR(cmd_buf); 518 goto put_dfx_access; 519 } 520 521 cmd_buf_tmp = strchr(cmd_buf, '\n'); 522 if (cmd_buf_tmp) { 523 *cmd_buf_tmp = '\0'; 524 count = cmd_buf_tmp - cmd_buf + 1; 525 } 526 527 ret = qm_cmd_write_dump(qm, cmd_buf); 528 if (ret) { 529 kfree(cmd_buf); 530 goto put_dfx_access; 531 } 532 533 kfree(cmd_buf); 534 535 ret = count; 536 537 put_dfx_access: 538 hisi_qm_put_dfx_access(qm); 539 return ret; 540 } 541 542 static const struct file_operations qm_cmd_fops = { 543 .owner = THIS_MODULE, 544 .open = simple_open, 545 .read = qm_cmd_read, 546 .write = qm_cmd_write, 547 }; 548 549 /** 550 * hisi_qm_regs_dump() - Dump registers's value. 551 * @s: debugfs file handle. 552 * @regset: accelerator registers information. 553 * 554 * Dump accelerator registers. 555 */ 556 void hisi_qm_regs_dump(struct seq_file *s, struct debugfs_regset32 *regset) 557 { 558 struct pci_dev *pdev = to_pci_dev(regset->dev); 559 struct hisi_qm *qm = pci_get_drvdata(pdev); 560 const struct debugfs_reg32 *regs = regset->regs; 561 int regs_len = regset->nregs; 562 int i, ret; 563 u32 val; 564 565 ret = hisi_qm_get_dfx_access(qm); 566 if (ret) 567 return; 568 569 for (i = 0; i < regs_len; i++) { 570 val = readl(regset->base + regs[i].offset); 571 seq_printf(s, "%s= 0x%08x\n", regs[i].name, val); 572 } 573 574 hisi_qm_put_dfx_access(qm); 575 } 576 EXPORT_SYMBOL_GPL(hisi_qm_regs_dump); 577 578 static int qm_regs_show(struct seq_file *s, void *unused) 579 { 580 struct hisi_qm *qm = s->private; 581 struct debugfs_regset32 regset; 582 583 if (qm->fun_type == QM_HW_PF) { 584 regset.regs = qm_dfx_regs; 585 regset.nregs = ARRAY_SIZE(qm_dfx_regs); 586 } else { 587 regset.regs = qm_vf_dfx_regs; 588 regset.nregs = ARRAY_SIZE(qm_vf_dfx_regs); 589 } 590 591 regset.base = qm->io_base; 592 regset.dev = &qm->pdev->dev; 593 594 hisi_qm_regs_dump(s, ®set); 595 596 return 0; 597 } 598 599 DEFINE_SHOW_ATTRIBUTE(qm_regs); 600 601 static u32 current_q_read(struct hisi_qm *qm) 602 { 603 return readl(qm->io_base + QM_DFX_SQE_CNT_VF_SQN) >> QM_DFX_QN_SHIFT; 604 } 605 606 static int current_q_write(struct hisi_qm *qm, u32 val) 607 { 608 u32 tmp; 609 610 if (val >= qm->debug.curr_qm_qp_num) 611 return -EINVAL; 612 613 tmp = val << QM_DFX_QN_SHIFT | 614 (readl(qm->io_base + QM_DFX_SQE_CNT_VF_SQN) & CURRENT_FUN_MASK); 615 writel(tmp, qm->io_base + QM_DFX_SQE_CNT_VF_SQN); 616 617 tmp = val << QM_DFX_QN_SHIFT | 618 (readl(qm->io_base + QM_DFX_CQE_CNT_VF_CQN) & CURRENT_FUN_MASK); 619 writel(tmp, qm->io_base + QM_DFX_CQE_CNT_VF_CQN); 620 621 return 0; 622 } 623 624 static u32 clear_enable_read(struct hisi_qm *qm) 625 { 626 return readl(qm->io_base + QM_DFX_CNT_CLR_CE); 627 } 628 629 /* rd_clr_ctrl 1 enable read clear, otherwise 0 disable it */ 630 static int clear_enable_write(struct hisi_qm *qm, u32 rd_clr_ctrl) 631 { 632 if (rd_clr_ctrl > 1) 633 return -EINVAL; 634 635 writel(rd_clr_ctrl, qm->io_base + QM_DFX_CNT_CLR_CE); 636 637 return 0; 638 } 639 640 static u32 current_qm_read(struct hisi_qm *qm) 641 { 642 return readl(qm->io_base + QM_DFX_MB_CNT_VF); 643 } 644 645 static int qm_get_vf_qp_num(struct hisi_qm *qm, u32 fun_num) 646 { 647 u32 remain_q_num, vfq_num; 648 u32 num_vfs = qm->vfs_num; 649 650 vfq_num = (qm->ctrl_qp_num - qm->qp_num) / num_vfs; 651 if (vfq_num >= qm->max_qp_num) 652 return qm->max_qp_num; 653 654 remain_q_num = (qm->ctrl_qp_num - qm->qp_num) % num_vfs; 655 if (vfq_num + remain_q_num <= qm->max_qp_num) 656 return fun_num == num_vfs ? vfq_num + remain_q_num : vfq_num; 657 658 /* 659 * if vfq_num + remain_q_num > max_qp_num, the last VFs, 660 * each with one more queue. 661 */ 662 return fun_num + remain_q_num > num_vfs ? vfq_num + 1 : vfq_num; 663 } 664 665 static int current_qm_write(struct hisi_qm *qm, u32 val) 666 { 667 u32 tmp; 668 669 if (val > qm->vfs_num) 670 return -EINVAL; 671 672 /* According PF or VF Dev ID to calculation curr_qm_qp_num and store */ 673 if (!val) 674 qm->debug.curr_qm_qp_num = qm->qp_num; 675 else 676 qm->debug.curr_qm_qp_num = qm_get_vf_qp_num(qm, val); 677 678 writel(val, qm->io_base + QM_DFX_MB_CNT_VF); 679 writel(val, qm->io_base + QM_DFX_DB_CNT_VF); 680 681 tmp = val | 682 (readl(qm->io_base + QM_DFX_SQE_CNT_VF_SQN) & CURRENT_Q_MASK); 683 writel(tmp, qm->io_base + QM_DFX_SQE_CNT_VF_SQN); 684 685 tmp = val | 686 (readl(qm->io_base + QM_DFX_CQE_CNT_VF_CQN) & CURRENT_Q_MASK); 687 writel(tmp, qm->io_base + QM_DFX_CQE_CNT_VF_CQN); 688 689 return 0; 690 } 691 692 static ssize_t qm_debug_read(struct file *filp, char __user *buf, 693 size_t count, loff_t *pos) 694 { 695 struct debugfs_file *file = filp->private_data; 696 enum qm_debug_file index = file->index; 697 struct hisi_qm *qm = file_to_qm(file); 698 char tbuf[QM_DBG_TMP_BUF_LEN]; 699 u32 val; 700 int ret; 701 702 ret = hisi_qm_get_dfx_access(qm); 703 if (ret) 704 return ret; 705 706 mutex_lock(&file->lock); 707 switch (index) { 708 case CURRENT_QM: 709 val = current_qm_read(qm); 710 break; 711 case CURRENT_Q: 712 val = current_q_read(qm); 713 break; 714 case CLEAR_ENABLE: 715 val = clear_enable_read(qm); 716 break; 717 default: 718 goto err_input; 719 } 720 mutex_unlock(&file->lock); 721 722 hisi_qm_put_dfx_access(qm); 723 ret = scnprintf(tbuf, QM_DBG_TMP_BUF_LEN, "%u\n", val); 724 return simple_read_from_buffer(buf, count, pos, tbuf, ret); 725 726 err_input: 727 mutex_unlock(&file->lock); 728 hisi_qm_put_dfx_access(qm); 729 return -EINVAL; 730 } 731 732 static ssize_t qm_debug_write(struct file *filp, const char __user *buf, 733 size_t count, loff_t *pos) 734 { 735 struct debugfs_file *file = filp->private_data; 736 enum qm_debug_file index = file->index; 737 struct hisi_qm *qm = file_to_qm(file); 738 unsigned long val; 739 char tbuf[QM_DBG_TMP_BUF_LEN]; 740 int len, ret; 741 742 if (*pos != 0) 743 return 0; 744 745 if (count >= QM_DBG_TMP_BUF_LEN) 746 return -ENOSPC; 747 748 len = simple_write_to_buffer(tbuf, QM_DBG_TMP_BUF_LEN - 1, pos, buf, 749 count); 750 if (len < 0) 751 return len; 752 753 tbuf[len] = '\0'; 754 if (kstrtoul(tbuf, 0, &val)) 755 return -EFAULT; 756 757 ret = hisi_qm_get_dfx_access(qm); 758 if (ret) 759 return ret; 760 761 mutex_lock(&file->lock); 762 switch (index) { 763 case CURRENT_QM: 764 ret = current_qm_write(qm, val); 765 break; 766 case CURRENT_Q: 767 ret = current_q_write(qm, val); 768 break; 769 case CLEAR_ENABLE: 770 ret = clear_enable_write(qm, val); 771 break; 772 default: 773 ret = -EINVAL; 774 } 775 mutex_unlock(&file->lock); 776 777 hisi_qm_put_dfx_access(qm); 778 779 if (ret) 780 return ret; 781 782 return count; 783 } 784 785 static const struct file_operations qm_debug_fops = { 786 .owner = THIS_MODULE, 787 .open = simple_open, 788 .read = qm_debug_read, 789 .write = qm_debug_write, 790 }; 791 792 static void dfx_regs_uninit(struct hisi_qm *qm, 793 struct dfx_diff_registers *dregs, int reg_len) 794 { 795 int i; 796 797 if (!dregs) 798 return; 799 800 /* Setting the pointer is NULL to prevent double free */ 801 for (i = 0; i < reg_len; i++) { 802 if (!dregs[i].regs) 803 continue; 804 805 kfree(dregs[i].regs); 806 dregs[i].regs = NULL; 807 } 808 kfree(dregs); 809 } 810 811 static struct dfx_diff_registers *dfx_regs_init(struct hisi_qm *qm, 812 const struct dfx_diff_registers *cregs, u32 reg_len) 813 { 814 struct dfx_diff_registers *diff_regs; 815 u32 j, base_offset; 816 int i; 817 818 diff_regs = kcalloc(reg_len, sizeof(*diff_regs), GFP_KERNEL); 819 if (!diff_regs) 820 return ERR_PTR(-ENOMEM); 821 822 for (i = 0; i < reg_len; i++) { 823 if (!cregs[i].reg_len) 824 continue; 825 826 diff_regs[i].reg_offset = cregs[i].reg_offset; 827 diff_regs[i].reg_len = cregs[i].reg_len; 828 diff_regs[i].regs = kcalloc(QM_DFX_REGS_LEN, cregs[i].reg_len, 829 GFP_KERNEL); 830 if (!diff_regs[i].regs) 831 goto alloc_error; 832 833 for (j = 0; j < diff_regs[i].reg_len; j++) { 834 base_offset = diff_regs[i].reg_offset + 835 j * QM_DFX_REGS_LEN; 836 diff_regs[i].regs[j] = readl(qm->io_base + base_offset); 837 } 838 } 839 840 return diff_regs; 841 842 alloc_error: 843 while (i > 0) { 844 i--; 845 kfree(diff_regs[i].regs); 846 } 847 kfree(diff_regs); 848 return ERR_PTR(-ENOMEM); 849 } 850 851 static int qm_diff_regs_init(struct hisi_qm *qm, 852 struct dfx_diff_registers *dregs, u32 reg_len) 853 { 854 int ret; 855 856 qm->debug.qm_diff_regs = dfx_regs_init(qm, qm_diff_regs, ARRAY_SIZE(qm_diff_regs)); 857 if (IS_ERR(qm->debug.qm_diff_regs)) { 858 ret = PTR_ERR(qm->debug.qm_diff_regs); 859 qm->debug.qm_diff_regs = NULL; 860 return ret; 861 } 862 863 qm->debug.acc_diff_regs = dfx_regs_init(qm, dregs, reg_len); 864 if (IS_ERR(qm->debug.acc_diff_regs)) { 865 dfx_regs_uninit(qm, qm->debug.qm_diff_regs, ARRAY_SIZE(qm_diff_regs)); 866 ret = PTR_ERR(qm->debug.acc_diff_regs); 867 qm->debug.acc_diff_regs = NULL; 868 return ret; 869 } 870 871 return 0; 872 } 873 874 static void qm_last_regs_uninit(struct hisi_qm *qm) 875 { 876 struct qm_debug *debug = &qm->debug; 877 878 if (qm->fun_type == QM_HW_VF || !debug->qm_last_words) 879 return; 880 881 kfree(debug->qm_last_words); 882 debug->qm_last_words = NULL; 883 } 884 885 static int qm_last_regs_init(struct hisi_qm *qm) 886 { 887 int dfx_regs_num = ARRAY_SIZE(qm_dfx_regs); 888 struct qm_debug *debug = &qm->debug; 889 int i; 890 891 if (qm->fun_type == QM_HW_VF) 892 return 0; 893 894 debug->qm_last_words = kcalloc(dfx_regs_num, sizeof(unsigned int), GFP_KERNEL); 895 if (!debug->qm_last_words) 896 return -ENOMEM; 897 898 for (i = 0; i < dfx_regs_num; i++) { 899 debug->qm_last_words[i] = readl_relaxed(qm->io_base + 900 qm_dfx_regs[i].offset); 901 } 902 903 return 0; 904 } 905 906 static void qm_diff_regs_uninit(struct hisi_qm *qm, u32 reg_len) 907 { 908 dfx_regs_uninit(qm, qm->debug.acc_diff_regs, reg_len); 909 qm->debug.acc_diff_regs = NULL; 910 dfx_regs_uninit(qm, qm->debug.qm_diff_regs, ARRAY_SIZE(qm_diff_regs)); 911 qm->debug.qm_diff_regs = NULL; 912 } 913 914 /** 915 * hisi_qm_regs_debugfs_init() - Allocate memory for registers. 916 * @qm: device qm handle. 917 * @dregs: diff registers handle. 918 * @reg_len: diff registers region length. 919 */ 920 int hisi_qm_regs_debugfs_init(struct hisi_qm *qm, 921 struct dfx_diff_registers *dregs, u32 reg_len) 922 { 923 int ret; 924 925 if (!qm || !dregs) 926 return -EINVAL; 927 928 if (qm->fun_type != QM_HW_PF) 929 return 0; 930 931 ret = qm_last_regs_init(qm); 932 if (ret) { 933 dev_info(&qm->pdev->dev, "failed to init qm words memory!\n"); 934 return ret; 935 } 936 937 ret = qm_diff_regs_init(qm, dregs, reg_len); 938 if (ret) { 939 qm_last_regs_uninit(qm); 940 return ret; 941 } 942 943 return 0; 944 } 945 EXPORT_SYMBOL_GPL(hisi_qm_regs_debugfs_init); 946 947 /** 948 * hisi_qm_regs_debugfs_uninit() - Free memory for registers. 949 * @qm: device qm handle. 950 * @reg_len: diff registers region length. 951 */ 952 void hisi_qm_regs_debugfs_uninit(struct hisi_qm *qm, u32 reg_len) 953 { 954 if (!qm || qm->fun_type != QM_HW_PF) 955 return; 956 957 qm_diff_regs_uninit(qm, reg_len); 958 qm_last_regs_uninit(qm); 959 } 960 EXPORT_SYMBOL_GPL(hisi_qm_regs_debugfs_uninit); 961 962 /** 963 * hisi_qm_acc_diff_regs_dump() - Dump registers's value. 964 * @qm: device qm handle. 965 * @s: Debugfs file handle. 966 * @dregs: diff registers handle. 967 * @regs_len: diff registers region length. 968 */ 969 void hisi_qm_acc_diff_regs_dump(struct hisi_qm *qm, struct seq_file *s, 970 struct dfx_diff_registers *dregs, u32 regs_len) 971 { 972 u32 j, val, base_offset; 973 int i, ret; 974 975 if (!qm || !s || !dregs) 976 return; 977 978 ret = hisi_qm_get_dfx_access(qm); 979 if (ret) 980 return; 981 982 down_read(&qm->qps_lock); 983 for (i = 0; i < regs_len; i++) { 984 if (!dregs[i].reg_len) 985 continue; 986 987 for (j = 0; j < dregs[i].reg_len; j++) { 988 base_offset = dregs[i].reg_offset + j * QM_DFX_REGS_LEN; 989 val = readl(qm->io_base + base_offset); 990 if (val != dregs[i].regs[j]) 991 seq_printf(s, "0x%08x = 0x%08x ---> 0x%08x\n", 992 base_offset, dregs[i].regs[j], val); 993 } 994 } 995 up_read(&qm->qps_lock); 996 997 hisi_qm_put_dfx_access(qm); 998 } 999 EXPORT_SYMBOL_GPL(hisi_qm_acc_diff_regs_dump); 1000 1001 void hisi_qm_show_last_dfx_regs(struct hisi_qm *qm) 1002 { 1003 struct qm_debug *debug = &qm->debug; 1004 struct pci_dev *pdev = qm->pdev; 1005 u32 val; 1006 int i; 1007 1008 if (qm->fun_type == QM_HW_VF || !debug->qm_last_words) 1009 return; 1010 1011 for (i = 0; i < ARRAY_SIZE(qm_dfx_regs); i++) { 1012 val = readl_relaxed(qm->io_base + qm_dfx_regs[i].offset); 1013 if (debug->qm_last_words[i] != val) 1014 pci_info(pdev, "%s \t= 0x%08x => 0x%08x\n", 1015 qm_dfx_regs[i].name, debug->qm_last_words[i], val); 1016 } 1017 } 1018 1019 static int qm_diff_regs_show(struct seq_file *s, void *unused) 1020 { 1021 struct hisi_qm *qm = s->private; 1022 1023 hisi_qm_acc_diff_regs_dump(qm, s, qm->debug.qm_diff_regs, 1024 ARRAY_SIZE(qm_diff_regs)); 1025 1026 return 0; 1027 } 1028 DEFINE_SHOW_ATTRIBUTE(qm_diff_regs); 1029 1030 static ssize_t qm_status_read(struct file *filp, char __user *buffer, 1031 size_t count, loff_t *pos) 1032 { 1033 struct hisi_qm *qm = filp->private_data; 1034 char buf[QM_DBG_READ_LEN]; 1035 int val, len; 1036 1037 val = atomic_read(&qm->status.flags); 1038 len = scnprintf(buf, QM_DBG_READ_LEN, "%s\n", qm_s[val]); 1039 1040 return simple_read_from_buffer(buffer, count, pos, buf, len); 1041 } 1042 1043 static const struct file_operations qm_status_fops = { 1044 .owner = THIS_MODULE, 1045 .open = simple_open, 1046 .read = qm_status_read, 1047 }; 1048 1049 static void qm_create_debugfs_file(struct hisi_qm *qm, struct dentry *dir, 1050 enum qm_debug_file index) 1051 { 1052 struct debugfs_file *file = qm->debug.files + index; 1053 1054 debugfs_create_file(qm_debug_file_name[index], 0600, dir, file, 1055 &qm_debug_fops); 1056 1057 file->index = index; 1058 mutex_init(&file->lock); 1059 file->debug = &qm->debug; 1060 } 1061 1062 static int qm_debugfs_atomic64_set(void *data, u64 val) 1063 { 1064 if (val) 1065 return -EINVAL; 1066 1067 atomic64_set((atomic64_t *)data, 0); 1068 1069 return 0; 1070 } 1071 1072 static int qm_debugfs_atomic64_get(void *data, u64 *val) 1073 { 1074 *val = atomic64_read((atomic64_t *)data); 1075 1076 return 0; 1077 } 1078 1079 DEFINE_DEBUGFS_ATTRIBUTE(qm_atomic64_ops, qm_debugfs_atomic64_get, 1080 qm_debugfs_atomic64_set, "%llu\n"); 1081 1082 /** 1083 * hisi_qm_debug_init() - Initialize qm related debugfs files. 1084 * @qm: The qm for which we want to add debugfs files. 1085 * 1086 * Create qm related debugfs files. 1087 */ 1088 void hisi_qm_debug_init(struct hisi_qm *qm) 1089 { 1090 struct dfx_diff_registers *qm_regs = qm->debug.qm_diff_regs; 1091 struct qm_dfx *dfx = &qm->debug.dfx; 1092 struct dentry *qm_d; 1093 void *data; 1094 int i; 1095 1096 qm_d = debugfs_create_dir("qm", qm->debug.debug_root); 1097 qm->debug.qm_d = qm_d; 1098 1099 /* only show this in PF */ 1100 if (qm->fun_type == QM_HW_PF) { 1101 qm_create_debugfs_file(qm, qm->debug.debug_root, CURRENT_QM); 1102 for (i = CURRENT_Q; i < DEBUG_FILE_NUM; i++) 1103 qm_create_debugfs_file(qm, qm->debug.qm_d, i); 1104 } 1105 1106 if (qm_regs) 1107 debugfs_create_file("diff_regs", 0444, qm->debug.qm_d, 1108 qm, &qm_diff_regs_fops); 1109 1110 debugfs_create_file("regs", 0444, qm->debug.qm_d, qm, &qm_regs_fops); 1111 1112 debugfs_create_file("cmd", 0600, qm->debug.qm_d, qm, &qm_cmd_fops); 1113 1114 debugfs_create_file("status", 0444, qm->debug.qm_d, qm, 1115 &qm_status_fops); 1116 for (i = 0; i < ARRAY_SIZE(qm_dfx_files); i++) { 1117 data = (atomic64_t *)((uintptr_t)dfx + qm_dfx_files[i].offset); 1118 debugfs_create_file(qm_dfx_files[i].name, 1119 0644, 1120 qm_d, 1121 data, 1122 &qm_atomic64_ops); 1123 } 1124 1125 if (test_bit(QM_SUPPORT_FUNC_QOS, &qm->caps)) 1126 hisi_qm_set_algqos_init(qm); 1127 } 1128 EXPORT_SYMBOL_GPL(hisi_qm_debug_init); 1129 1130 /** 1131 * hisi_qm_debug_regs_clear() - clear qm debug related registers. 1132 * @qm: The qm for which we want to clear its debug registers. 1133 */ 1134 void hisi_qm_debug_regs_clear(struct hisi_qm *qm) 1135 { 1136 const struct debugfs_reg32 *regs; 1137 int i; 1138 1139 /* clear current_qm */ 1140 writel(0x0, qm->io_base + QM_DFX_MB_CNT_VF); 1141 writel(0x0, qm->io_base + QM_DFX_DB_CNT_VF); 1142 1143 /* clear current_q */ 1144 writel(0x0, qm->io_base + QM_DFX_SQE_CNT_VF_SQN); 1145 writel(0x0, qm->io_base + QM_DFX_CQE_CNT_VF_CQN); 1146 1147 /* 1148 * these registers are reading and clearing, so clear them after 1149 * reading them. 1150 */ 1151 writel(0x1, qm->io_base + QM_DFX_CNT_CLR_CE); 1152 1153 regs = qm_dfx_regs; 1154 for (i = 0; i < CNT_CYC_REGS_NUM; i++) { 1155 readl(qm->io_base + regs->offset); 1156 regs++; 1157 } 1158 1159 /* clear clear_enable */ 1160 writel(0x0, qm->io_base + QM_DFX_CNT_CLR_CE); 1161 } 1162 EXPORT_SYMBOL_GPL(hisi_qm_debug_regs_clear); 1163