[mirror_ubuntu-bionic-kernel.git] / kernel / irq / debugfs.c

/*
 * Copyright 2017 Thomas Gleixner <tglx@linutronix.de>
 *
 * This file is licensed under the GPL V2.
 */
#include <linux/debugfs.h>
#include <linux/irqdomain.h>
#include <linux/irq.h>

#include "internals.h"

static struct dentry *irq_dir;

struct irq_bit_descr {
	unsigned int	mask;
	char		*name;
};
#define BIT_MASK_DESCR(m)	{ .mask = m, .name = #m }

static void irq_debug_show_bits(struct seq_file *m, int ind, unsigned int state,
				const struct irq_bit_descr *sd, int size)
{
	int i;

	for (i = 0; i < size; i++, sd++) {
		if (state & sd->mask)
			seq_printf(m, "%*s%s\n", ind + 12, "", sd->name);
	}
}

#ifdef CONFIG_SMP
static void irq_debug_show_masks(struct seq_file *m, struct irq_desc *desc)
{
	struct irq_data *data = irq_desc_get_irq_data(desc);
	struct cpumask *msk;

	msk = irq_data_get_affinity_mask(data);
	seq_printf(m, "affinity: %*pbl\n", cpumask_pr_args(msk));
#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
	msk = irq_data_get_effective_affinity_mask(data);
	seq_printf(m, "effectiv: %*pbl\n", cpumask_pr_args(msk));
#endif
#ifdef CONFIG_GENERIC_PENDING_IRQ
	msk = desc->pending_mask;
	seq_printf(m, "pending:  %*pbl\n", cpumask_pr_args(msk));
#endif
}
#else
static void irq_debug_show_masks(struct seq_file *m, struct irq_desc *desc) { }
#endif

static const struct irq_bit_descr irqchip_flags[] = {
	BIT_MASK_DESCR(IRQCHIP_SET_TYPE_MASKED),
	BIT_MASK_DESCR(IRQCHIP_EOI_IF_HANDLED),
	BIT_MASK_DESCR(IRQCHIP_MASK_ON_SUSPEND),
	BIT_MASK_DESCR(IRQCHIP_ONOFFLINE_ENABLED),
	BIT_MASK_DESCR(IRQCHIP_SKIP_SET_WAKE),
	BIT_MASK_DESCR(IRQCHIP_ONESHOT_SAFE),
	BIT_MASK_DESCR(IRQCHIP_EOI_THREADED),
};

static void
irq_debug_show_chip(struct seq_file *m, struct irq_data *data, int ind)
{
	struct irq_chip *chip = data->chip;

	if (!chip) {
		seq_printf(m, "chip: None\n");
		return;
	}
	seq_printf(m, "%*schip:    %s\n", ind, "", chip->name);
	seq_printf(m, "%*sflags:   0x%lx\n", ind + 1, "", chip->flags);
	irq_debug_show_bits(m, ind, chip->flags, irqchip_flags,
			    ARRAY_SIZE(irqchip_flags));
}

static void
irq_debug_show_data(struct seq_file *m, struct irq_data *data, int ind)
{
	seq_printf(m, "%*sdomain:  %s\n", ind, "",
		   data->domain ? data->domain->name : "");
	seq_printf(m, "%*shwirq:   0x%lx\n", ind + 1, "", data->hwirq);
	irq_debug_show_chip(m, data, ind + 1);
#ifdef	CONFIG_IRQ_DOMAIN_HIERARCHY
	if (!data->parent_data)
		return;
	seq_printf(m, "%*sparent:\n", ind + 1, "");
	irq_debug_show_data(m, data->parent_data, ind + 4);
#endif
}

