[mirror_ubuntu-zesty-kernel.git] / drivers / misc / genwqe / card_debugfs.c

/**
 * IBM Accelerator Family 'GenWQE'
 *
 * (C) Copyright IBM Corp. 2013
 *
 * Author: Frank Haverkamp <haver@linux.vnet.ibm.com>
 * Author: Joerg-Stephan Vogt <jsvogt@de.ibm.com>
 * Author: Michael Jung <mijung@gmx.net>
 * Author: Michael Ruettger <michael@ibmra.de>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License (version 2 only)
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */

/*
 * Debugfs interfaces for the GenWQE card. Help to debug potential
 * problems. Dump internal chip state for debugging and failure
 * determination.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/uaccess.h>

#include "card_base.h"
#include "card_ddcb.h"

#define GENWQE_DEBUGFS_RO(_name, _showfn)				\
	static int genwqe_debugfs_##_name##_open(struct inode *inode,	\
						 struct file *file)	\
	{								\
		return single_open(file, _showfn, inode->i_private);	\
	}								\
	static const struct file_operations genwqe_##_name##_fops = {	\
		.open = genwqe_debugfs_##_name##_open,			\
		.read = seq_read,					\
		.llseek = seq_lseek,					\
		.release = single_release,				\
	}

static void dbg_uidn_show(struct seq_file *s, struct genwqe_reg *regs,
			  int entries)
{
	unsigned int i;
	u32 v_hi, v_lo;

	for (i = 0; i < entries; i++) {
		v_hi = (regs[i].val >> 32) & 0xffffffff;
		v_lo = (regs[i].val)       & 0xffffffff;

		seq_printf(s, "  0x%08x 0x%08x 0x%08x 0x%08x EXT_ERR_REC\n",
			   regs[i].addr, regs[i].idx, v_hi, v_lo);
	}
}

static int curr_dbg_uidn_show(struct seq_file *s, void *unused, int uid)
{
	struct genwqe_dev *cd = s->private;
	int entries;
	struct genwqe_reg *regs;

	entries = genwqe_ffdc_buff_size(cd, uid);
	if (entries < 0)
		return -EINVAL;

	if (entries == 0)
		return 0;

	regs = kcalloc(entries, sizeof(*regs), GFP_KERNEL);
	if (regs == NULL)
		return -ENOMEM;

	genwqe_stop_traps(cd); /* halt the traps while dumping data */
	genwqe_ffdc_buff_read(cd, uid, regs, entries);
	genwqe_start_traps(cd);

	dbg_uidn_show(s, regs, entries);
	kfree(regs);
	return 0;
}

static int genwqe_curr_dbg_uid0_show(struct seq_file *s, void *unused)
{
	return curr_dbg_uidn_show(s, unused, 0);
}

GENWQE_DEBUGFS_RO(curr_dbg_uid0, genwqe_curr_dbg_uid0_show);

static int genwqe_curr_dbg_uid1_show(struct seq_file *s, void *unused)
{
	return curr_dbg_uidn_show(s, unused, 1);
}

GENWQE_DEBUGFS_RO(curr_dbg_uid1, genwqe_curr_dbg_uid1_show);

static int genwqe_curr_dbg_uid2_show(struct seq_file *s, void *unused)
{
	return curr_dbg_uidn_show(s, unused, 2);
}

GENWQE_DEBUGFS_RO(curr_dbg_uid2, genwqe_curr_dbg_uid2_show);

static int prev_dbg_uidn_show(struct seq_file *s, void *unused, int uid)
{
	struct genwqe_dev *cd = s->private;

	dbg_uidn_show(s, cd->ffdc[uid].regs,  cd->ffdc[uid].entries);
	return 0;
}

static int genwqe_prev_dbg_uid0_show(struct seq_file *s, void *unused)
{
	return prev_dbg_uidn_show(s, unused, 0);
}

GENWQE_DEBUGFS_RO(prev_dbg_uid0, genwqe_prev_dbg_uid0_show);

static int genwqe_prev_dbg_uid1_show(struct seq_file *s, void *unused)
{
	return prev_dbg_uidn_show(s, unused, 1);
}

GENWQE_DEBUGFS_RO(prev_dbg_uid1, genwqe_prev_dbg_uid1_show);

static int genwqe_prev_dbg_uid2_show(struct seq_file *s, void *unused)
{
	return prev_dbg_uidn_show(s, unused, 2);
}

GENWQE_DEBUGFS_RO(prev_dbg_uid2, genwqe_prev_dbg_uid2_show);

