[GitHub/mt8127/android_kernel_alcatel_ttab.git] / kernel / irq / proc.c

/*
 * linux/kernel/irq/proc.c
 *
 * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
 *
 * This file contains the /proc/irq/ handling code.
 */

#include <linux/irq.h>
#include <linux/gfp.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/interrupt.h>
#include <linux/kernel_stat.h>

#include "internals.h"

static struct proc_dir_entry *root_irq_dir;

#ifdef CONFIG_SMP

static int irq_affinity_proc_show(struct seq_file *m, void *v)
{
	struct irq_desc *desc = irq_to_desc((long)m->private);
	const struct cpumask *mask = desc->irq_data.affinity;

#ifdef CONFIG_GENERIC_PENDING_IRQ
	if (irqd_is_setaffinity_pending(&desc->irq_data))
		mask = desc->pending_mask;
#endif
	seq_cpumask(m, mask);
	seq_putc(m, '\n');
	return 0;
}

static int irq_affinity_hint_proc_show(struct seq_file *m, void *v)
{
	struct irq_desc *desc = irq_to_desc((long)m->private);
	unsigned long flags;
	cpumask_var_t mask;

	if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
		return -ENOMEM;

	raw_spin_lock_irqsave(&desc->lock, flags);
	if (desc->affinity_hint)
		cpumask_copy(mask, desc->affinity_hint);
	raw_spin_unlock_irqrestore(&desc->lock, flags);

	seq_cpumask(m, mask);
	seq_putc(m, '\n');
	free_cpumask_var(mask);

	return 0;
}

#ifndef is_affinity_mask_valid
#define is_affinity_mask_valid(val) 1
#endif

int no_irq_affinity;
static ssize_t irq_affinity_proc_write(struct file *file,
		const char __user *buffer, size_t count, loff_t *pos)
{
	unsigned int irq = (int)(long)PDE(file->f_path.dentry->d_inode)->data;
	cpumask_var_t new_value;
	int err;

	if (!irq_can_set_affinity(irq) || no_irq_affinity)
		return -EIO;

	if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
		return -ENOMEM;

	err = cpumask_parse_user(buffer, count, new_value);
	if (err)
		goto free_cpumask;

	if (!is_affinity_mask_valid(new_value)) {
		err = -EINVAL;
		goto free_cpumask;
	}

	/*
	 * Do not allow disabling IRQs completely - it's a too easy
	 * way to make the system unusable accidentally :-) At least
	 * one online CPU still has to be targeted.
	 */
	if (!cpumask_intersects(new_value, cpu_online_mask)) {
		/* Special case for empty set - allow the architecture
		   code to set default SMP affinity. */
		err = irq_select_affinity_usr(irq, new_value) ? -EINVAL : count;
	} else {
		irq_set_affinity(irq, new_value);
		err = count;
	}

free_cpumask:
	free_cpumask_var(new_value);
	return err;
}

static int irq_affinity_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, irq_affinity_proc_show, PDE(inode)->data);
}

static int irq_affinity_hint_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, irq_affinity_hint_proc_show, PDE(inode)->data);
}

static const struct file_operations irq_affinity_proc_fops = {
	.open		= irq_affinity_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= irq_affinity_proc_write,
};

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

static int default_affinity_show(struct seq_file *m, void *v)
{
	seq_cpumask(m, irq_default_affinity);
	seq_putc(m, '\n');
	return 0;
}

static ssize_t default_affinity_write(struct file *file,
		const char __user *buffer, size_t count, loff_t *ppos)
{
	cpumask_var_t new_value;
	int err;

	if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
		return -ENOMEM;

	err = cpumask_parse_user(buffer, count, new_value);
	if (err)
		goto out;

	if (!is_affinity_mask_valid(new_value)) {
		err = -EINVAL;
		goto out;
	}

	/*
	 * Do not allow disabling IRQs completely - it's a too easy
	 * way to make the system unusable accidentally :-) At least
	 * one online CPU still has to be targeted.
	 */
	if (!cpumask_intersects(new_value, cpu_online_mask)) {
		err = -EINVAL;
		goto out;
	}

	cpumask_copy(irq_default_affinity, new_value);
	err = count;

out:
	free_cpumask_var(new_value);
	return err;
}

