1 /* 2 * Copyright (C) 2000 Jeff Dike (jdike@karaya.com) 3 * Licensed under the GPL 4 * Derived (i.e. mostly copied) from arch/i386/kernel/irq.c: 5 * Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar 6 */ 7 8 #include "linux/kernel.h" 9 #include "linux/module.h" 10 #include "linux/smp.h" 11 #include "linux/kernel_stat.h" 12 #include "linux/interrupt.h" 13 #include "linux/random.h" 14 #include "linux/slab.h" 15 #include "linux/file.h" 16 #include "linux/proc_fs.h" 17 #include "linux/init.h" 18 #include "linux/seq_file.h" 19 #include "linux/profile.h" 20 #include "linux/hardirq.h" 21 #include "asm/irq.h" 22 #include "asm/hw_irq.h" 23 #include "asm/atomic.h" 24 #include "asm/signal.h" 25 #include "asm/system.h" 26 #include "asm/errno.h" 27 #include "asm/uaccess.h" 28 #include "user_util.h" 29 #include "kern_util.h" 30 #include "irq_user.h" 31 #include "irq_kern.h" 32 #include "os.h" 33 #include "sigio.h" 34 #include "misc_constants.h" 35 36 /* 37 * Generic, controller-independent functions: 38 */ 39 40 int show_interrupts(struct seq_file *p, void *v) 41 { 42 int i = *(loff_t *) v, j; 43 struct irqaction * action; 44 unsigned long flags; 45 46 if (i == 0) { 47 seq_printf(p, " "); 48 for_each_online_cpu(j) 49 seq_printf(p, "CPU%d ",j); 50 seq_putc(p, '\n'); 51 } 52 53 if (i < NR_IRQS) { 54 spin_lock_irqsave(&irq_desc[i].lock, flags); 55 action = irq_desc[i].action; 56 if (!action) 57 goto skip; 58 seq_printf(p, "%3d: ",i); 59 #ifndef CONFIG_SMP 60 seq_printf(p, "%10u ", kstat_irqs(i)); 61 #else 62 for_each_online_cpu(j) 63 seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]); 64 #endif 65 seq_printf(p, " %14s", irq_desc[i].chip->typename); 66 seq_printf(p, " %s", action->name); 67 68 for (action=action->next; action; action = action->next) 69 seq_printf(p, ", %s", action->name); 70 71 seq_putc(p, '\n'); 72 skip: 73 spin_unlock_irqrestore(&irq_desc[i].lock, flags); 74 } else if (i == NR_IRQS) { 75 seq_putc(p, '\n'); 76 } 77 78 return 0; 79 } 80 81 struct irq_fd *active_fds = NULL; 82 static struct irq_fd **last_irq_ptr = &active_fds; 83 84 extern void free_irqs(void); 85 86 void sigio_handler(int sig, union uml_pt_regs *regs) 87 { 88 struct irq_fd *irq_fd; 89 int n; 90 91 if (smp_sigio_handler()) 92 return; 93 94 while (1) { 95 n = os_waiting_for_events(active_fds); 96 if (n <= 0) { 97 if(n == -EINTR) continue; 98 else break; 99 } 100 101 for (irq_fd = active_fds; irq_fd != NULL; irq_fd = irq_fd->next) { 102 if (irq_fd->current_events != 0) { 103 irq_fd->current_events = 0; 104 do_IRQ(irq_fd->irq, regs); 105 } 106 } 107 } 108 109 free_irqs(); 110 } 111 112 static DEFINE_SPINLOCK(irq_lock); 113 114 int activate_fd(int irq, int fd, int type, void *dev_id) 115 { 116 struct pollfd *tmp_pfd; 117 struct irq_fd *new_fd, *irq_fd; 118 unsigned long flags; 119 int pid, events, err, n; 120 121 pid = os_getpid(); 122 err = os_set_fd_async(fd, pid); 123 if (err < 0) 124 goto out; 125 126 new_fd = um_kmalloc(sizeof(*new_fd)); 127 err = -ENOMEM; 128 if (new_fd == NULL) 129 goto out; 130 131 if (type == IRQ_READ) 132 events = UM_POLLIN | UM_POLLPRI; 133 else 134 events = UM_POLLOUT; 135 *new_fd = ((struct irq_fd) { .next = NULL, 136 .id = dev_id, 137 .fd = fd, 138 .type = type, 139 .irq = irq, 140 .pid = pid, 141 .events = events, 142 .current_events = 0 } ); 143 144 spin_lock_irqsave(&irq_lock, flags); 145 for (irq_fd = active_fds; irq_fd != NULL; irq_fd = irq_fd->next) { 146 if ((irq_fd->fd == fd) && (irq_fd->type == type)) { 147 printk("Registering fd %d twice\n", fd); 148 printk("Irqs : %d, %d\n", irq_fd->irq, irq); 149 printk("Ids : 0x%p, 0x%p\n", irq_fd->id, dev_id); 150 goto out_unlock; 151 } 152 } 153 154 if (type == IRQ_WRITE) 155 fd = -1; 156 157 tmp_pfd = NULL; 158 n = 0; 159 160 while (1) { 161 n = os_create_pollfd(fd, events, tmp_pfd, n); 162 if (n == 0) 163 break; 164 165 /* n > 0 166 * It means we couldn't put new pollfd to current pollfds 167 * and tmp_fds is NULL or too small for new pollfds array. 168 * Needed size is equal to n as minimum. 169 * 170 * Here we have to drop the lock in order to call 171 * kmalloc, which might sleep. 172 * If something else came in and changed the pollfds array 173 * so we will not be able to put new pollfd struct to pollfds 174 * then we free the buffer tmp_fds and try again. 175 */ 176 spin_unlock_irqrestore(&irq_lock, flags); 177 kfree(tmp_pfd); 178 tmp_pfd = NULL; 179 180 tmp_pfd = um_kmalloc(n); 181 if (tmp_pfd == NULL) 182 goto out_kfree; 183 184 spin_lock_irqsave(&irq_lock, flags); 185 } 186 187 *last_irq_ptr = new_fd; 188 last_irq_ptr = &new_fd->next; 189 190 spin_unlock_irqrestore(&irq_lock, flags); 191 192 /* This calls activate_fd, so it has to be outside the critical 193 * section. 194 */ 195 maybe_sigio_broken(fd, (type == IRQ_READ)); 196 197 return 0; 198 199 out_unlock: 200 spin_unlock_irqrestore(&irq_lock, flags); 201 out_kfree: 202 kfree(new_fd); 203 out: 204 return err; 205 } 206 207 static void free_irq_by_cb(int (*test)(struct irq_fd *, void *), void *arg) 208 { 209 unsigned long flags; 210 211 spin_lock_irqsave(&irq_lock, flags); 212 os_free_irq_by_cb(test, arg, active_fds, &last_irq_ptr); 213 spin_unlock_irqrestore(&irq_lock, flags); 214 } 215 216 struct irq_and_dev { 217 int irq; 218 void *dev; 219 }; 220 221 static int same_irq_and_dev(struct irq_fd *irq, void *d) 222 { 223 struct irq_and_dev *data = d; 224 225 return ((irq->irq == data->irq) && (irq->id == data->dev)); 226 } 227 228 void free_irq_by_irq_and_dev(unsigned int irq, void *dev) 229 { 230 struct irq_and_dev data = ((struct irq_and_dev) { .irq = irq, 231 .dev = dev }); 232 233 free_irq_by_cb(same_irq_and_dev, &data); 234 } 235 236 static int same_fd(struct irq_fd *irq, void *fd) 237 { 238 return (irq->fd == *((int *)fd)); 239 } 240 241 void free_irq_by_fd(int fd) 242 { 243 free_irq_by_cb(same_fd, &fd); 244 } 245 246 static struct irq_fd *find_irq_by_fd(int fd, int irqnum, int *index_out) 247 { 248 struct irq_fd *irq; 249 int i = 0; 250 int fdi; 251 252 for (irq = active_fds; irq != NULL; irq = irq->next) { 253 if ((irq->fd == fd) && (irq->irq == irqnum)) 254 break; 255 i++; 256 } 257 if (irq == NULL) { 258 printk("find_irq_by_fd doesn't have descriptor %d\n", fd); 259 goto out; 260 } 261 fdi = os_get_pollfd(i); 262 if ((fdi != -1) && (fdi != fd)) { 263 printk("find_irq_by_fd - mismatch between active_fds and " 264 "pollfds, fd %d vs %d, need %d\n", irq->fd, 265 fdi, fd); 266 irq = NULL; 267 goto out; 268 } 269 *index_out = i; 270 out: 271 return irq; 272 } 273 274 void reactivate_fd(int fd, int irqnum) 275 { 276 struct irq_fd *irq; 277 unsigned long flags; 278 int i; 279 280 spin_lock_irqsave(&irq_lock, flags); 281 irq = find_irq_by_fd(fd, irqnum, &i); 282 if (irq == NULL) { 283 spin_unlock_irqrestore(&irq_lock, flags); 284 return; 285 } 286 os_set_pollfd(i, irq->fd); 287 spin_unlock_irqrestore(&irq_lock, flags); 288 289 add_sigio_fd(fd); 290 } 291 292 void deactivate_fd(int fd, int irqnum) 293 { 294 struct irq_fd *irq; 295 unsigned long flags; 296 int i; 297 298 spin_lock_irqsave(&irq_lock, flags); 299 irq = find_irq_by_fd(fd, irqnum, &i); 300 if(irq == NULL){ 301 spin_unlock_irqrestore(&irq_lock, flags); 302 return; 303 } 304 305 os_set_pollfd(i, -1); 306 spin_unlock_irqrestore(&irq_lock, flags); 307 308 ignore_sigio_fd(fd); 309 } 310 311 int deactivate_all_fds(void) 312 { 313 struct irq_fd *irq; 314 int err; 315 316 for (irq = active_fds; irq != NULL; irq = irq->next) { 317 err = os_clear_fd_async(irq->fd); 318 if (err) 319 return err; 320 } 321 /* If there is a signal already queued, after unblocking ignore it */ 322 os_set_ioignore(); 323 324 return 0; 325 } 326 327 #ifdef CONFIG_MODE_TT 328 void forward_interrupts(int pid) 329 { 330 struct irq_fd *irq; 331 unsigned long flags; 332 int err; 333 334 spin_lock_irqsave(&irq_lock, flags); 335 for (irq = active_fds; irq != NULL; irq = irq->next) { 336 err = os_set_owner(irq->fd, pid); 337 if (err < 0) { 338 /* XXX Just remove the irq rather than 339 * print out an infinite stream of these 340 */ 341 printk("Failed to forward %d to pid %d, err = %d\n", 342 irq->fd, pid, -err); 343 } 344 345 irq->pid = pid; 346 } 347 spin_unlock_irqrestore(&irq_lock, flags); 348 } 349 #endif 350 351 /* 352 * do_IRQ handles all normal device IRQ's (the special 353 * SMP cross-CPU interrupts have their own specific 354 * handlers). 355 */ 356 unsigned int do_IRQ(int irq, union uml_pt_regs *regs) 357 { 358 irq_enter(); 359 __do_IRQ(irq, (struct pt_regs *)regs); 360 irq_exit(); 361 return 1; 362 } 363 364 int um_request_irq(unsigned int irq, int fd, int type, 365 irqreturn_t (*handler)(int, void *, struct pt_regs *), 366 unsigned long irqflags, const char * devname, 367 void *dev_id) 368 { 369 int err; 370 371 err = request_irq(irq, handler, irqflags, devname, dev_id); 372 if (err) 373 return err; 374 375 if (fd != -1) 376 err = activate_fd(irq, fd, type, dev_id); 377 return err; 378 } 379 EXPORT_SYMBOL(um_request_irq); 380 EXPORT_SYMBOL(reactivate_fd); 381 382 /* hw_interrupt_type must define (startup || enable) && 383 * (shutdown || disable) && end */ 384 static void dummy(unsigned int irq) 385 { 386 } 387 388 /* This is used for everything else than the timer. */ 389 static struct hw_interrupt_type normal_irq_type = { 390 .typename = "SIGIO", 391 .release = free_irq_by_irq_and_dev, 392 .disable = dummy, 393 .enable = dummy, 394 .ack = dummy, 395 .end = dummy 396 }; 397 398 static struct hw_interrupt_type SIGVTALRM_irq_type = { 399 .typename = "SIGVTALRM", 400 .release = free_irq_by_irq_and_dev, 401 .shutdown = dummy, /* never called */ 402 .disable = dummy, 403 .enable = dummy, 404 .ack = dummy, 405 .end = dummy 406 }; 407 408 void __init init_IRQ(void) 409 { 410 int i; 411 412 irq_desc[TIMER_IRQ].status = IRQ_DISABLED; 413 irq_desc[TIMER_IRQ].action = NULL; 414 irq_desc[TIMER_IRQ].depth = 1; 415 irq_desc[TIMER_IRQ].chip = &SIGVTALRM_irq_type; 416 enable_irq(TIMER_IRQ); 417 for (i = 1; i < NR_IRQS; i++) { 418 irq_desc[i].status = IRQ_DISABLED; 419 irq_desc[i].action = NULL; 420 irq_desc[i].depth = 1; 421 irq_desc[i].chip = &normal_irq_type; 422 enable_irq(i); 423 } 424 } 425 426 int init_aio_irq(int irq, char *name, irqreturn_t (*handler)(int, void *, 427 struct pt_regs *)) 428 { 429 int fds[2], err; 430 431 err = os_pipe(fds, 1, 1); 432 if (err) { 433 printk("init_aio_irq - os_pipe failed, err = %d\n", -err); 434 goto out; 435 } 436 437 err = um_request_irq(irq, fds[0], IRQ_READ, handler, 438 IRQF_DISABLED | IRQF_SAMPLE_RANDOM, name, 439 (void *) (long) fds[0]); 440 if (err) { 441 printk("init_aio_irq - : um_request_irq failed, err = %d\n", 442 err); 443 goto out_close; 444 } 445 446 err = fds[1]; 447 goto out; 448 449 out_close: 450 os_close_file(fds[0]); 451 os_close_file(fds[1]); 452 out: 453 return err; 454 } 455