static int genwqe_curr_regs_show(struct seq_file *s, void *unused)
{
	struct genwqe_dev *cd = s->private;
	unsigned int i;
	struct genwqe_reg *regs;

	regs = kcalloc(GENWQE_FFDC_REGS, sizeof(*regs), GFP_KERNEL);
	if (regs == NULL)
		return -ENOMEM;

	genwqe_stop_traps(cd);
	genwqe_read_ffdc_regs(cd, regs, GENWQE_FFDC_REGS, 1);
	genwqe_start_traps(cd);

	for (i = 0; i < GENWQE_FFDC_REGS; i++) {
		if (regs[i].addr == 0xffffffff)
			break;  /* invalid entries */

		if (regs[i].val == 0x0ull)
			continue;  /* do not print 0x0 FIRs */

		seq_printf(s, "  0x%08x 0x%016llx\n",
			   regs[i].addr, regs[i].val);
	}
	return 0;
}

GENWQE_DEBUGFS_RO(curr_regs, genwqe_curr_regs_show);

static int genwqe_prev_regs_show(struct seq_file *s, void *unused)
{
	struct genwqe_dev *cd = s->private;
	unsigned int i;
	struct genwqe_reg *regs = cd->ffdc[GENWQE_DBG_REGS].regs;

	if (regs == NULL)
		return -EINVAL;

	for (i = 0; i < GENWQE_FFDC_REGS; i++) {
		if (regs[i].addr == 0xffffffff)
			break;  /* invalid entries */

		if (regs[i].val == 0x0ull)
			continue;  /* do not print 0x0 FIRs */

		seq_printf(s, "  0x%08x 0x%016llx\n",
			   regs[i].addr, regs[i].val);
	}
	return 0;
}

GENWQE_DEBUGFS_RO(prev_regs, genwqe_prev_regs_show);

static int genwqe_jtimer_show(struct seq_file *s, void *unused)
{
	struct genwqe_dev *cd = s->private;
	unsigned int vf_num;
	u64 jtimer;

	jtimer = genwqe_read_vreg(cd, IO_SLC_VF_APPJOB_TIMEOUT, 0);
	seq_printf(s, "  PF   0x%016llx %d msec\n", jtimer,
		   genwqe_pf_jobtimeout_msec);

	for (vf_num = 0; vf_num < cd->num_vfs; vf_num++) {
		jtimer = genwqe_read_vreg(cd, IO_SLC_VF_APPJOB_TIMEOUT,
					  vf_num + 1);
		seq_printf(s, "  VF%-2d 0x%016llx %d msec\n", vf_num, jtimer,
			   cd->vf_jobtimeout_msec[vf_num]);
	}
	return 0;
}

GENWQE_DEBUGFS_RO(jtimer, genwqe_jtimer_show);

static int genwqe_queue_working_time_show(struct seq_file *s, void *unused)
{
	struct genwqe_dev *cd = s->private;
	unsigned int vf_num;
	u64 t;

	t = genwqe_read_vreg(cd, IO_SLC_VF_QUEUE_WTIME, 0);
	seq_printf(s, "  PF   0x%016llx\n", t);

	for (vf_num = 0; vf_num < cd->num_vfs; vf_num++) {
		t = genwqe_read_vreg(cd, IO_SLC_VF_QUEUE_WTIME, vf_num + 1);
		seq_printf(s, "  VF%-2d 0x%016llx\n", vf_num, t);
	}
	return 0;
}

GENWQE_DEBUGFS_RO(queue_working_time, genwqe_queue_working_time_show);