static int default_affinity_open(struct inode *inode, struct file *file)
{
	return single_open(file, default_affinity_show, PDE(inode)->data);
}

static const struct file_operations default_affinity_proc_fops = {
	.open		= default_affinity_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= default_affinity_write,
};

static int irq_node_proc_show(struct seq_file *m, void *v)
{
	struct irq_desc *desc = irq_to_desc((long) m->private);

	seq_printf(m, "%d\n", desc->irq_data.node);
	return 0;
}

static int irq_node_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, irq_node_proc_show, PDE(inode)->data);
}

static const struct file_operations irq_node_proc_fops = {
	.open		= irq_node_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};
#endif

static int irq_spurious_proc_show(struct seq_file *m, void *v)
{
	struct irq_desc *desc = irq_to_desc((long) m->private);

	seq_printf(m, "count %u\n" "unhandled %u\n" "last_unhandled %u ms\n",
		   desc->irq_count, desc->irqs_unhandled,
		   jiffies_to_msecs(desc->last_unhandled));
	return 0;
}

static int irq_spurious_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, irq_spurious_proc_show, PDE(inode)->data);
}

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

#define MAX_NAMELEN 128

static int name_unique(unsigned int irq, struct irqaction *new_action)
{
	struct irq_desc *desc = irq_to_desc(irq);
	struct irqaction *action;
	unsigned long flags;
	int ret = 1;

	raw_spin_lock_irqsave(&desc->lock, flags);
	for (action = desc->action ; action; action = action->next) {
		if ((action != new_action) && action->name &&
				!strcmp(new_action->name, action->name)) {
			ret = 0;
			break;
		}
	}
	raw_spin_unlock_irqrestore(&desc->lock, flags);
	return ret;
}

void register_handler_proc(unsigned int irq, struct irqaction *action)
{
	char name [MAX_NAMELEN];
	struct irq_desc *desc = irq_to_desc(irq);

	if (!desc->dir || action->dir || !action->name ||
					!name_unique(irq, action))
		return;

	memset(name, 0, MAX_NAMELEN);
	snprintf(name, MAX_NAMELEN, "%s", action->name);

	/* create /proc/irq/1234/handler/ */
	action->dir = proc_mkdir(name, desc->dir);
}

#undef MAX_NAMELEN

#define MAX_NAMELEN 10

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

	if (!root_irq_dir || (desc->irq_data.chip == &no_irq_chip) || desc->dir)
		return;

	memset(name, 0, MAX_NAMELEN);
	sprintf(name, "%d", irq);

	/* create /proc/irq/1234 */
	desc->dir = proc_mkdir(name, root_irq_dir);
	if (!desc->dir)
		return;

#ifdef CONFIG_SMP
	/* create /proc/irq/<irq>/smp_affinity */
	proc_create_data("smp_affinity", 0600, desc->dir,
			 &irq_affinity_proc_fops, (void *)(long)irq);

	/* create /proc/irq/<irq>/affinity_hint */
	proc_create_data("affinity_hint", 0400, desc->dir,
			 &irq_affinity_hint_proc_fops, (void *)(long)irq);

	proc_create_data("node", 0444, desc->dir,
			 &irq_node_proc_fops, (void *)(long)irq);
#endif

	proc_create_data("spurious", 0444, desc->dir,
			 &irq_spurious_proc_fops, (void *)(long)irq);
}

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

	if (!root_irq_dir || !desc->dir)
		return;
#ifdef CONFIG_SMP
	remove_proc_entry("smp_affinity", desc->dir);
	remove_proc_entry("affinity_hint", desc->dir);
	remove_proc_entry("node", desc->dir);
#endif
	remove_proc_entry("spurious", desc->dir);

	memset(name, 0, MAX_NAMELEN);
	sprintf(name, "%u", irq);
	remove_proc_entry(name, root_irq_dir);
}

#undef MAX_NAMELEN

void unregister_handler_proc(unsigned int irq, struct irqaction *action)
{
	if (action->dir) {
		struct irq_desc *desc = irq_to_desc(irq);

		remove_proc_entry(action->dir->name, desc->dir);
	}
}

