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