1 /** 2 * IBM Accelerator Family 'GenWQE' 3 * 4 * (C) Copyright IBM Corp. 2013 5 * 6 * Author: Frank Haverkamp <haver@linux.vnet.ibm.com> 7 * Author: Joerg-Stephan Vogt <jsvogt@de.ibm.com> 8 * Author: Michael Jung <mijung@gmx.net> 9 * Author: Michael Ruettger <michael@ibmra.de> 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License (version 2 only) 13 * as published by the Free Software Foundation. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 */ 20 21 /* 22 * Debugfs interfaces for the GenWQE card. Help to debug potential 23 * problems. Dump internal chip state for debugging and failure 24 * determination. 25 */ 26 27 #include <linux/module.h> 28 #include <linux/kernel.h> 29 #include <linux/debugfs.h> 30 #include <linux/seq_file.h> 31 #include <linux/uaccess.h> 32 33 #include "card_base.h" 34 #include "card_ddcb.h" 35 36 #define GENWQE_DEBUGFS_RO(_name, _showfn) \ 37 static int genwqe_debugfs_##_name##_open(struct inode *inode, \ 38 struct file *file) \ 39 { \ 40 return single_open(file, _showfn, inode->i_private); \ 41 } \ 42 static const struct file_operations genwqe_##_name##_fops = { \ 43 .open = genwqe_debugfs_##_name##_open, \ 44 .read = seq_read, \ 45 .llseek = seq_lseek, \ 46 .release = single_release, \ 47 } 48 49 static void dbg_uidn_show(struct seq_file *s, struct genwqe_reg *regs, 50 int entries) 51 { 52 unsigned int i; 53 u32 v_hi, v_lo; 54 55 for (i = 0; i < entries; i++) { 56 v_hi = (regs[i].val >> 32) & 0xffffffff; 57 v_lo = (regs[i].val) & 0xffffffff; 58 59 seq_printf(s, " 0x%08x 0x%08x 0x%08x 0x%08x EXT_ERR_REC\n", 60 regs[i].addr, regs[i].idx, v_hi, v_lo); 61 } 62 } 63 64 static int curr_dbg_uidn_show(struct seq_file *s, void *unused, int uid) 65 { 66 struct genwqe_dev *cd = s->private; 67 int entries; 68 struct genwqe_reg *regs; 69 70 entries = genwqe_ffdc_buff_size(cd, uid); 71 if (entries < 0) 72 return -EINVAL; 73 74 if (entries == 0) 75 return 0; 76 77 regs = kcalloc(entries, sizeof(*regs), GFP_KERNEL); 78 if (regs == NULL) 79 return -ENOMEM; 80 81 genwqe_stop_traps(cd); /* halt the traps while dumping data */ 82 genwqe_ffdc_buff_read(cd, uid, regs, entries); 83 genwqe_start_traps(cd); 84 85 dbg_uidn_show(s, regs, entries); 86 kfree(regs); 87 return 0; 88 } 89 90 static int genwqe_curr_dbg_uid0_show(struct seq_file *s, void *unused) 91 { 92 return curr_dbg_uidn_show(s, unused, 0); 93 } 94 95 GENWQE_DEBUGFS_RO(curr_dbg_uid0, genwqe_curr_dbg_uid0_show); 96 97 static int genwqe_curr_dbg_uid1_show(struct seq_file *s, void *unused) 98 { 99 return curr_dbg_uidn_show(s, unused, 1); 100 } 101 102 GENWQE_DEBUGFS_RO(curr_dbg_uid1, genwqe_curr_dbg_uid1_show); 103 104 static int genwqe_curr_dbg_uid2_show(struct seq_file *s, void *unused) 105 { 106 return curr_dbg_uidn_show(s, unused, 2); 107 } 108 109 GENWQE_DEBUGFS_RO(curr_dbg_uid2, genwqe_curr_dbg_uid2_show); 110 111 static int prev_dbg_uidn_show(struct seq_file *s, void *unused, int uid) 112 { 113 struct genwqe_dev *cd = s->private; 114 115 dbg_uidn_show(s, cd->ffdc[uid].regs, cd->ffdc[uid].entries); 116 return 0; 117 } 118 119 static int genwqe_prev_dbg_uid0_show(struct seq_file *s, void *unused) 120 { 121 return prev_dbg_uidn_show(s, unused, 0); 122 } 123 124 GENWQE_DEBUGFS_RO(prev_dbg_uid0, genwqe_prev_dbg_uid0_show); 125 126 static int genwqe_prev_dbg_uid1_show(struct seq_file *s, void *unused) 127 { 128 return prev_dbg_uidn_show(s, unused, 1); 129 } 130 131 GENWQE_DEBUGFS_RO(prev_dbg_uid1, genwqe_prev_dbg_uid1_show); 132 133 static int genwqe_prev_dbg_uid2_show(struct seq_file *s, void *unused) 134 { 135 return prev_dbg_uidn_show(s, unused, 2); 136 } 137 138 GENWQE_DEBUGFS_RO(prev_dbg_uid2, genwqe_prev_dbg_uid2_show); 139 140 static int genwqe_curr_regs_show(struct seq_file *s, void *unused) 141 { 142 struct genwqe_dev *cd = s->private; 143 unsigned int i; 144 struct genwqe_reg *regs; 145 146 regs = kcalloc(GENWQE_FFDC_REGS, sizeof(*regs), GFP_KERNEL); 147 if (regs == NULL) 148 return -ENOMEM; 149 150 genwqe_stop_traps(cd); 151 genwqe_read_ffdc_regs(cd, regs, GENWQE_FFDC_REGS, 1); 152 genwqe_start_traps(cd); 153 154 for (i = 0; i < GENWQE_FFDC_REGS; i++) { 155 if (regs[i].addr == 0xffffffff) 156 break; /* invalid entries */ 157 158 if (regs[i].val == 0x0ull) 159 continue; /* do not print 0x0 FIRs */ 160 161 seq_printf(s, " 0x%08x 0x%016llx\n", 162 regs[i].addr, regs[i].val); 163 } 164 return 0; 165 } 166 167 GENWQE_DEBUGFS_RO(curr_regs, genwqe_curr_regs_show); 168 169 static int genwqe_prev_regs_show(struct seq_file *s, void *unused) 170 { 171 struct genwqe_dev *cd = s->private; 172 unsigned int i; 173 struct genwqe_reg *regs = cd->ffdc[GENWQE_DBG_REGS].regs; 174 175 if (regs == NULL) 176 return -EINVAL; 177 178 for (i = 0; i < GENWQE_FFDC_REGS; i++) { 179 if (regs[i].addr == 0xffffffff) 180 break; /* invalid entries */ 181 182 if (regs[i].val == 0x0ull) 183 continue; /* do not print 0x0 FIRs */ 184 185 seq_printf(s, " 0x%08x 0x%016llx\n", 186 regs[i].addr, regs[i].val); 187 } 188 return 0; 189 } 190 191 GENWQE_DEBUGFS_RO(prev_regs, genwqe_prev_regs_show); 192 193 static int genwqe_jtimer_show(struct seq_file *s, void *unused) 194 { 195 struct genwqe_dev *cd = s->private; 196 unsigned int vf_num; 197 u64 jtimer; 198 199 jtimer = genwqe_read_vreg(cd, IO_SLC_VF_APPJOB_TIMEOUT, 0); 200 seq_printf(s, " PF 0x%016llx %d msec\n", jtimer, 201 genwqe_pf_jobtimeout_msec); 202 203 for (vf_num = 0; vf_num < cd->num_vfs; vf_num++) { 204 jtimer = genwqe_read_vreg(cd, IO_SLC_VF_APPJOB_TIMEOUT, 205 vf_num + 1); 206 seq_printf(s, " VF%-2d 0x%016llx %d msec\n", vf_num, jtimer, 207 cd->vf_jobtimeout_msec[vf_num]); 208 } 209 return 0; 210 } 211 212 GENWQE_DEBUGFS_RO(jtimer, genwqe_jtimer_show); 213 214 static int genwqe_queue_working_time_show(struct seq_file *s, void *unused) 215 { 216 struct genwqe_dev *cd = s->private; 217 unsigned int vf_num; 218 u64 t; 219 220 t = genwqe_read_vreg(cd, IO_SLC_VF_QUEUE_WTIME, 0); 221 seq_printf(s, " PF 0x%016llx\n", t); 222 223 for (vf_num = 0; vf_num < cd->num_vfs; vf_num++) { 224 t = genwqe_read_vreg(cd, IO_SLC_VF_QUEUE_WTIME, vf_num + 1); 225 seq_printf(s, " VF%-2d 0x%016llx\n", vf_num, t); 226 } 227 return 0; 228 } 229 230 GENWQE_DEBUGFS_RO(queue_working_time, genwqe_queue_working_time_show); 231 232 static int genwqe_ddcb_info_show(struct seq_file *s, void *unused) 233 { 234 struct genwqe_dev *cd = s->private; 235 unsigned int i; 236 struct ddcb_queue *queue; 237 struct ddcb *pddcb; 238 239 queue = &cd->queue; 240 seq_puts(s, "DDCB QUEUE:\n"); 241 seq_printf(s, " ddcb_max: %d\n" 242 " ddcb_daddr: %016llx - %016llx\n" 243 " ddcb_vaddr: %016llx\n" 244 " ddcbs_in_flight: %u\n" 245 " ddcbs_max_in_flight: %u\n" 246 " ddcbs_completed: %u\n" 247 " return_on_busy: %u\n" 248 " wait_on_busy: %u\n" 249 " irqs_processed: %u\n", 250 queue->ddcb_max, (long long)queue->ddcb_daddr, 251 (long long)queue->ddcb_daddr + 252 (queue->ddcb_max * DDCB_LENGTH), 253 (long long)queue->ddcb_vaddr, queue->ddcbs_in_flight, 254 queue->ddcbs_max_in_flight, queue->ddcbs_completed, 255 queue->return_on_busy, queue->wait_on_busy, 256 cd->irqs_processed); 257 258 /* Hardware State */ 259 seq_printf(s, " 0x%08x 0x%016llx IO_QUEUE_CONFIG\n" 260 " 0x%08x 0x%016llx IO_QUEUE_STATUS\n" 261 " 0x%08x 0x%016llx IO_QUEUE_SEGMENT\n" 262 " 0x%08x 0x%016llx IO_QUEUE_INITSQN\n" 263 " 0x%08x 0x%016llx IO_QUEUE_WRAP\n" 264 " 0x%08x 0x%016llx IO_QUEUE_OFFSET\n" 265 " 0x%08x 0x%016llx IO_QUEUE_WTIME\n" 266 " 0x%08x 0x%016llx IO_QUEUE_ERRCNTS\n" 267 " 0x%08x 0x%016llx IO_QUEUE_LRW\n", 268 queue->IO_QUEUE_CONFIG, 269 __genwqe_readq(cd, queue->IO_QUEUE_CONFIG), 270 queue->IO_QUEUE_STATUS, 271 __genwqe_readq(cd, queue->IO_QUEUE_STATUS), 272 queue->IO_QUEUE_SEGMENT, 273 __genwqe_readq(cd, queue->IO_QUEUE_SEGMENT), 274 queue->IO_QUEUE_INITSQN, 275 __genwqe_readq(cd, queue->IO_QUEUE_INITSQN), 276 queue->IO_QUEUE_WRAP, 277 __genwqe_readq(cd, queue->IO_QUEUE_WRAP), 278 queue->IO_QUEUE_OFFSET, 279 __genwqe_readq(cd, queue->IO_QUEUE_OFFSET), 280 queue->IO_QUEUE_WTIME, 281 __genwqe_readq(cd, queue->IO_QUEUE_WTIME), 282 queue->IO_QUEUE_ERRCNTS, 283 __genwqe_readq(cd, queue->IO_QUEUE_ERRCNTS), 284 queue->IO_QUEUE_LRW, 285 __genwqe_readq(cd, queue->IO_QUEUE_LRW)); 286 287 seq_printf(s, "DDCB list (ddcb_act=%d/ddcb_next=%d):\n", 288 queue->ddcb_act, queue->ddcb_next); 289 290 pddcb = queue->ddcb_vaddr; 291 for (i = 0; i < queue->ddcb_max; i++) { 292 seq_printf(s, " %-3d: RETC=%03x SEQ=%04x HSI/SHI=%02x/%02x ", 293 i, be16_to_cpu(pddcb->retc_16), 294 be16_to_cpu(pddcb->seqnum_16), 295 pddcb->hsi, pddcb->shi); 296 seq_printf(s, "PRIV=%06llx CMD=%02x\n", 297 be64_to_cpu(pddcb->priv_64), pddcb->cmd); 298 pddcb++; 299 } 300 return 0; 301 } 302 303 GENWQE_DEBUGFS_RO(ddcb_info, genwqe_ddcb_info_show); 304 305 static int genwqe_info_show(struct seq_file *s, void *unused) 306 { 307 struct genwqe_dev *cd = s->private; 308 u16 val16, type; 309 u64 app_id, slu_id, bitstream = -1; 310 struct pci_dev *pci_dev = cd->pci_dev; 311 312 slu_id = __genwqe_readq(cd, IO_SLU_UNITCFG); 313 app_id = __genwqe_readq(cd, IO_APP_UNITCFG); 314 315 if (genwqe_is_privileged(cd)) 316 bitstream = __genwqe_readq(cd, IO_SLU_BITSTREAM); 317 318 val16 = (u16)(slu_id & 0x0fLLU); 319 type = (u16)((slu_id >> 20) & 0xffLLU); 320 321 seq_printf(s, "%s driver version: %s\n" 322 " Device Name/Type: %s %s CardIdx: %d\n" 323 " SLU/APP Config : 0x%016llx/0x%016llx\n" 324 " Build Date : %u/%x/%u\n" 325 " Base Clock : %u MHz\n" 326 " Arch/SVN Release: %u/%llx\n" 327 " Bitstream : %llx\n", 328 GENWQE_DEVNAME, DRV_VERSION, dev_name(&pci_dev->dev), 329 genwqe_is_privileged(cd) ? 330 "Physical" : "Virtual or no SR-IOV", 331 cd->card_idx, slu_id, app_id, 332 (u16)((slu_id >> 12) & 0x0fLLU), /* month */ 333 (u16)((slu_id >> 4) & 0xffLLU), /* day */ 334 (u16)((slu_id >> 16) & 0x0fLLU) + 2010, /* year */ 335 genwqe_base_clock_frequency(cd), 336 (u16)((slu_id >> 32) & 0xffLLU), slu_id >> 40, 337 bitstream); 338 339 return 0; 340 } 341 342 GENWQE_DEBUGFS_RO(info, genwqe_info_show); 343 344 int genwqe_init_debugfs(struct genwqe_dev *cd) 345 { 346 struct dentry *root; 347 struct dentry *file; 348 int ret; 349 char card_name[64]; 350 char name[64]; 351 unsigned int i; 352 353 sprintf(card_name, "%s%d_card", GENWQE_DEVNAME, cd->card_idx); 354 355 root = debugfs_create_dir(card_name, cd->debugfs_genwqe); 356 if (!root) { 357 ret = -ENOMEM; 358 goto err0; 359 } 360 361 /* non privileged interfaces are done here */ 362 file = debugfs_create_file("ddcb_info", S_IRUGO, root, cd, 363 &genwqe_ddcb_info_fops); 364 if (!file) { 365 ret = -ENOMEM; 366 goto err1; 367 } 368 369 file = debugfs_create_file("info", S_IRUGO, root, cd, 370 &genwqe_info_fops); 371 if (!file) { 372 ret = -ENOMEM; 373 goto err1; 374 } 375 376 file = debugfs_create_x64("err_inject", 0666, root, &cd->err_inject); 377 if (!file) { 378 ret = -ENOMEM; 379 goto err1; 380 } 381 382 file = debugfs_create_u32("ddcb_software_timeout", 0666, root, 383 &cd->ddcb_software_timeout); 384 if (!file) { 385 ret = -ENOMEM; 386 goto err1; 387 } 388 389 file = debugfs_create_u32("kill_timeout", 0666, root, 390 &cd->kill_timeout); 391 if (!file) { 392 ret = -ENOMEM; 393 goto err1; 394 } 395 396 /* privileged interfaces follow here */ 397 if (!genwqe_is_privileged(cd)) { 398 cd->debugfs_root = root; 399 return 0; 400 } 401 402 file = debugfs_create_file("curr_regs", S_IRUGO, root, cd, 403 &genwqe_curr_regs_fops); 404 if (!file) { 405 ret = -ENOMEM; 406 goto err1; 407 } 408 409 file = debugfs_create_file("curr_dbg_uid0", S_IRUGO, root, cd, 410 &genwqe_curr_dbg_uid0_fops); 411 if (!file) { 412 ret = -ENOMEM; 413 goto err1; 414 } 415 416 file = debugfs_create_file("curr_dbg_uid1", S_IRUGO, root, cd, 417 &genwqe_curr_dbg_uid1_fops); 418 if (!file) { 419 ret = -ENOMEM; 420 goto err1; 421 } 422 423 file = debugfs_create_file("curr_dbg_uid2", S_IRUGO, root, cd, 424 &genwqe_curr_dbg_uid2_fops); 425 if (!file) { 426 ret = -ENOMEM; 427 goto err1; 428 } 429 430 file = debugfs_create_file("prev_regs", S_IRUGO, root, cd, 431 &genwqe_prev_regs_fops); 432 if (!file) { 433 ret = -ENOMEM; 434 goto err1; 435 } 436 437 file = debugfs_create_file("prev_dbg_uid0", S_IRUGO, root, cd, 438 &genwqe_prev_dbg_uid0_fops); 439 if (!file) { 440 ret = -ENOMEM; 441 goto err1; 442 } 443 444 file = debugfs_create_file("prev_dbg_uid1", S_IRUGO, root, cd, 445 &genwqe_prev_dbg_uid1_fops); 446 if (!file) { 447 ret = -ENOMEM; 448 goto err1; 449 } 450 451 file = debugfs_create_file("prev_dbg_uid2", S_IRUGO, root, cd, 452 &genwqe_prev_dbg_uid2_fops); 453 if (!file) { 454 ret = -ENOMEM; 455 goto err1; 456 } 457 458 for (i = 0; i < GENWQE_MAX_VFS; i++) { 459 sprintf(name, "vf%u_jobtimeout_msec", i); 460 461 file = debugfs_create_u32(name, 0666, root, 462 &cd->vf_jobtimeout_msec[i]); 463 if (!file) { 464 ret = -ENOMEM; 465 goto err1; 466 } 467 } 468 469 file = debugfs_create_file("jobtimer", S_IRUGO, root, cd, 470 &genwqe_jtimer_fops); 471 if (!file) { 472 ret = -ENOMEM; 473 goto err1; 474 } 475 476 file = debugfs_create_file("queue_working_time", S_IRUGO, root, cd, 477 &genwqe_queue_working_time_fops); 478 if (!file) { 479 ret = -ENOMEM; 480 goto err1; 481 } 482 483 file = debugfs_create_u32("skip_recovery", 0666, root, 484 &cd->skip_recovery); 485 if (!file) { 486 ret = -ENOMEM; 487 goto err1; 488 } 489 490 file = debugfs_create_u32("use_platform_recovery", 0666, root, 491 &cd->use_platform_recovery); 492 if (!file) { 493 ret = -ENOMEM; 494 goto err1; 495 } 496 497 cd->debugfs_root = root; 498 return 0; 499 err1: 500 debugfs_remove_recursive(root); 501 err0: 502 return ret; 503 } 504 505 void genqwe_exit_debugfs(struct genwqe_dev *cd) 506 { 507 debugfs_remove_recursive(cd->debugfs_root); 508 } 509