static void register_default_affinity_proc(void)
{
#ifdef CONFIG_SMP
	proc_create("irq/default_smp_affinity", 0600, NULL,
		    &default_affinity_proc_fops);
#endif
}

void init_irq_proc(void)
{
	unsigned int irq;
	struct irq_desc *desc;

	/* create /proc/irq */
	root_irq_dir = proc_mkdir("irq", NULL);
	if (!root_irq_dir)
		return;

	register_default_affinity_proc();

	/*
	 * Create entries for all existing IRQs.
	 */
	for_each_irq_desc(irq, desc) {
		if (!desc)
			continue;

		register_irq_proc(irq, desc);
	}
}

#ifdef CONFIG_GENERIC_IRQ_SHOW

int __weak arch_show_interrupts(struct seq_file *p, int prec)
{
	return 0;
}

#ifndef ACTUAL_NR_IRQS
# define ACTUAL_NR_IRQS nr_irqs
#endif

int show_interrupts(struct seq_file *p, void *v)
{
	static int prec;

	unsigned long flags, any_count = 0;
	int i = *(loff_t *) v, j;
	struct irqaction *action;
	struct irq_desc *desc;

	if (i > ACTUAL_NR_IRQS)
		return 0;

	if (i == ACTUAL_NR_IRQS)
		return arch_show_interrupts(p, prec);

	/* print header and calculate the width of the first column */
	if (i == 0) {
		for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec)
			j *= 10;

		seq_printf(p, "%*s", prec + 8, "");
		for_each_online_cpu(j)
			seq_printf(p, "CPU%-8d", j);
		seq_putc(p, '\n');
	}

	desc = irq_to_desc(i);
	if (!desc)
		return 0;

	raw_spin_lock_irqsave(&desc->lock, flags);
	for_each_online_cpu(j)
		any_count |= kstat_irqs_cpu(i, j);
	action = desc->action;
	if (!action && !any_count)
		goto out;

	seq_printf(p, "%*d: ", prec, i);
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));

	if (desc->irq_data.chip) {
		if (desc->irq_data.chip->irq_print_chip)
			desc->irq_data.chip->irq_print_chip(&desc->irq_data, p);
		else if (desc->irq_data.chip->name)
			seq_printf(p, " %8s", desc->irq_data.chip->name);
		else
			seq_printf(p, " %8s", "-");
	} else {
		seq_printf(p, " %8s", "None");
	}
#ifdef CONFIG_GENERIC_IRQ_SHOW_LEVEL
	seq_printf(p, " %-8s", irqd_is_level_type(&desc->irq_data) ? "Level" : "Edge");
#endif
	if (desc->name)
		seq_printf(p, "-%-8s", desc->name);

	if (action) {
		seq_printf(p, "  %s", action->name);
		while ((action = action->next) != NULL)
			seq_printf(p, ", %s", action->name);
	}

	seq_putc(p, '\n');
out:
	raw_spin_unlock_irqrestore(&desc->lock, flags);
	return 0;
}
#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/kernel/irq/proc.c
	3	*
	4	* Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
	5	*
	6	* This file contains the /proc/irq/ handling code.
	7	*/
	8
	9	#include <linux/irq.h>
5a0e3ad6	10	#include <linux/gfp.h>
1da177e4	11	#include <linux/proc_fs.h>
f18e439d	12	#include <linux/seq_file.h>
1da177e4	13	#include <linux/interrupt.h>
c78b9b65	14	#include <linux/kernel_stat.h>
1da177e4	15
97a41e26 AB	16	#include "internals.h"
97a41e26 AB	17
4a733ee1	18	static struct proc_dir_entry *root_irq_dir;
1da177e4 LT	19
	20	#ifdef CONFIG_SMP
	21