static const struct irq_bit_descr irqdata_states[] = {
	BIT_MASK_DESCR(IRQ_TYPE_EDGE_RISING),
	BIT_MASK_DESCR(IRQ_TYPE_EDGE_FALLING),
	BIT_MASK_DESCR(IRQ_TYPE_LEVEL_HIGH),
	BIT_MASK_DESCR(IRQ_TYPE_LEVEL_LOW),
	BIT_MASK_DESCR(IRQD_LEVEL),

	BIT_MASK_DESCR(IRQD_ACTIVATED),
	BIT_MASK_DESCR(IRQD_IRQ_STARTED),
	BIT_MASK_DESCR(IRQD_IRQ_DISABLED),
	BIT_MASK_DESCR(IRQD_IRQ_MASKED),
	BIT_MASK_DESCR(IRQD_IRQ_INPROGRESS),

	BIT_MASK_DESCR(IRQD_PER_CPU),
	BIT_MASK_DESCR(IRQD_NO_BALANCING),

	BIT_MASK_DESCR(IRQD_MOVE_PCNTXT),
	BIT_MASK_DESCR(IRQD_AFFINITY_SET),
	BIT_MASK_DESCR(IRQD_SETAFFINITY_PENDING),
	BIT_MASK_DESCR(IRQD_AFFINITY_MANAGED),
	BIT_MASK_DESCR(IRQD_MANAGED_SHUTDOWN),

	BIT_MASK_DESCR(IRQD_FORWARDED_TO_VCPU),

	BIT_MASK_DESCR(IRQD_WAKEUP_STATE),
	BIT_MASK_DESCR(IRQD_WAKEUP_ARMED),
};

static const struct irq_bit_descr irqdesc_states[] = {
	BIT_MASK_DESCR(_IRQ_NOPROBE),
	BIT_MASK_DESCR(_IRQ_NOREQUEST),
	BIT_MASK_DESCR(_IRQ_NOTHREAD),
	BIT_MASK_DESCR(_IRQ_NOAUTOEN),
	BIT_MASK_DESCR(_IRQ_NESTED_THREAD),
	BIT_MASK_DESCR(_IRQ_PER_CPU_DEVID),
	BIT_MASK_DESCR(_IRQ_IS_POLLED),
	BIT_MASK_DESCR(_IRQ_DISABLE_UNLAZY),
};

static const struct irq_bit_descr irqdesc_istates[] = {
	BIT_MASK_DESCR(IRQS_AUTODETECT),
	BIT_MASK_DESCR(IRQS_SPURIOUS_DISABLED),
	BIT_MASK_DESCR(IRQS_POLL_INPROGRESS),
	BIT_MASK_DESCR(IRQS_ONESHOT),
	BIT_MASK_DESCR(IRQS_REPLAY),
	BIT_MASK_DESCR(IRQS_WAITING),
	BIT_MASK_DESCR(IRQS_PENDING),
	BIT_MASK_DESCR(IRQS_SUSPENDED),
};


static int irq_debug_show(struct seq_file *m, void *p)
{
	struct irq_desc *desc = m->private;
	struct irq_data *data;

	raw_spin_lock_irq(&desc->lock);
	data = irq_desc_get_irq_data(desc);
	seq_printf(m, "handler:  %pf\n", desc->handle_irq);
	seq_printf(m, "status:   0x%08x\n", desc->status_use_accessors);
	irq_debug_show_bits(m, 0, desc->status_use_accessors, irqdesc_states,
			    ARRAY_SIZE(irqdesc_states));
	seq_printf(m, "istate:   0x%08x\n", desc->istate);
	irq_debug_show_bits(m, 0, desc->istate, irqdesc_istates,
			    ARRAY_SIZE(irqdesc_istates));
	seq_printf(m, "ddepth:   %u\n", desc->depth);
	seq_printf(m, "wdepth:   %u\n", desc->wake_depth);
	seq_printf(m, "dstate:   0x%08x\n", irqd_get(data));
	irq_debug_show_bits(m, 0, irqd_get(data), irqdata_states,
			    ARRAY_SIZE(irqdata_states));
	seq_printf(m, "node:     %d\n", irq_data_get_node(data));
	irq_debug_show_masks(m, desc);
	irq_debug_show_data(m, data, 0);
	raw_spin_unlock_irq(&desc->lock);
	return 0;
}

