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
dbg_uidn_show(struct seq_file * s,struct genwqe_reg * regs,int entries)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
curr_dbg_uidn_show(struct seq_file * s,void * unused,int uid)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
genwqe_curr_dbg_uid0_show(struct seq_file * s,void * unused)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
genwqe_curr_dbg_uid1_show(struct seq_file * s,void * unused)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
genwqe_curr_dbg_uid2_show(struct seq_file * s,void * unused)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
prev_dbg_uidn_show(struct seq_file * s,void * unused,int uid)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
genwqe_prev_dbg_uid0_show(struct seq_file * s,void * unused)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
genwqe_prev_dbg_uid1_show(struct seq_file * s,void * unused)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
genwqe_prev_dbg_uid2_show(struct seq_file * s,void * unused)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
genwqe_curr_regs_show(struct seq_file * s,void * unused)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
genwqe_prev_regs_show(struct seq_file * s,void * unused)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
genwqe_jtimer_show(struct seq_file * s,void * unused)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
genwqe_queue_working_time_show(struct seq_file * s,void * unused)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
genwqe_ddcb_info_show(struct seq_file * s,void * unused)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
genwqe_info_show(struct seq_file * s,void * unused)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
genwqe_init_debugfs(struct genwqe_dev * cd)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
genqwe_exit_debugfs(struct genwqe_dev * cd)505 void genqwe_exit_debugfs(struct genwqe_dev *cd)
506 {
507 debugfs_remove_recursive(cd->debugfs_root);
508 }
509