f18e439d	22	static int irq_affinity_proc_show(struct seq_file m, void v)
1da177e4	23	{
08678b08	24	struct irq_desc *desc = irq_to_desc((long)m->private);
6b8ff312	25	const struct cpumask *mask = desc->irq_data.affinity;
42ee2b74 AK	26
42ee2b74 AK	27	#ifdef CONFIG_GENERIC_PENDING_IRQ
f230b6d5	28	if (irqd_is_setaffinity_pending(&desc->irq_data))
7f7ace0c	29	mask = desc->pending_mask;
42ee2b74	30	#endif
f18e439d AD	31	seq_cpumask(m, mask);
	32	seq_putc(m, '\n');
	33	return 0;
1da177e4 LT	34	}
1da177e4 LT	35
e7a297b0 PWJ	36	static int irq_affinity_hint_proc_show(struct seq_file m, void v)
	37	{
	38	struct irq_desc *desc = irq_to_desc((long)m->private);
	39	unsigned long flags;
	40	cpumask_var_t mask;
	41
4308ad80	42	if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
e7a297b0 PWJ	43	return -ENOMEM;
	44
	45	raw_spin_lock_irqsave(&desc->lock, flags);
	46	if (desc->affinity_hint)
	47	cpumask_copy(mask, desc->affinity_hint);
e7a297b0 PWJ	48	raw_spin_unlock_irqrestore(&desc->lock, flags);
	49
	50	seq_cpumask(m, mask);
	51	seq_putc(m, '\n');
	52	free_cpumask_var(mask);
	53
	54	return 0;
	55	}
	56
25d61578 JK	57	#ifndef is_affinity_mask_valid
	58	#define is_affinity_mask_valid(val) 1
	59	#endif
	60
1da177e4	61	int no_irq_affinity;
f18e439d AD	62	static ssize_t irq_affinity_proc_write(struct file *file,
f18e439d AD	63	const char __user buffer, size_t count, loff_t pos)
1da177e4	64	{
f18e439d	65	unsigned int irq = (int)(long)PDE(file->f_path.dentry->d_inode)->data;
0de26520	66	cpumask_var_t new_value;
f18e439d	67	int err;
1da177e4	68
bce43032	69	if (!irq_can_set_affinity(irq) \|\| no_irq_affinity)
1da177e4 LT	70	return -EIO;
1da177e4 LT	71
0de26520 RR	72	if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
	73	return -ENOMEM;
	74
	75	err = cpumask_parse_user(buffer, count, new_value);
1da177e4	76	if (err)
0de26520	77	goto free_cpumask;
1da177e4	78
6bdf197b	79	if (!is_affinity_mask_valid(new_value)) {
0de26520 RR	80	err = -EINVAL;
	81	goto free_cpumask;
	82	}
25d61578	83
1da177e4 LT	84	/*
	85	* Do not allow disabling IRQs completely - it's a too easy
	86	* way to make the system unusable accidentally :-) At least
	87	* one online CPU still has to be targeted.
	88	*/
0de26520	89	if (!cpumask_intersects(new_value, cpu_online_mask)) {
eee45269 IK	90	/* Special case for empty set - allow the architecture
eee45269 IK	91	code to set default SMP affinity. */
3b8249e7	92	err = irq_select_affinity_usr(irq, new_value) ? -EINVAL : count;
0de26520 RR	93	} else {
	94	irq_set_affinity(irq, new_value);
	95	err = count;
	96	}
	97
	98	free_cpumask:
	99	free_cpumask_var(new_value);
	100	return err;
1da177e4 LT	101	}
1da177e4 LT	102
f18e439d	103	static int irq_affinity_proc_open(struct inode inode, struct file file)
18404756	104	{
f18e439d	105	return single_open(file, irq_affinity_proc_show, PDE(inode)->data);
18404756 MK	106	}
18404756 MK	107
e7a297b0 PWJ	108	static int irq_affinity_hint_proc_open(struct inode inode, struct file file)
	109	{
	110	return single_open(file, irq_affinity_hint_proc_show, PDE(inode)->data);
	111	}
	112
f18e439d AD	113	static const struct file_operations irq_affinity_proc_fops = {
	114	.open = irq_affinity_proc_open,
	115	.read = seq_read,
	116	.llseek = seq_lseek,
	117	.release = single_release,
	118	.write = irq_affinity_proc_write,
	119	};
	120
e7a297b0 PWJ	121	static const struct file_operations irq_affinity_hint_proc_fops = {
	122	.open = irq_affinity_hint_proc_open,
	123	.read = seq_read,
	124	.llseek = seq_lseek,
	125	.release = single_release,
	126	};
	127
