irq: make variable static
[linux-2.6.git] / kernel / irq / proc.c
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>
10 #include <linux/proc_fs.h>
11 #include <linux/seq_file.h>
12 #include <linux/interrupt.h>
13
14 #include "internals.h"
15
16 static struct proc_dir_entry *root_irq_dir;
17
18 #ifdef CONFIG_SMP
19
20 static int irq_affinity_proc_show(struct seq_file *m, void *v)
21 {
22         struct irq_desc *desc = irq_to_desc((long)m->private);
23         cpumask_t *mask = &desc->affinity;
24
25 #ifdef CONFIG_GENERIC_PENDING_IRQ
26         if (desc->status & IRQ_MOVE_PENDING)
27                 mask = &desc->pending_mask;
28 #endif
29         seq_cpumask(m, mask);
30         seq_putc(m, '\n');
31         return 0;
32 }
33
34 #ifndef is_affinity_mask_valid
35 #define is_affinity_mask_valid(val) 1
36 #endif
37
38 int no_irq_affinity;
39 static ssize_t irq_affinity_proc_write(struct file *file,
40                 const char __user *buffer, size_t count, loff_t *pos)
41 {
42         unsigned int irq = (int)(long)PDE(file->f_path.dentry->d_inode)->data;
43         cpumask_t new_value;
44         int err;
45
46         if (!irq_to_desc(irq)->chip->set_affinity || no_irq_affinity ||
47             irq_balancing_disabled(irq))
48                 return -EIO;
49
50         err = cpumask_parse_user(buffer, count, new_value);
51         if (err)
52                 return err;
53
54         if (!is_affinity_mask_valid(new_value))
55                 return -EINVAL;
56
57         /*
58          * Do not allow disabling IRQs completely - it's a too easy
59          * way to make the system unusable accidentally :-) At least
60          * one online CPU still has to be targeted.
61          */
62         if (!cpus_intersects(new_value, cpu_online_map))
63                 /* Special case for empty set - allow the architecture
64                    code to set default SMP affinity. */
65                 return irq_select_affinity(irq) ? -EINVAL : count;
66
67         irq_set_affinity(irq, new_value);
68
69         return count;
70 }
71
72 static int irq_affinity_proc_open(struct inode *inode, struct file *file)
73 {
74         return single_open(file, irq_affinity_proc_show, PDE(inode)->data);
75 }
76
77 static const struct file_operations irq_affinity_proc_fops = {
78         .open           = irq_affinity_proc_open,
79         .read           = seq_read,
80         .llseek         = seq_lseek,
81         .release        = single_release,
82         .write          = irq_affinity_proc_write,
83 };
84
85 static int default_affinity_show(struct seq_file *m, void *v)
86 {
87         seq_cpumask(m, &irq_default_affinity);
88         seq_putc(m, '\n');
89         return 0;
90 }
91
92 static ssize_t default_affinity_write(struct file *file,
93                 const char __user *buffer, size_t count, loff_t *ppos)
94 {
95         cpumask_t new_value;
96         int err;
97
98         err = cpumask_parse_user(buffer, count, new_value);
99         if (err)
100                 return err;
101
102         if (!is_affinity_mask_valid(new_value))
103                 return -EINVAL;
104
105         /*
106          * Do not allow disabling IRQs completely - it's a too easy
107          * way to make the system unusable accidentally :-) At least
108          * one online CPU still has to be targeted.
109          */
110         if (!cpus_intersects(new_value, cpu_online_map))
111                 return -EINVAL;
112
113         irq_default_affinity = new_value;
114
115         return count;
116 }
117
118 static int default_affinity_open(struct inode *inode, struct file *file)
119 {
120         return single_open(file, default_affinity_show, NULL);
121 }
122
123 static const struct file_operations default_affinity_proc_fops = {
124         .open           = default_affinity_open,
125         .read           = seq_read,
126         .llseek         = seq_lseek,
127         .release        = single_release,
128         .write          = default_affinity_write,
129 };
130 #endif
131
132 static int irq_spurious_read(char *page, char **start, off_t off,
133                                   int count, int *eof, void *data)
134 {
135         struct irq_desc *desc = irq_to_desc((long) data);
136         return sprintf(page, "count %u\n"
137                              "unhandled %u\n"
138                              "last_unhandled %u ms\n",
139                         desc->irq_count,
140                         desc->irqs_unhandled,
141                         jiffies_to_msecs(desc->last_unhandled));
142 }
143
144 #define MAX_NAMELEN 128
145
146 static int name_unique(unsigned int irq, struct irqaction *new_action)
147 {
148         struct irq_desc *desc = irq_to_desc(irq);
149         struct irqaction *action;
150         unsigned long flags;
151         int ret = 1;
152
153         spin_lock_irqsave(&desc->lock, flags);
154         for (action = desc->action ; action; action = action->next) {
155                 if ((action != new_action) && action->name &&
156                                 !strcmp(new_action->name, action->name)) {
157                         ret = 0;
158                         break;
159                 }
160         }
161         spin_unlock_irqrestore(&desc->lock, flags);
162         return ret;
163 }
164
165 void register_handler_proc(unsigned int irq, struct irqaction *action)
166 {
167         char name [MAX_NAMELEN];
168         struct irq_desc *desc = irq_to_desc(irq);
169
170         if (!desc->dir || action->dir || !action->name ||
171                                         !name_unique(irq, action))
172                 return;
173
174         memset(name, 0, MAX_NAMELEN);
175         snprintf(name, MAX_NAMELEN, "%s", action->name);
176
177         /* create /proc/irq/1234/handler/ */
178         action->dir = proc_mkdir(name, desc->dir);
179 }
180
181 #undef MAX_NAMELEN
182
183 #define MAX_NAMELEN 10
184
185 void register_irq_proc(unsigned int irq, struct irq_desc *desc)
186 {
187         char name [MAX_NAMELEN];
188         struct proc_dir_entry *entry;
189
190         if (!root_irq_dir || (desc->chip == &no_irq_chip) || desc->dir)
191                 return;
192
193         memset(name, 0, MAX_NAMELEN);
194         sprintf(name, "%d", irq);
195
196         /* create /proc/irq/1234 */
197         desc->dir = proc_mkdir(name, root_irq_dir);
198
199 #ifdef CONFIG_SMP
200         /* create /proc/irq/<irq>/smp_affinity */
201         proc_create_data("smp_affinity", 0600, desc->dir,
202                          &irq_affinity_proc_fops, (void *)(long)irq);
203 #endif
204
205         entry = create_proc_entry("spurious", 0444, desc->dir);
206         if (entry) {
207                 entry->data = (void *)(long)irq;
208                 entry->read_proc = irq_spurious_read;
209         }
210 }
211
212 #undef MAX_NAMELEN
213
214 void unregister_handler_proc(unsigned int irq, struct irqaction *action)
215 {
216         if (action->dir) {
217                 struct irq_desc *desc = irq_to_desc(irq);
218
219                 remove_proc_entry(action->dir->name, desc->dir);
220         }
221 }
222
223 static void register_default_affinity_proc(void)
224 {
225 #ifdef CONFIG_SMP
226         proc_create("irq/default_smp_affinity", 0600, NULL,
227                     &default_affinity_proc_fops);
228 #endif
229 }
230
231 void init_irq_proc(void)
232 {
233         unsigned int irq;
234         struct irq_desc *desc;
235
236         /* create /proc/irq */
237         root_irq_dir = proc_mkdir("irq", NULL);
238         if (!root_irq_dir)
239                 return;
240
241         register_default_affinity_proc();
242
243         /*
244          * Create entries for all existing IRQs.
245          */
246         for_each_irq_desc(irq, desc)
247                 register_irq_proc(irq, desc);
248 }
249