static int irq_debug_open(struct inode *inode, struct file *file)
{
	return single_open(file, irq_debug_show, inode->i_private);
}

static const struct file_operations dfs_irq_ops = {
	.open		= irq_debug_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

void irq_add_debugfs_entry(unsigned int irq, struct irq_desc *desc)
{
	char name [10];

	if (!irq_dir || !desc || desc->debugfs_file)
		return;

	sprintf(name, "%d", irq);
	desc->debugfs_file = debugfs_create_file(name, 0444, irq_dir, desc,
						 &dfs_irq_ops);
}

void irq_remove_debugfs_entry(struct irq_desc *desc)
{
	if (desc->debugfs_file)
		debugfs_remove(desc->debugfs_file);
}

static int __init irq_debugfs_init(void)
{
	struct dentry *root_dir;
	int irq;

	root_dir = debugfs_create_dir("irq", NULL);
	if (!root_dir)
		return -ENOMEM;

	irq_domain_debugfs_init(root_dir);

	irq_dir = debugfs_create_dir("irqs", root_dir);

	irq_lock_sparse();
	for_each_active_irq(irq)
		irq_add_debugfs_entry(irq, irq_to_desc(irq));
	irq_unlock_sparse();

	return 0;
}
__initcall(irq_debugfs_init);
Commit	Line	Data
087cdfb6 TG	1	/*
	2	* Copyright 2017 Thomas Gleixner <tglx@linutronix.de>
	3	*
	4	* This file is licensed under the GPL V2.
	5	*/
	6	#include <linux/debugfs.h>
	7	#include <linux/irqdomain.h>
	8	#include <linux/irq.h>
	9
	10	#include "internals.h"
	11
	12	static struct dentry *irq_dir;
	13
	14	struct irq_bit_descr {
	15	unsigned int mask;
	16	char *name;
	17	};
	18	#define BIT_MASK_DESCR(m) { .mask = m, .name = #m }
	19
	20	static void irq_debug_show_bits(struct seq_file *m, int ind, unsigned int state,
	21	const struct irq_bit_descr *sd, int size)
	22	{
	23	int i;
	24
	25	for (i = 0; i < size; i++, sd++) {
	26	if (state & sd->mask)
	27	seq_printf(m, "%*s%s\n", ind + 12, "", sd->name);
	28	}
	29	}
	30
	31	#ifdef CONFIG_SMP
	32	static void irq_debug_show_masks(struct seq_file m, struct irq_desc desc)
	33	{
	34	struct irq_data *data = irq_desc_get_irq_data(desc);
	35	struct cpumask *msk;
	36
	37	msk = irq_data_get_affinity_mask(data);
	38	seq_printf(m, "affinity: %*pbl\n", cpumask_pr_args(msk));
0d3f5425 TG	39	#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
	40	msk = irq_data_get_effective_affinity_mask(data);
	41	seq_printf(m, "effectiv: %*pbl\n", cpumask_pr_args(msk));
	42	#endif
087cdfb6 TG	43	#ifdef CONFIG_GENERIC_PENDING_IRQ
	44	msk = desc->pending_mask;
	45	seq_printf(m, "pending: %*pbl\n", cpumask_pr_args(msk));
	46	#endif
	47	}
	48	#else
	49	static void irq_debug_show_masks(struct seq_file m, struct irq_desc desc) { }
	50	#endif
	51
	52	static const struct irq_bit_descr irqchip_flags[] = {
	53	BIT_MASK_DESCR(IRQCHIP_SET_TYPE_MASKED),
	54	BIT_MASK_DESCR(IRQCHIP_EOI_IF_HANDLED),
	55	BIT_MASK_DESCR(IRQCHIP_MASK_ON_SUSPEND),
	56	BIT_MASK_DESCR(IRQCHIP_ONOFFLINE_ENABLED),
	57	BIT_MASK_DESCR(IRQCHIP_SKIP_SET_WAKE),
	58	BIT_MASK_DESCR(IRQCHIP_ONESHOT_SAFE),
	59	BIT_MASK_DESCR(IRQCHIP_EOI_THREADED),
	60	};
	61
	62	static void
	63	irq_debug_show_chip(struct seq_file m, struct irq_data data, int ind)
	64	{
	65	struct irq_chip *chip = data->chip;
	66
	67	if (!chip) {
	68	seq_printf(m, "chip: None\n");
	69	return;
	70	}
	71	seq_printf(m, "%*schip: %s\n", ind, "", chip->name);
	72	seq_printf(m, "%*sflags: 0x%lx\n", ind + 1, "", chip->flags);
	73	irq_debug_show_bits(m, ind, chip->flags, irqchip_flags,
	74	ARRAY_SIZE(irqchip_flags));
	75	}
	76
	77	static void
	78	irq_debug_show_data(struct seq_file m, struct irq_data data, int ind)
	79	{
	80	seq_printf(m, "%*sdomain: %s\n", ind, "",
	81	data->domain ? data->domain->name : "");
	82	seq_printf(m, "%*shwirq: 0x%lx\n", ind + 1, "", data->hwirq);
	83	irq_debug_show_chip(m, data, ind + 1);
	84	#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
	85	if (!data->parent_data)
	86	return;
	87	seq_printf(m, "%*sparent:\n", ind + 1, "");
	88	irq_debug_show_data(m, data->parent_data, ind + 4);
	89	#endif
	90	}
	91
	92	static const struct irq_bit_descr irqdata_states[] = {
	93	BIT_MASK_DESCR(IRQ_TYPE_EDGE_RISING),
	94	BIT_MASK_DESCR(IRQ_TYPE_EDGE_FALLING),
	95	BIT_MASK_DESCR(IRQ_TYPE_LEVEL_HIGH),
	96	BIT_MASK_DESCR(IRQ_TYPE_LEVEL_LOW),
	97	BIT_MASK_DESCR(IRQD_LEVEL),
	98
	99	BIT_MASK_DESCR(IRQD_ACTIVATED),
	100	BIT_MASK_DESCR(IRQD_IRQ_STARTED),
	101	BIT_MASK_DESCR(IRQD_IRQ_DISABLED),
	102	BIT_MASK_DESCR(IRQD_IRQ_MASKED),
	103	BIT_MASK_DESCR(IRQD_IRQ_INPROGRESS),
	104
	105	BIT_MASK_DESCR(IRQD_PER_CPU),
	106	BIT_MASK_DESCR(IRQD_NO_BALANCING),
107
108	BIT_MASK_DESCR(IRQD_MOVE_PCNTXT),
109	BIT_MASK_DESCR(IRQD_AFFINITY_SET),
110	BIT_MASK_DESCR(IRQD_SETAFFINITY_PENDING),
111	BIT_MASK_DESCR(IRQD_AFFINITY_MANAGED),
112	BIT_MASK_DESCR(IRQD_MANAGED_SHUTDOWN),
113
114	BIT_MASK_DESCR(IRQD_FORWARDED_TO_VCPU),
115
116	BIT_MASK_DESCR(IRQD_WAKEUP_STATE),
117	BIT_MASK_DESCR(IRQD_WAKEUP_ARMED),
118	};
119
120	static const struct irq_bit_descr irqdesc_states[] = {
121	BIT_MASK_DESCR(_IRQ_NOPROBE),
122	BIT_MASK_DESCR(_IRQ_NOREQUEST),
123	BIT_MASK_DESCR(_IRQ_NOTHREAD),
124	BIT_MASK_DESCR(_IRQ_NOAUTOEN),
125	BIT_MASK_DESCR(_IRQ_NESTED_THREAD),
126	BIT_MASK_DESCR(_IRQ_PER_CPU_DEVID),
127	BIT_MASK_DESCR(_IRQ_IS_POLLED),
128	BIT_MASK_DESCR(_IRQ_DISABLE_UNLAZY),
129	};
130
131	static const struct irq_bit_descr irqdesc_istates[] = {
132	BIT_MASK_DESCR(IRQS_AUTODETECT),
133	BIT_MASK_DESCR(IRQS_SPURIOUS_DISABLED),
134	BIT_MASK_DESCR(IRQS_POLL_INPROGRESS),
135	BIT_MASK_DESCR(IRQS_ONESHOT),
136	BIT_MASK_DESCR(IRQS_REPLAY),
137	BIT_MASK_DESCR(IRQS_WAITING),
138	BIT_MASK_DESCR(IRQS_PENDING),
139	BIT_MASK_DESCR(IRQS_SUSPENDED),
140	};
141
142
143	static int irq_debug_show(struct seq_file m, void p)
144	{
145	struct irq_desc *desc = m->private;
146	struct irq_data *data;
147
148	raw_spin_lock_irq(&desc->lock);
149	data = irq_desc_get_irq_data(desc);
150	seq_printf(m, "handler: %pf\n", desc->handle_irq);
151	seq_printf(m, "status: 0x%08x\n", desc->status_use_accessors);
152	irq_debug_show_bits(m, 0, desc->status_use_accessors, irqdesc_states,
153	ARRAY_SIZE(irqdesc_states));
154	seq_printf(m, "istate: 0x%08x\n", desc->istate);
155	irq_debug_show_bits(m, 0, desc->istate, irqdesc_istates,
156	ARRAY_SIZE(irqdesc_istates));
157	seq_printf(m, "ddepth: %u\n", desc->depth);
158	seq_printf(m, "wdepth: %u\n", desc->wake_depth);
159	seq_printf(m, "dstate: 0x%08x\n", irqd_get(data));
160	irq_debug_show_bits(m, 0, irqd_get(data), irqdata_states,
161	ARRAY_SIZE(irqdata_states));
162	seq_printf(m, "node: %d\n", irq_data_get_node(data));
163	irq_debug_show_masks(m, desc);
164	irq_debug_show_data(m, data, 0);
165	raw_spin_unlock_irq(&desc->lock);
166	return 0;
167	}
168
169	static int irq_debug_open(struct inode inode, struct file file)
170	{
171	return single_open(file, irq_debug_show, inode->i_private);
172	}
173
174	static const struct file_operations dfs_irq_ops = {
175	.open = irq_debug_open,
176	.read = seq_read,
177	.llseek = seq_lseek,
178	.release = single_release,
179	};
180
181	void irq_add_debugfs_entry(unsigned int irq, struct irq_desc *desc)
182	{
183	char name [10];
184
185	if (!irq_dir \|\| !desc \|\| desc->debugfs_file)
186	return;
187
188	sprintf(name, "%d", irq);
189	desc->debugfs_file = debugfs_create_file(name, 0444, irq_dir, desc,
190	&dfs_irq_ops);
191	}
192
193	void irq_remove_debugfs_entry(struct irq_desc *desc)
194	{
195	if (desc->debugfs_file)
196	debugfs_remove(desc->debugfs_file);
197	}
198
199	static int __init irq_debugfs_init(void)
200	{
201	struct dentry *root_dir;
202	int irq;
203
204	root_dir = debugfs_create_dir("irq", NULL);
205	if (!root_dir)
206	return -ENOMEM;
207
208	irq_domain_debugfs_init(root_dir);
209
210	irq_dir = debugfs_create_dir("irqs", root_dir);
211
212	irq_lock_sparse();
213	for_each_active_irq(irq)
214	irq_add_debugfs_entry(irq, irq_to_desc(irq));
215	irq_unlock_sparse();
216
217	return 0;
218	}
219	__initcall(irq_debugfs_init);