f18e439d AD	128	static int default_affinity_show(struct seq_file m, void v)
f18e439d AD	129	{
d036e67b	130	seq_cpumask(m, irq_default_affinity);
f18e439d AD	131	seq_putc(m, '\n');
	132	return 0;
	133	}
	134
	135	static ssize_t default_affinity_write(struct file *file,
	136	const char __user buffer, size_t count, loff_t ppos)
18404756	137	{
d036e67b	138	cpumask_var_t new_value;
f18e439d	139	int err;
18404756	140
d036e67b RR	141	if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
	142	return -ENOMEM;
	143
	144	err = cpumask_parse_user(buffer, count, new_value);
18404756	145	if (err)
d036e67b	146	goto out;
18404756	147
d036e67b RR	148	if (!is_affinity_mask_valid(new_value)) {
	149	err = -EINVAL;
	150	goto out;
	151	}
18404756 MK	152
	153	/*
	154	* Do not allow disabling IRQs completely - it's a too easy
	155	* way to make the system unusable accidentally :-) At least
	156	* one online CPU still has to be targeted.
	157	*/
d036e67b RR	158	if (!cpumask_intersects(new_value, cpu_online_mask)) {
	159	err = -EINVAL;
	160	goto out;
	161	}
18404756	162
d036e67b RR	163	cpumask_copy(irq_default_affinity, new_value);
d036e67b RR	164	err = count;
18404756	165
d036e67b RR	166	out:
	167	free_cpumask_var(new_value);
	168	return err;
18404756	169	}
f18e439d AD	170
	171	static int default_affinity_open(struct inode inode, struct file file)
	172	{
34769945	173	return single_open(file, default_affinity_show, PDE(inode)->data);
f18e439d AD	174	}
	175
	176	static const struct file_operations default_affinity_proc_fops = {
	177	.open = default_affinity_open,
	178	.read = seq_read,
	179	.llseek = seq_lseek,
	180	.release = single_release,
	181	.write = default_affinity_write,
	182	};
92d6b71a DS	183
	184	static int irq_node_proc_show(struct seq_file m, void v)
	185	{
	186	struct irq_desc *desc = irq_to_desc((long) m->private);
	187
6b8ff312	188	seq_printf(m, "%d\n", desc->irq_data.node);
92d6b71a DS	189	return 0;
	190	}
	191
	192	static int irq_node_proc_open(struct inode inode, struct file file)
	193	{
	194	return single_open(file, irq_node_proc_show, PDE(inode)->data);
	195	}
	196
	197	static const struct file_operations irq_node_proc_fops = {
	198	.open = irq_node_proc_open,
	199	.read = seq_read,
	200	.llseek = seq_lseek,
	201	.release = single_release,
	202	};
1da177e4 LT	203	#endif
1da177e4 LT	204
a1afb637	205	static int irq_spurious_proc_show(struct seq_file m, void v)
96d97cf0	206	{
a1afb637 AD	207	struct irq_desc *desc = irq_to_desc((long) m->private);
	208
	209	seq_printf(m, "count %u\n" "unhandled %u\n" "last_unhandled %u ms\n",
	210	desc->irq_count, desc->irqs_unhandled,
	211	jiffies_to_msecs(desc->last_unhandled));
	212	return 0;
	213	}
	214
	215	static int irq_spurious_proc_open(struct inode inode, struct file file)
	216	{
25c9170e	217	return single_open(file, irq_spurious_proc_show, PDE(inode)->data);
96d97cf0 AK	218	}
96d97cf0 AK	219
a1afb637 AD	220	static const struct file_operations irq_spurious_proc_fops = {
	221	.open = irq_spurious_proc_open,
	222	.read = seq_read,
	223	.llseek = seq_lseek,
	224	.release = single_release,
	225	};
	226
