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 static void dbg_uidn_show(struct seq_file *s, struct genwqe_reg *regs,
  37                           int entries)
  38 {
  39         unsigned int i;
  40         u32 v_hi, v_lo;
  41
  42         for (i = 0; i < entries; i++) {
  43                 v_hi = (regs[i].val >> 32) & 0xffffffff;
  44                 v_lo = (regs[i].val)       & 0xffffffff;
  45
  46                 seq_printf(s, "  0x%08x 0x%08x 0x%08x 0x%08x EXT_ERR_REC\n",
  47                            regs[i].addr, regs[i].idx, v_hi, v_lo);
  48         }
  49 }
  50
  51 static int curr_dbg_uidn_show(struct seq_file *s, void *unused, int uid)
  52 {
  53         struct genwqe_dev *cd = s->private;
  54         int entries;
  55         struct genwqe_reg *regs;
  56
  57         entries = genwqe_ffdc_buff_size(cd, uid);
  58         if (entries < 0)
  59                 return -EINVAL;
  60
  61         if (entries == 0)
  62                 return 0;
  63
  64         regs = kcalloc(entries, sizeof(*regs), GFP_KERNEL);
  65         if (regs == NULL)
  66                 return -ENOMEM;
  67
  68         genwqe_stop_traps(cd); /* halt the traps while dumping data */
  69         genwqe_ffdc_buff_read(cd, uid, regs, entries);
  70         genwqe_start_traps(cd);
  71
  72         dbg_uidn_show(s, regs, entries);
  73         kfree(regs);
  74         return 0;
  75 }
  76
  77 static int curr_dbg_uid0_show(struct seq_file *s, void *unused)
  78 {
  79         return curr_dbg_uidn_show(s, unused, 0);
  80 }
  81
  82 DEFINE_SHOW_ATTRIBUTE(curr_dbg_uid0);
  83
  84 static int curr_dbg_uid1_show(struct seq_file *s, void *unused)
  85 {
  86         return curr_dbg_uidn_show(s, unused, 1);
  87 }
  88
  89 DEFINE_SHOW_ATTRIBUTE(curr_dbg_uid1);
  90
  91 static int curr_dbg_uid2_show(struct seq_file *s, void *unused)
  92 {
  93         return curr_dbg_uidn_show(s, unused, 2);
  94 }
  95
  96 DEFINE_SHOW_ATTRIBUTE(curr_dbg_uid2);
  97
  98 static int prev_dbg_uidn_show(struct seq_file *s, void *unused, int uid)
  99 {
 100         struct genwqe_dev *cd = s->private;
 101
 102         dbg_uidn_show(s, cd->ffdc[uid].regs,  cd->ffdc[uid].entries);
 103         return 0;
 104 }
 105
 106 static int prev_dbg_uid0_show(struct seq_file *s, void *unused)
 107 {
 108         return prev_dbg_uidn_show(s, unused, 0);
 109 }
 110
 111 DEFINE_SHOW_ATTRIBUTE(prev_dbg_uid0);
 112
 113 static int prev_dbg_uid1_show(struct seq_file *s, void *unused)
 114 {
 115         return prev_dbg_uidn_show(s, unused, 1);
 116 }
 117
 118 DEFINE_SHOW_ATTRIBUTE(prev_dbg_uid1);
 119
 120 static int prev_dbg_uid2_show(struct seq_file *s, void *unused)
 121 {
 122         return prev_dbg_uidn_show(s, unused, 2);
 123 }
 124
 125 DEFINE_SHOW_ATTRIBUTE(prev_dbg_uid2);
 126
 127 static int curr_regs_show(struct seq_file *s, void *unused)
 128 {
 129         struct genwqe_dev *cd = s->private;
 130         unsigned int i;
 131         struct genwqe_reg *regs;
 132
 133         regs = kcalloc(GENWQE_FFDC_REGS, sizeof(*regs), GFP_KERNEL);
 134         if (regs == NULL)
 135                 return -ENOMEM;
 136
 137         genwqe_stop_traps(cd);
 138         genwqe_read_ffdc_regs(cd, regs, GENWQE_FFDC_REGS, 1);
 139         genwqe_start_traps(cd);
 140
 141         for (i = 0; i < GENWQE_FFDC_REGS; i++) {
 142                 if (regs[i].addr == 0xffffffff)
 143                         break;  /* invalid entries */
 144
 145                 if (regs[i].val == 0x0ull)
 146                         continue;  /* do not print 0x0 FIRs */
 147
 148                 seq_printf(s, "  0x%08x 0x%016llx\n",
 149                            regs[i].addr, regs[i].val);
 150         }
 151         return 0;
 152 }
 153
 154 DEFINE_SHOW_ATTRIBUTE(curr_regs);
 155
 156 static int prev_regs_show(struct seq_file *s, void *unused)
 157 {
 158         struct genwqe_dev *cd = s->private;
 159         unsigned int i;
 160         struct genwqe_reg *regs = cd->ffdc[GENWQE_DBG_REGS].regs;
 161
 162         if (regs == NULL)
 163                 return -EINVAL;
 164
 165         for (i = 0; i < GENWQE_FFDC_REGS; i++) {
 166                 if (regs[i].addr == 0xffffffff)
 167                         break;  /* invalid entries */
 168
 169                 if (regs[i].val == 0x0ull)
 170                         continue;  /* do not print 0x0 FIRs */
 171
 172                 seq_printf(s, "  0x%08x 0x%016llx\n",
 173                            regs[i].addr, regs[i].val);
 174         }
 175         return 0;
 176 }
 177
 178 DEFINE_SHOW_ATTRIBUTE(prev_regs);
 179
 180 static int jtimer_show(struct seq_file *s, void *unused)
 181 {
 182         struct genwqe_dev *cd = s->private;
 183         unsigned int vf_num;
 184         u64 jtimer;
 185
 186         jtimer = genwqe_read_vreg(cd, IO_SLC_VF_APPJOB_TIMEOUT, 0);
 187         seq_printf(s, "  PF   0x%016llx %d msec\n", jtimer,
 188                    GENWQE_PF_JOBTIMEOUT_MSEC);
 189
 190         for (vf_num = 0; vf_num < cd->num_vfs; vf_num++) {
 191                 jtimer = genwqe_read_vreg(cd, IO_SLC_VF_APPJOB_TIMEOUT,
 192                                           vf_num + 1);
 193                 seq_printf(s, "  VF%-2d 0x%016llx %d msec\n", vf_num, jtimer,
 194                            cd->vf_jobtimeout_msec[vf_num]);
 195         }
 196         return 0;
 197 }
 198
 199 DEFINE_SHOW_ATTRIBUTE(jtimer);
 200
 201 static int queue_working_time_show(struct seq_file *s, void *unused)
 202 {
 203         struct genwqe_dev *cd = s->private;
 204         unsigned int vf_num;
 205         u64 t;
 206
 207         t = genwqe_read_vreg(cd, IO_SLC_VF_QUEUE_WTIME, 0);
 208         seq_printf(s, "  PF   0x%016llx\n", t);
 209
 210         for (vf_num = 0; vf_num < cd->num_vfs; vf_num++) {
 211                 t = genwqe_read_vreg(cd, IO_SLC_VF_QUEUE_WTIME, vf_num + 1);
 212                 seq_printf(s, "  VF%-2d 0x%016llx\n", vf_num, t);
 213         }
 214         return 0;
 215 }
 216
 217 DEFINE_SHOW_ATTRIBUTE(queue_working_time);
 218
 219 static int ddcb_info_show(struct seq_file *s, void *unused)
 220 {
 221         struct genwqe_dev *cd = s->private;
 222         unsigned int i;
 223         struct ddcb_queue *queue;
 224         struct ddcb *pddcb;
 225
 226         queue = &cd->queue;
 227         seq_puts(s, "DDCB QUEUE:\n");
 228         seq_printf(s, "  ddcb_max:            %d\n"
 229                    "  ddcb_daddr:          %016llx - %016llx\n"
 230                    "  ddcb_vaddr:          %016llx\n"
 231                    "  ddcbs_in_flight:     %u\n"
 232                    "  ddcbs_max_in_flight: %u\n"
 233                    "  ddcbs_completed:     %u\n"
 234                    "  return_on_busy:      %u\n"
 235                    "  wait_on_busy:        %u\n"
 236                    "  irqs_processed:      %u\n",
 237                    queue->ddcb_max, (long long)queue->ddcb_daddr,
 238                    (long long)queue->ddcb_daddr +
 239                    (queue->ddcb_max * DDCB_LENGTH),
 240                    (long long)queue->ddcb_vaddr, queue->ddcbs_in_flight,
 241                    queue->ddcbs_max_in_flight, queue->ddcbs_completed,
 242                    queue->return_on_busy, queue->wait_on_busy,
 243                    cd->irqs_processed);
 244
 245         /* Hardware State */
 246         seq_printf(s, "  0x%08x 0x%016llx IO_QUEUE_CONFIG\n"
 247                    "  0x%08x 0x%016llx IO_QUEUE_STATUS\n"
 248                    "  0x%08x 0x%016llx IO_QUEUE_SEGMENT\n"
 249                    "  0x%08x 0x%016llx IO_QUEUE_INITSQN\n"
 250                    "  0x%08x 0x%016llx IO_QUEUE_WRAP\n"
 251                    "  0x%08x 0x%016llx IO_QUEUE_OFFSET\n"
 252                    "  0x%08x 0x%016llx IO_QUEUE_WTIME\n"
 253                    "  0x%08x 0x%016llx IO_QUEUE_ERRCNTS\n"
 254                    "  0x%08x 0x%016llx IO_QUEUE_LRW\n",
 255                    queue->IO_QUEUE_CONFIG,
 256                    __genwqe_readq(cd, queue->IO_QUEUE_CONFIG),
 257                    queue->IO_QUEUE_STATUS,
 258                    __genwqe_readq(cd, queue->IO_QUEUE_STATUS),
 259                    queue->IO_QUEUE_SEGMENT,
 260                    __genwqe_readq(cd, queue->IO_QUEUE_SEGMENT),
 261                    queue->IO_QUEUE_INITSQN,
 262                    __genwqe_readq(cd, queue->IO_QUEUE_INITSQN),
 263                    queue->IO_QUEUE_WRAP,
 264                    __genwqe_readq(cd, queue->IO_QUEUE_WRAP),
 265                    queue->IO_QUEUE_OFFSET,
 266                    __genwqe_readq(cd, queue->IO_QUEUE_OFFSET),
 267                    queue->IO_QUEUE_WTIME,
 268                    __genwqe_readq(cd, queue->IO_QUEUE_WTIME),
 269                    queue->IO_QUEUE_ERRCNTS,
 270                    __genwqe_readq(cd, queue->IO_QUEUE_ERRCNTS),
 271                    queue->IO_QUEUE_LRW,
 272                    __genwqe_readq(cd, queue->IO_QUEUE_LRW));
 273
 274         seq_printf(s, "DDCB list (ddcb_act=%d/ddcb_next=%d):\n",
 275                    queue->ddcb_act, queue->ddcb_next);
 276
 277         pddcb = queue->ddcb_vaddr;
 278         for (i = 0; i < queue->ddcb_max; i++) {
 279                 seq_printf(s, "  %-3d: RETC=%03x SEQ=%04x HSI/SHI=%02x/%02x ",
 280                            i, be16_to_cpu(pddcb->retc_16),
 281                            be16_to_cpu(pddcb->seqnum_16),
 282                            pddcb->hsi, pddcb->shi);
 283                 seq_printf(s, "PRIV=%06llx CMD=%02x\n",
 284                            be64_to_cpu(pddcb->priv_64), pddcb->cmd);
 285                 pddcb++;
 286         }
 287         return 0;
 288 }
 289
 290 DEFINE_SHOW_ATTRIBUTE(ddcb_info);
 291
 292 static int info_show(struct seq_file *s, void *unused)
 293 {
 294         struct genwqe_dev *cd = s->private;
 295         u64 app_id, slu_id, bitstream = -1;
 296         struct pci_dev *pci_dev = cd->pci_dev;
 297
 298         slu_id = __genwqe_readq(cd, IO_SLU_UNITCFG);
 299         app_id = __genwqe_readq(cd, IO_APP_UNITCFG);
 300
 301         if (genwqe_is_privileged(cd))
 302                 bitstream = __genwqe_readq(cd, IO_SLU_BITSTREAM);
 303
 304         seq_printf(s, "%s driver version: %s\n"
 305                    "    Device Name/Type: %s %s CardIdx: %d\n"
 306                    "    SLU/APP Config  : 0x%016llx/0x%016llx\n"
 307                    "    Build Date      : %u/%x/%u\n"
 308                    "    Base Clock      : %u MHz\n"
 309                    "    Arch/SVN Release: %u/%llx\n"
 310                    "    Bitstream       : %llx\n",
 311                    GENWQE_DEVNAME, DRV_VERSION, dev_name(&pci_dev->dev),
 312                    genwqe_is_privileged(cd) ?
 313                    "Physical" : "Virtual or no SR-IOV",
 314                    cd->card_idx, slu_id, app_id,
 315                    (u16)((slu_id >> 12) & 0x0fLLU),        /* month */
 316                    (u16)((slu_id >>  4) & 0xffLLU),        /* day */
 317                    (u16)((slu_id >> 16) & 0x0fLLU) + 2010, /* year */
 318                    genwqe_base_clock_frequency(cd),
 319                    (u16)((slu_id >> 32) & 0xffLLU), slu_id >> 40,
 320                    bitstream);
 321
 322         return 0;
 323 }
 324
 325 DEFINE_SHOW_ATTRIBUTE(info);
 326
 327 int genwqe_init_debugfs(struct genwqe_dev *cd)
 328 {
 329         struct dentry *root;
 330         struct dentry *file;
 331         int ret;
 332         char card_name[64];
 333         char name[64];
 334         unsigned int i;
 335
 336         sprintf(card_name, "%s%d_card", GENWQE_DEVNAME, cd->card_idx);
 337
 338         root = debugfs_create_dir(card_name, cd->debugfs_genwqe);
 339         if (!root) {
 340                 ret = -ENOMEM;
 341                 goto err0;
 342         }
 343
 344         /* non privileged interfaces are done here */
 345         file = debugfs_create_file("ddcb_info", S_IRUGO, root, cd,
 346                                    &ddcb_info_fops);
 347         if (!file) {
 348                 ret = -ENOMEM;
 349                 goto err1;
 350         }
 351
 352         file = debugfs_create_file("info", S_IRUGO, root, cd,
 353                                    &info_fops);
 354         if (!file) {
 355                 ret = -ENOMEM;
 356                 goto err1;
 357         }
 358
 359         file = debugfs_create_x64("err_inject", 0666, root, &cd->err_inject);
 360         if (!file) {
 361                 ret = -ENOMEM;
 362                 goto err1;
 363         }
 364
 365         file = debugfs_create_u32("ddcb_software_timeout", 0666, root,
 366                                   &cd->ddcb_software_timeout);
 367         if (!file) {
 368                 ret = -ENOMEM;
 369                 goto err1;
 370         }
 371
 372         file = debugfs_create_u32("kill_timeout", 0666, root,
 373                                   &cd->kill_timeout);
 374         if (!file) {
 375                 ret = -ENOMEM;
 376                 goto err1;
 377         }
 378
 379         /* privileged interfaces follow here */
 380         if (!genwqe_is_privileged(cd)) {
 381                 cd->debugfs_root = root;
 382                 return 0;
 383         }
 384
 385         file = debugfs_create_file("curr_regs", S_IRUGO, root, cd,
 386                                    &curr_regs_fops);
 387         if (!file) {
 388                 ret = -ENOMEM;
 389                 goto err1;
 390         }
 391
 392         file = debugfs_create_file("curr_dbg_uid0", S_IRUGO, root, cd,
 393                                    &curr_dbg_uid0_fops);
 394         if (!file) {
 395                 ret = -ENOMEM;
 396                 goto err1;
 397         }
 398
 399         file = debugfs_create_file("curr_dbg_uid1", S_IRUGO, root, cd,
 400                                    &curr_dbg_uid1_fops);
 401         if (!file) {
 402                 ret = -ENOMEM;
 403                 goto err1;
 404         }
 405
 406         file = debugfs_create_file("curr_dbg_uid2", S_IRUGO, root, cd,
 407                                    &curr_dbg_uid2_fops);
 408         if (!file) {
 409                 ret = -ENOMEM;
 410                 goto err1;
 411         }
 412
 413         file = debugfs_create_file("prev_regs", S_IRUGO, root, cd,
 414                                    &prev_regs_fops);
 415         if (!file) {
 416                 ret = -ENOMEM;
 417                 goto err1;
 418         }
 419
 420         file = debugfs_create_file("prev_dbg_uid0", S_IRUGO, root, cd,
 421                                    &prev_dbg_uid0_fops);
 422         if (!file) {
 423                 ret = -ENOMEM;
 424                 goto err1;
 425         }
 426
 427         file = debugfs_create_file("prev_dbg_uid1", S_IRUGO, root, cd,
 428                                    &prev_dbg_uid1_fops);
 429         if (!file) {
 430                 ret = -ENOMEM;
 431                 goto err1;
 432         }
 433
 434         file = debugfs_create_file("prev_dbg_uid2", S_IRUGO, root, cd,
 435                                    &prev_dbg_uid2_fops);
 436         if (!file) {
 437                 ret = -ENOMEM;
 438                 goto err1;
 439         }
 440
 441         for (i = 0; i <  GENWQE_MAX_VFS; i++) {
 442                 sprintf(name, "vf%u_jobtimeout_msec", i);
 443
 444                 file = debugfs_create_u32(name, 0666, root,
 445                                           &cd->vf_jobtimeout_msec[i]);
 446                 if (!file) {
 447                         ret = -ENOMEM;
 448                         goto err1;
 449                 }
 450         }
 451
 452         file = debugfs_create_file("jobtimer", S_IRUGO, root, cd,
 453                                    &jtimer_fops);
 454         if (!file) {
 455                 ret = -ENOMEM;
 456                 goto err1;
 457         }
 458
 459         file = debugfs_create_file("queue_working_time", S_IRUGO, root, cd,
 460                                    &queue_working_time_fops);
 461         if (!file) {
 462                 ret = -ENOMEM;
 463                 goto err1;
 464         }
 465
 466         file = debugfs_create_u32("skip_recovery", 0666, root,
 467                                   &cd->skip_recovery);
 468         if (!file) {
 469                 ret = -ENOMEM;
 470                 goto err1;
 471         }
 472
 473         file = debugfs_create_u32("use_platform_recovery", 0666, root,
 474                                   &cd->use_platform_recovery);
 475         if (!file) {
 476                 ret = -ENOMEM;
 477                 goto err1;
 478         }
 479
 480         cd->debugfs_root = root;
 481         return 0;
 482 err1:
 483         debugfs_remove_recursive(root);
 484 err0:
 485         return ret;
 486 }
 487
 488 void genqwe_exit_debugfs(struct genwqe_dev *cd)
 489 {
 490         debugfs_remove_recursive(cd->debugfs_root);
 491 }