static int genwqe_ddcb_info_show(struct seq_file *s, void *unused)
{
	struct genwqe_dev *cd = s->private;
	unsigned int i;
	struct ddcb_queue *queue;
	struct ddcb *pddcb;

	queue = &cd->queue;
	seq_puts(s, "DDCB QUEUE:\n");
	seq_printf(s, "  ddcb_max:            %d\n"
		   "  ddcb_daddr:          %016llx - %016llx\n"
		   "  ddcb_vaddr:          %016llx\n"
		   "  ddcbs_in_flight:     %u\n"
		   "  ddcbs_max_in_flight: %u\n"
		   "  ddcbs_completed:     %u\n"
		   "  return_on_busy:      %u\n"
		   "  wait_on_busy:        %u\n"
		   "  irqs_processed:      %u\n",
		   queue->ddcb_max, (long long)queue->ddcb_daddr,
		   (long long)queue->ddcb_daddr +
		   (queue->ddcb_max * DDCB_LENGTH),
		   (long long)queue->ddcb_vaddr, queue->ddcbs_in_flight,
		   queue->ddcbs_max_in_flight, queue->ddcbs_completed,
		   queue->return_on_busy, queue->wait_on_busy,
		   cd->irqs_processed);

	/* Hardware State */
	seq_printf(s, "  0x%08x 0x%016llx IO_QUEUE_CONFIG\n"
		   "  0x%08x 0x%016llx IO_QUEUE_STATUS\n"
		   "  0x%08x 0x%016llx IO_QUEUE_SEGMENT\n"
		   "  0x%08x 0x%016llx IO_QUEUE_INITSQN\n"
		   "  0x%08x 0x%016llx IO_QUEUE_WRAP\n"
		   "  0x%08x 0x%016llx IO_QUEUE_OFFSET\n"
		   "  0x%08x 0x%016llx IO_QUEUE_WTIME\n"
		   "  0x%08x 0x%016llx IO_QUEUE_ERRCNTS\n"
		   "  0x%08x 0x%016llx IO_QUEUE_LRW\n",
		   queue->IO_QUEUE_CONFIG,
		   __genwqe_readq(cd, queue->IO_QUEUE_CONFIG),
		   queue->IO_QUEUE_STATUS,
		   __genwqe_readq(cd, queue->IO_QUEUE_STATUS),
		   queue->IO_QUEUE_SEGMENT,
		   __genwqe_readq(cd, queue->IO_QUEUE_SEGMENT),
		   queue->IO_QUEUE_INITSQN,
		   __genwqe_readq(cd, queue->IO_QUEUE_INITSQN),
		   queue->IO_QUEUE_WRAP,
		   __genwqe_readq(cd, queue->IO_QUEUE_WRAP),
		   queue->IO_QUEUE_OFFSET,
		   __genwqe_readq(cd, queue->IO_QUEUE_OFFSET),
		   queue->IO_QUEUE_WTIME,
		   __genwqe_readq(cd, queue->IO_QUEUE_WTIME),
		   queue->IO_QUEUE_ERRCNTS,
		   __genwqe_readq(cd, queue->IO_QUEUE_ERRCNTS),
		   queue->IO_QUEUE_LRW,
		   __genwqe_readq(cd, queue->IO_QUEUE_LRW));

	seq_printf(s, "DDCB list (ddcb_act=%d/ddcb_next=%d):\n",
		   queue->ddcb_act, queue->ddcb_next);

	pddcb = queue->ddcb_vaddr;
	for (i = 0; i < queue->ddcb_max; i++) {
		seq_printf(s, "  %-3d: RETC=%03x SEQ=%04x HSI/SHI=%02x/%02x ",
			   i, be16_to_cpu(pddcb->retc_16),
			   be16_to_cpu(pddcb->seqnum_16),
			   pddcb->hsi, pddcb->shi);
		seq_printf(s, "PRIV=%06llx CMD=%02x\n",
			   be64_to_cpu(pddcb->priv_64), pddcb->cmd);
		pddcb++;
	}
	return 0;
}

GENWQE_DEBUGFS_RO(ddcb_info, genwqe_ddcb_info_show);

static int genwqe_info_show(struct seq_file *s, void *unused)
{
	struct genwqe_dev *cd = s->private;
	u16 val16, type;
	u64 app_id, slu_id, bitstream = -1;
	struct pci_dev *pci_dev = cd->pci_dev;

	slu_id = __genwqe_readq(cd, IO_SLU_UNITCFG);
	app_id = __genwqe_readq(cd, IO_APP_UNITCFG);

	if (genwqe_is_privileged(cd))
		bitstream = __genwqe_readq(cd, IO_SLU_BITSTREAM);

	val16 = (u16)(slu_id & 0x0fLLU);
	type  = (u16)((slu_id >> 20) & 0xffLLU);

	seq_printf(s, "%s driver version: %s\n"
		   "    Device Name/Type: %s %s CardIdx: %d\n"
		   "    SLU/APP Config  : 0x%016llx/0x%016llx\n"
		   "    Build Date      : %u/%x/%u\n"
		   "    Base Clock      : %u MHz\n"
		   "    Arch/SVN Release: %u/%llx\n"
		   "    Bitstream       : %llx\n",
		   GENWQE_DEVNAME, DRV_VERSION, dev_name(&pci_dev->dev),
		   genwqe_is_privileged(cd) ?
		   "Physical" : "Virtual or no SR-IOV",
		   cd->card_idx, slu_id, app_id,
		   (u16)((slu_id >> 12) & 0x0fLLU),	   /* month */
		   (u16)((slu_id >>  4) & 0xffLLU),	   /* day */
		   (u16)((slu_id >> 16) & 0x0fLLU) + 2010, /* year */
		   genwqe_base_clock_frequency(cd),
		   (u16)((slu_id >> 32) & 0xffLLU), slu_id >> 40,
		   bitstream);

	return 0;
}