1da177e4 LT	227	#define MAX_NAMELEN 128
	228
	229	static int name_unique(unsigned int irq, struct irqaction *new_action)
	230	{
08678b08	231	struct irq_desc *desc = irq_to_desc(irq);
1da177e4	232	struct irqaction *action;
d2d9433a DA	233	unsigned long flags;
d2d9433a DA	234	int ret = 1;
1da177e4	235
239007b8	236	raw_spin_lock_irqsave(&desc->lock, flags);
d2d9433a	237	for (action = desc->action ; action; action = action->next) {
1da177e4	238	if ((action != new_action) && action->name &&
d2d9433a DA	239	!strcmp(new_action->name, action->name)) {
	240	ret = 0;
	241	break;
	242	}
	243	}
239007b8	244	raw_spin_unlock_irqrestore(&desc->lock, flags);
d2d9433a	245	return ret;
1da177e4 LT	246	}
	247
	248	void register_handler_proc(unsigned int irq, struct irqaction *action)
	249	{
	250	char name [MAX_NAMELEN];
08678b08	251	struct irq_desc *desc = irq_to_desc(irq);
1da177e4	252
08678b08	253	if (!desc->dir \|\| action->dir \|\| !action->name \|\|
1da177e4 LT	254	!name_unique(irq, action))
	255	return;
	256
	257	memset(name, 0, MAX_NAMELEN);
	258	snprintf(name, MAX_NAMELEN, "%s", action->name);
	259
	260	/* create /proc/irq/1234/handler/ */
08678b08	261	action->dir = proc_mkdir(name, desc->dir);
1da177e4 LT	262	}
	263
	264	#undef MAX_NAMELEN
	265
	266	#define MAX_NAMELEN 10
	267
2c6927a3	268	void register_irq_proc(unsigned int irq, struct irq_desc *desc)
1da177e4 LT	269	{
	270	char name [MAX_NAMELEN];
	271
6b8ff312	272	if (!root_irq_dir \|\| (desc->irq_data.chip == &no_irq_chip) \|\| desc->dir)
1da177e4 LT	273	return;
	274
	275	memset(name, 0, MAX_NAMELEN);
	276	sprintf(name, "%d", irq);
	277
	278	/* create /proc/irq/1234 */
08678b08	279	desc->dir = proc_mkdir(name, root_irq_dir);
c82a43d4 CG	280	if (!desc->dir)
c82a43d4 CG	281	return;
1da177e4 LT	282
1da177e4 LT	283	#ifdef CONFIG_SMP
f18e439d	284	/* create /proc/irq/<irq>/smp_affinity */
08678b08	285	proc_create_data("smp_affinity", 0600, desc->dir,
f18e439d	286	&irq_affinity_proc_fops, (void *)(long)irq);
92d6b71a	287
e7a297b0 PWJ	288	/* create /proc/irq/<irq>/affinity_hint */
	289	proc_create_data("affinity_hint", 0400, desc->dir,
	290	&irq_affinity_hint_proc_fops, (void *)(long)irq);
	291
92d6b71a DS	292	proc_create_data("node", 0444, desc->dir,
92d6b71a DS	293	&irq_node_proc_fops, (void *)(long)irq);
1da177e4	294	#endif
96d97cf0	295
a1afb637 AD	296	proc_create_data("spurious", 0444, desc->dir,
a1afb637 AD	297	&irq_spurious_proc_fops, (void *)(long)irq);
1da177e4 LT	298	}
1da177e4 LT	299
13bfe99e TG	300	void unregister_irq_proc(unsigned int irq, struct irq_desc *desc)
	301	{
	302	char name [MAX_NAMELEN];
	303
	304	if (!root_irq_dir \|\| !desc->dir)
	305	return;
	306	#ifdef CONFIG_SMP
	307	remove_proc_entry("smp_affinity", desc->dir);
	308	remove_proc_entry("affinity_hint", desc->dir);
	309	remove_proc_entry("node", desc->dir);
	310	#endif
	311	remove_proc_entry("spurious", desc->dir);
	312
	313	memset(name, 0, MAX_NAMELEN);
	314	sprintf(name, "%u", irq);
	315	remove_proc_entry(name, root_irq_dir);
	316	}
	317
1da177e4 LT	318	#undef MAX_NAMELEN
	319
	320	void unregister_handler_proc(unsigned int irq, struct irqaction *action)
	321	{
08678b08 YL	322	if (action->dir) {
08678b08 YL	323	struct irq_desc *desc = irq_to_desc(irq);
d3c60047	324
08678b08 YL	325	remove_proc_entry(action->dir->name, desc->dir);
08678b08 YL	326	}
1da177e4 LT	327	}
1da177e4 LT	328
3786fc71	329	static void register_default_affinity_proc(void)
18404756 MK	330	{
18404756 MK	331	#ifdef CONFIG_SMP
f18e439d AD	332	proc_create("irq/default_smp_affinity", 0600, NULL,
f18e439d AD	333	&default_affinity_proc_fops);
18404756 MK	334	#endif
	335	}
	336
