drivers/misc/genwqe/card_debugfs.c

   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 }