GENWQE_DEBUGFS_RO(info, genwqe_info_show);

int genwqe_init_debugfs(struct genwqe_dev *cd)
{
	struct dentry *root;
	struct dentry *file;
	int ret;
	char card_name[64];
	char name[64];
	unsigned int i;

	sprintf(card_name, "%s%d_card", GENWQE_DEVNAME, cd->card_idx);

	root = debugfs_create_dir(card_name, cd->debugfs_genwqe);
	if (!root) {
		ret = -ENOMEM;
		goto err0;
	}

	/* non privileged interfaces are done here */
	file = debugfs_create_file("ddcb_info", S_IRUGO, root, cd,
				   &genwqe_ddcb_info_fops);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	file = debugfs_create_file("info", S_IRUGO, root, cd,
				   &genwqe_info_fops);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	file = debugfs_create_x64("err_inject", 0666, root, &cd->err_inject);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	file = debugfs_create_u32("ddcb_software_timeout", 0666, root,
				  &cd->ddcb_software_timeout);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	file = debugfs_create_u32("kill_timeout", 0666, root,
				  &cd->kill_timeout);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	/* privileged interfaces follow here */
	if (!genwqe_is_privileged(cd)) {
		cd->debugfs_root = root;
		return 0;
	}

	file = debugfs_create_file("curr_regs", S_IRUGO, root, cd,
				   &genwqe_curr_regs_fops);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	file = debugfs_create_file("curr_dbg_uid0", S_IRUGO, root, cd,
				   &genwqe_curr_dbg_uid0_fops);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	file = debugfs_create_file("curr_dbg_uid1", S_IRUGO, root, cd,
				   &genwqe_curr_dbg_uid1_fops);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	file = debugfs_create_file("curr_dbg_uid2", S_IRUGO, root, cd,
				   &genwqe_curr_dbg_uid2_fops);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	file = debugfs_create_file("prev_regs", S_IRUGO, root, cd,
				   &genwqe_prev_regs_fops);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	file = debugfs_create_file("prev_dbg_uid0", S_IRUGO, root, cd,
				   &genwqe_prev_dbg_uid0_fops);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	file = debugfs_create_file("prev_dbg_uid1", S_IRUGO, root, cd,
				   &genwqe_prev_dbg_uid1_fops);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	file = debugfs_create_file("prev_dbg_uid2", S_IRUGO, root, cd,
				   &genwqe_prev_dbg_uid2_fops);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	for (i = 0; i <  GENWQE_MAX_VFS; i++) {
		sprintf(name, "vf%u_jobtimeout_msec", i);

		file = debugfs_create_u32(name, 0666, root,
					  &cd->vf_jobtimeout_msec[i]);
		if (!file) {
			ret = -ENOMEM;
			goto err1;
		}
	}

	file = debugfs_create_file("jobtimer", S_IRUGO, root, cd,
				   &genwqe_jtimer_fops);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	file = debugfs_create_file("queue_working_time", S_IRUGO, root, cd,
				   &genwqe_queue_working_time_fops);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	file = debugfs_create_u32("skip_recovery", 0666, root,
				  &cd->skip_recovery);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	file = debugfs_create_u32("use_platform_recovery", 0666, root,
				  &cd->use_platform_recovery);
	if (!file) {
		ret = -ENOMEM;
		goto err1;
	}

	cd->debugfs_root = root;
	return 0;
err1:
	debugfs_remove_recursive(root);
err0:
	return ret;
}

void genqwe_exit_debugfs(struct genwqe_dev *cd)
{
	debugfs_remove_recursive(cd->debugfs_root);
}
Commit	Line	Data
c59330cd FH	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>
26d8f6f1	8	* Author: Michael Jung <mijung@gmx.net>
c59330cd FH	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>
c59330cd FH	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"
1451f414 FH	247	" return_on_busy: %u\n"
1451f414 FH	248	" wait_on_busy: %u\n"
c59330cd FH	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,
1451f414 FH	255	queue->return_on_busy, queue->wait_on_busy,
1451f414 FH	256	cd->irqs_processed);
c59330cd FH	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",
64df2ec5	328	GENWQE_DEVNAME, DRV_VERSION, dev_name(&pci_dev->dev),
c59330cd FH	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
32d9dbe3	353	sprintf(card_name, "%s%d_card", GENWQE_DEVNAME, cd->card_idx);
c59330cd FH	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++) {
32d9dbe3	459	sprintf(name, "vf%u_jobtimeout_msec", i);
c59330cd FH	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
fb145456 KSS	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
c59330cd FH	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	}