1da177e4 LT	337	void init_irq_proc(void)
1da177e4 LT	338	{
2c6927a3 YL	339	unsigned int irq;
2c6927a3 YL	340	struct irq_desc *desc;
1da177e4 LT	341
	342	/* create /proc/irq */
	343	root_irq_dir = proc_mkdir("irq", NULL);
	344	if (!root_irq_dir)
	345	return;
	346
18404756 MK	347	register_default_affinity_proc();
18404756 MK	348
1da177e4 LT	349	/*
	350	* Create entries for all existing IRQs.
	351	*/
0b8f1efa YL	352	for_each_irq_desc(irq, desc) {
	353	if (!desc)
	354	continue;
	355
2c6927a3	356	register_irq_proc(irq, desc);
0b8f1efa	357	}
1da177e4 LT	358	}
1da177e4 LT	359
c78b9b65 TG	360	#ifdef CONFIG_GENERIC_IRQ_SHOW
	361
	362	int __weak arch_show_interrupts(struct seq_file *p, int prec)
	363	{
	364	return 0;
	365	}
	366
a6e120ed TG	367	#ifndef ACTUAL_NR_IRQS
	368	# define ACTUAL_NR_IRQS nr_irqs
	369	#endif
	370
c78b9b65 TG	371	int show_interrupts(struct seq_file p, void v)
	372	{
	373	static int prec;
	374
	375	unsigned long flags, any_count = 0;
	376	int i = (loff_t ) v, j;
	377	struct irqaction *action;
	378	struct irq_desc *desc;
	379
a6e120ed	380	if (i > ACTUAL_NR_IRQS)
c78b9b65 TG	381	return 0;
c78b9b65 TG	382
a6e120ed	383	if (i == ACTUAL_NR_IRQS)
c78b9b65 TG	384	return arch_show_interrupts(p, prec);
	385
	386	/* print header and calculate the width of the first column */
	387	if (i == 0) {
	388	for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec)
	389	j *= 10;
	390
	391	seq_printf(p, "%*s", prec + 8, "");
	392	for_each_online_cpu(j)
	393	seq_printf(p, "CPU%-8d", j);
	394	seq_putc(p, '\n');
	395	}
	396
	397	desc = irq_to_desc(i);
	398	if (!desc)
	399	return 0;
	400
	401	raw_spin_lock_irqsave(&desc->lock, flags);
	402	for_each_online_cpu(j)
	403	any_count \|= kstat_irqs_cpu(i, j);
	404	action = desc->action;
	405	if (!action && !any_count)
	406	goto out;
	407
	408	seq_printf(p, "%*d: ", prec, i);
	409	for_each_online_cpu(j)
	410	seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
ab7798ff TG	411
	412	if (desc->irq_data.chip) {
	413	if (desc->irq_data.chip->irq_print_chip)
	414	desc->irq_data.chip->irq_print_chip(&desc->irq_data, p);
	415	else if (desc->irq_data.chip->name)
	416	seq_printf(p, " %8s", desc->irq_data.chip->name);
	417	else
	418	seq_printf(p, " %8s", "-");
	419	} else {
	420	seq_printf(p, " %8s", "None");
	421	}
94b2c363	422	#ifdef CONFIG_GENERIC_IRQ_SHOW_LEVEL
ab7798ff TG	423	seq_printf(p, " %-8s", irqd_is_level_type(&desc->irq_data) ? "Level" : "Edge");
ab7798ff TG	424	#endif
ee0401ec TG	425	if (desc->name)
ee0401ec TG	426	seq_printf(p, "-%-8s", desc->name);
c78b9b65 TG	427
	428	if (action) {
	429	seq_printf(p, " %s", action->name);
	430	while ((action = action->next) != NULL)
	431	seq_printf(p, ", %s", action->name);
	432	}
	433
	434	seq_putc(p, '\n');
	435	out:
	436	raw_spin_unlock_irqrestore(&desc->lock, flags);
	437	return 0;
	438	}
	439	#endif