1/* 2 * Derived from arch/i386/kernel/irq.c 3 * Copyright (C) 1992 Linus Torvalds 4 * Adapted from arch/i386 by Gary Thomas 5 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) 6 * Updated and modified by Cort Dougan <cort@fsmlabs.com> 7 * Copyright (C) 1996-2001 Cort Dougan 8 * Adapted for Power Macintosh by Paul Mackerras 9 * Copyright (C) 1996 Paul Mackerras (paulus@cs.anu.edu.au) 10 * Amiga/APUS changes by Jesper Skov (jskov@cygnus.co.uk). 11 * 12 * This program is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU General Public License 14 * as published by the Free Software Foundation; either version 15 * 2 of the License, or (at your option) any later version. 16 * 17 * This file contains the code used by various IRQ handling routines: 18 * asking for different IRQ's should be done through these routines 19 * instead of just grabbing them. Thus setups with different IRQ numbers 20 * shouldn't result in any weird surprises, and installing new handlers 21 * should be easier. 22 * 23 * The MPC8xx has an interrupt mask in the SIU. If a bit is set, the 24 * interrupt is _enabled_. As expected, IRQ0 is bit 0 in the 32-bit 25 * mask register (of which only 16 are defined), hence the weird shifting 26 * and complement of the cached_irq_mask. I want to be able to stuff 27 * this right into the SIU SMASK register. 28 * Many of the prep/chrp functions are conditional compiled on CONFIG_8xx 29 * to reduce code space and undefined function references. 30 */ 31 32#undef DEBUG 33 34#include <linux/module.h> 35#include <linux/threads.h> 36#include <linux/kernel_stat.h> 37#include <linux/signal.h> 38#include <linux/sched.h> 39#include <linux/ptrace.h> 40#include <linux/ioport.h> 41#include <linux/interrupt.h> 42#include <linux/timex.h> 43#include <linux/init.h> 44#include <linux/slab.h> 45#include <linux/delay.h> 46#include <linux/irq.h> 47#include <linux/seq_file.h> 48#include <linux/cpumask.h> 49#include <linux/profile.h> 50#include <linux/bitops.h> 51#include <linux/list.h> 52#include <linux/radix-tree.h> 53#include <linux/mutex.h> 54#include <linux/bootmem.h> 55#include <linux/pci.h> 56 57#include <asm/uaccess.h> 58#include <asm/system.h> 59#include <asm/io.h> 60#include <asm/pgtable.h> 61#include <asm/irq.h> 62#include <asm/cache.h> 63#include <asm/prom.h> 64#include <asm/ptrace.h> 65#include <asm/machdep.h> 66#include <asm/udbg.h> 67#ifdef CONFIG_PPC64 68#include <asm/paca.h> 69#include <asm/firmware.h> 70#include <asm/lv1call.h> 71#endif 72 73int __irq_offset_value; 74static int ppc_spurious_interrupts; 75 76#ifdef CONFIG_PPC32 77EXPORT_SYMBOL(__irq_offset_value); 78atomic_t ppc_n_lost_interrupts; 79 80#ifndef CONFIG_PPC_MERGE 81#define NR_MASK_WORDS ((NR_IRQS + 31) / 32) 82unsigned long ppc_cached_irq_mask[NR_MASK_WORDS]; 83#endif 84 85#ifdef CONFIG_TAU_INT 86extern int tau_initialized; 87extern int tau_interrupts(int); 88#endif 89#endif /* CONFIG_PPC32 */ 90 91#if defined(CONFIG_SMP) && !defined(CONFIG_PPC_MERGE) 92extern atomic_t ipi_recv; 93extern atomic_t ipi_sent; 94#endif 95 96#ifdef CONFIG_PPC64 97EXPORT_SYMBOL(irq_desc); 98 99int distribute_irqs = 1; 100 101static inline unsigned long get_hard_enabled(void) 102{ 103 unsigned long enabled; 104 105 __asm__ __volatile__("lbz %0,%1(13)" 106 : "=r" (enabled) : "i" (offsetof(struct paca_struct, hard_enabled))); 107 108 return enabled; 109} 110 111static inline void set_soft_enabled(unsigned long enable) 112{ 113 __asm__ __volatile__("stb %0,%1(13)" 114 : : "r" (enable), "i" (offsetof(struct paca_struct, soft_enabled))); 115} 116 117void local_irq_restore(unsigned long en) 118{ 119 /* 120 * get_paca()->soft_enabled = en; 121 * Is it ever valid to use local_irq_restore(0) when soft_enabled is 1? 122 * That was allowed before, and in such a case we do need to take care 123 * that gcc will set soft_enabled directly via r13, not choose to use 124 * an intermediate register, lest we're preempted to a different cpu. 125 */ 126 set_soft_enabled(en); 127 if (!en) 128 return; 129 130 if (firmware_has_feature(FW_FEATURE_ISERIES)) { 131 /* 132 * Do we need to disable preemption here? Not really: in the 133 * unlikely event that we're preempted to a different cpu in 134 * between getting r13, loading its lppaca_ptr, and loading 135 * its any_int, we might call iseries_handle_interrupts without 136 * an interrupt pending on the new cpu, but that's no disaster, 137 * is it? And the business of preempting us off the old cpu 138 * would itself involve a local_irq_restore which handles the 139 * interrupt to that cpu. 140 * 141 * But use "local_paca->lppaca_ptr" instead of "get_lppaca()" 142 * to avoid any preemption checking added into get_paca(). 143 */ 144 if (local_paca->lppaca_ptr->int_dword.any_int) 145 iseries_handle_interrupts(); 146 return; 147 } 148 149 /* 150 * if (get_paca()->hard_enabled) return; 151 * But again we need to take care that gcc gets hard_enabled directly 152 * via r13, not choose to use an intermediate register, lest we're 153 * preempted to a different cpu in between the two instructions. 154 */ 155 if (get_hard_enabled()) 156 return; 157 158 /* 159 * Need to hard-enable interrupts here. Since currently disabled, 160 * no need to take further asm precautions against preemption; but 161 * use local_paca instead of get_paca() to avoid preemption checking. 162 */ 163 local_paca->hard_enabled = en; 164 if ((int)mfspr(SPRN_DEC) < 0) 165 mtspr(SPRN_DEC, 1); 166 167 /* 168 * Force the delivery of pending soft-disabled interrupts on PS3. 169 * Any HV call will have this side effect. 170 */ 171 if (firmware_has_feature(FW_FEATURE_PS3_LV1)) { 172 u64 tmp; 173 lv1_get_version_info(&tmp); 174 } 175 176 __hard_irq_enable(); 177} 178#endif /* CONFIG_PPC64 */ 179 180int show_interrupts(struct seq_file *p, void *v) 181{ 182 int i = *(loff_t *)v, j; 183 struct irqaction *action; 184 irq_desc_t *desc; 185 unsigned long flags; 186 187 if (i == 0) { 188 seq_puts(p, " "); 189 for_each_online_cpu(j) 190 seq_printf(p, "CPU%d ", j); 191 seq_putc(p, '\n'); 192 } 193 194 if (i < NR_IRQS) { 195 desc = get_irq_desc(i); 196 spin_lock_irqsave(&desc->lock, flags); 197 action = desc->action; 198 if (!action || !action->handler) 199 goto skip; 200 seq_printf(p, "%3d: ", i); 201#ifdef CONFIG_SMP 202 for_each_online_cpu(j) 203 seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]); 204#else 205 seq_printf(p, "%10u ", kstat_irqs(i)); 206#endif /* CONFIG_SMP */ 207 if (desc->chip) 208 seq_printf(p, " %s ", desc->chip->typename); 209 else 210 seq_puts(p, " None "); 211 seq_printf(p, "%s", (desc->status & IRQ_LEVEL) ? "Level " : "Edge "); 212 seq_printf(p, " %s", action->name); 213 for (action = action->next; action; action = action->next) 214 seq_printf(p, ", %s", action->name); 215 seq_putc(p, '\n'); 216skip: 217 spin_unlock_irqrestore(&desc->lock, flags); 218 } else if (i == NR_IRQS) { 219#ifdef CONFIG_PPC32 220#ifdef CONFIG_TAU_INT 221 if (tau_initialized){ 222 seq_puts(p, "TAU: "); 223 for_each_online_cpu(j) 224 seq_printf(p, "%10u ", tau_interrupts(j)); 225 seq_puts(p, " PowerPC Thermal Assist (cpu temp)\n"); 226 } 227#endif 228#if defined(CONFIG_SMP) && !defined(CONFIG_PPC_MERGE) 229 /* should this be per processor send/receive? */ 230 seq_printf(p, "IPI (recv/sent): %10u/%u\n", 231 atomic_read(&ipi_recv), atomic_read(&ipi_sent)); 232#endif 233#endif /* CONFIG_PPC32 */ 234 seq_printf(p, "BAD: %10u\n", ppc_spurious_interrupts); 235 } 236 return 0; 237} 238 239#ifdef CONFIG_HOTPLUG_CPU 240void fixup_irqs(cpumask_t map) 241{ 242 unsigned int irq; 243 static int warned; 244 245 for_each_irq(irq) { 246 cpumask_t mask; 247 248 if (irq_desc[irq].status & IRQ_PER_CPU) 249 continue; 250 251 cpus_and(mask, irq_desc[irq].affinity, map); 252 if (any_online_cpu(mask) == NR_CPUS) { 253 printk("Breaking affinity for irq %i\n", irq); 254 mask = map; 255 } 256 if (irq_desc[irq].chip->set_affinity) 257 irq_desc[irq].chip->set_affinity(irq, mask); 258 else if (irq_desc[irq].action && !(warned++)) 259 printk("Cannot set affinity for irq %i\n", irq); 260 } 261 262 local_irq_enable(); 263 mdelay(1); 264 local_irq_disable(); 265} 266#endif 267 268void do_IRQ(struct pt_regs *regs) 269{ 270 struct pt_regs *old_regs = set_irq_regs(regs); 271 unsigned int irq; 272#ifdef CONFIG_IRQSTACKS 273 struct thread_info *curtp, *irqtp; 274#endif 275 276 irq_enter(); 277 278#ifdef CONFIG_DEBUG_STACKOVERFLOW 279 /* Debugging check for stack overflow: is there less than 2KB free? */ 280 { 281 long sp; 282 283 sp = __get_SP() & (THREAD_SIZE-1); 284 285 if (unlikely(sp < (sizeof(struct thread_info) + 2048))) { 286 printk("do_IRQ: stack overflow: %ld\n", 287 sp - sizeof(struct thread_info)); 288 dump_stack(); 289 } 290 } 291#endif 292 293 /* 294 * Every platform is required to implement ppc_md.get_irq. 295 * This function will either return an irq number or NO_IRQ to 296 * indicate there are no more pending. 297 * The value NO_IRQ_IGNORE is for buggy hardware and means that this 298 * IRQ has already been handled. -- Tom 299 */ 300 irq = ppc_md.get_irq(); 301 302 if (irq != NO_IRQ && irq != NO_IRQ_IGNORE) { 303#ifdef CONFIG_IRQSTACKS 304 /* Switch to the irq stack to handle this */ 305 curtp = current_thread_info(); 306 irqtp = hardirq_ctx[smp_processor_id()]; 307 if (curtp != irqtp) { 308 struct irq_desc *desc = irq_desc + irq; 309 void *handler = desc->handle_irq; 310 if (handler == NULL) 311 handler = &__do_IRQ; 312 irqtp->task = curtp->task; 313 irqtp->flags = 0; 314 call_handle_irq(irq, desc, irqtp, handler); 315 irqtp->task = NULL; 316 if (irqtp->flags) 317 set_bits(irqtp->flags, &curtp->flags); 318 } else 319#endif 320 generic_handle_irq(irq); 321 } else if (irq != NO_IRQ_IGNORE) 322 /* That's not SMP safe ... but who cares ? */ 323 ppc_spurious_interrupts++; 324 325 irq_exit(); 326 set_irq_regs(old_regs); 327 328#ifdef CONFIG_PPC_ISERIES 329 if (firmware_has_feature(FW_FEATURE_ISERIES) && 330 get_lppaca()->int_dword.fields.decr_int) { 331 get_lppaca()->int_dword.fields.decr_int = 0; 332 /* Signal a fake decrementer interrupt */ 333 timer_interrupt(regs); 334 } 335#endif 336} 337 338void __init init_IRQ(void) 339{ 340 ppc_md.init_IRQ(); 341#ifdef CONFIG_PPC64 342 irq_ctx_init(); 343#endif 344} 345 346 347#ifdef CONFIG_IRQSTACKS 348struct thread_info *softirq_ctx[NR_CPUS] __read_mostly; 349struct thread_info *hardirq_ctx[NR_CPUS] __read_mostly; 350 351void irq_ctx_init(void) 352{ 353 struct thread_info *tp; 354 int i; 355 356 for_each_possible_cpu(i) { 357 memset((void *)softirq_ctx[i], 0, THREAD_SIZE); 358 tp = softirq_ctx[i]; 359 tp->cpu = i; 360 tp->preempt_count = SOFTIRQ_OFFSET; 361 362 memset((void *)hardirq_ctx[i], 0, THREAD_SIZE); 363 tp = hardirq_ctx[i]; 364 tp->cpu = i; 365 tp->preempt_count = HARDIRQ_OFFSET; 366 } 367} 368 369static inline void do_softirq_onstack(void) 370{ 371 struct thread_info *curtp, *irqtp; 372 373 curtp = current_thread_info(); 374 irqtp = softirq_ctx[smp_processor_id()]; 375 irqtp->task = curtp->task; 376 call_do_softirq(irqtp); 377 irqtp->task = NULL; 378} 379 380#else 381#define do_softirq_onstack() __do_softirq() 382#endif /* CONFIG_IRQSTACKS */ 383 384void do_softirq(void) 385{ 386 unsigned long flags; 387 388 if (in_interrupt()) 389 return; 390 391 local_irq_save(flags); 392 393 if (local_softirq_pending()) 394 do_softirq_onstack(); 395 396 local_irq_restore(flags); 397} 398EXPORT_SYMBOL(do_softirq); 399 400 401/* 402 * IRQ controller and virtual interrupts 403 */ 404 405#ifdef CONFIG_PPC_MERGE 406 407static LIST_HEAD(irq_hosts); 408static DEFINE_SPINLOCK(irq_big_lock); 409static DEFINE_PER_CPU(unsigned int, irq_radix_reader); 410static unsigned int irq_radix_writer; 411struct irq_map_entry irq_map[NR_IRQS]; 412static unsigned int irq_virq_count = NR_IRQS; 413static struct irq_host *irq_default_host; 414 415irq_hw_number_t virq_to_hw(unsigned int virq) 416{ 417 return irq_map[virq].hwirq; 418} 419EXPORT_SYMBOL_GPL(virq_to_hw); 420 421struct irq_host *irq_alloc_host(unsigned int revmap_type, 422 unsigned int revmap_arg, 423 struct irq_host_ops *ops, 424 irq_hw_number_t inval_irq) 425{ 426 struct irq_host *host; 427 unsigned int size = sizeof(struct irq_host); 428 unsigned int i; 429 unsigned int *rmap; 430 unsigned long flags; 431 432 /* Allocate structure and revmap table if using linear mapping */ 433 if (revmap_type == IRQ_HOST_MAP_LINEAR) 434 size += revmap_arg * sizeof(unsigned int); 435 if (mem_init_done) 436 host = kzalloc(size, GFP_KERNEL); 437 else { 438 host = alloc_bootmem(size); 439 if (host) 440 memset(host, 0, size); 441 } 442 if (host == NULL) 443 return NULL; 444 445 /* Fill structure */ 446 host->revmap_type = revmap_type; 447 host->inval_irq = inval_irq; 448 host->ops = ops; 449 450 spin_lock_irqsave(&irq_big_lock, flags); 451 452 /* If it's a legacy controller, check for duplicates and 453 * mark it as allocated (we use irq 0 host pointer for that 454 */ 455 if (revmap_type == IRQ_HOST_MAP_LEGACY) { 456 if (irq_map[0].host != NULL) { 457 spin_unlock_irqrestore(&irq_big_lock, flags); 458 /* If we are early boot, we can't free the structure, 459 * too bad... 460 * this will be fixed once slab is made available early 461 * instead of the current cruft 462 */ 463 if (mem_init_done) 464 kfree(host); 465 return NULL; 466 } 467 irq_map[0].host = host; 468 } 469 470 list_add(&host->link, &irq_hosts); 471 spin_unlock_irqrestore(&irq_big_lock, flags); 472 473 /* Additional setups per revmap type */ 474 switch(revmap_type) { 475 case IRQ_HOST_MAP_LEGACY: 476 /* 0 is always the invalid number for legacy */ 477 host->inval_irq = 0; 478 /* setup us as the host for all legacy interrupts */ 479 for (i = 1; i < NUM_ISA_INTERRUPTS; i++) { 480 irq_map[i].hwirq = 0; 481 smp_wmb(); 482 irq_map[i].host = host; 483 smp_wmb(); 484 485 /* Clear norequest flags */ 486 get_irq_desc(i)->status &= ~IRQ_NOREQUEST; 487 488 /* Legacy flags are left to default at this point, 489 * one can then use irq_create_mapping() to 490 * explicitely change them 491 */ 492 ops->map(host, i, i); 493 } 494 break; 495 case IRQ_HOST_MAP_LINEAR: 496 rmap = (unsigned int *)(host + 1); 497 for (i = 0; i < revmap_arg; i++) 498 rmap[i] = NO_IRQ; 499 host->revmap_data.linear.size = revmap_arg; 500 smp_wmb(); 501 host->revmap_data.linear.revmap = rmap; 502 break; 503 default: 504 break; 505 } 506 507 pr_debug("irq: Allocated host of type %d @0x%p\n", revmap_type, host); 508 509 return host; 510} 511 512struct irq_host *irq_find_host(struct device_node *node) 513{ 514 struct irq_host *h, *found = NULL; 515 unsigned long flags; 516 517 /* We might want to match the legacy controller last since 518 * it might potentially be set to match all interrupts in 519 * the absence of a device node. This isn't a problem so far 520 * yet though... 521 */ 522 spin_lock_irqsave(&irq_big_lock, flags); 523 list_for_each_entry(h, &irq_hosts, link) 524 if (h->ops->match == NULL || h->ops->match(h, node)) { 525 found = h; 526 break; 527 } 528 spin_unlock_irqrestore(&irq_big_lock, flags); 529 return found; 530} 531EXPORT_SYMBOL_GPL(irq_find_host); 532 533void irq_set_default_host(struct irq_host *host) 534{ 535 pr_debug("irq: Default host set to @0x%p\n", host); 536 537 irq_default_host = host; 538} 539 540void irq_set_virq_count(unsigned int count) 541{ 542 pr_debug("irq: Trying to set virq count to %d\n", count); 543 544 BUG_ON(count < NUM_ISA_INTERRUPTS); 545 if (count < NR_IRQS) 546 irq_virq_count = count; 547} 548 549/* radix tree not lockless safe ! we use a brlock-type mecanism 550 * for now, until we can use a lockless radix tree 551 */ 552static void irq_radix_wrlock(unsigned long *flags) 553{ 554 unsigned int cpu, ok; 555 556 spin_lock_irqsave(&irq_big_lock, *flags); 557 irq_radix_writer = 1; 558 smp_mb(); 559 do { 560 barrier(); 561 ok = 1; 562 for_each_possible_cpu(cpu) { 563 if (per_cpu(irq_radix_reader, cpu)) { 564 ok = 0; 565 break; 566 } 567 } 568 if (!ok) 569 cpu_relax(); 570 } while(!ok); 571} 572 573static void irq_radix_wrunlock(unsigned long flags) 574{ 575 smp_wmb(); 576 irq_radix_writer = 0; 577 spin_unlock_irqrestore(&irq_big_lock, flags); 578} 579 580static void irq_radix_rdlock(unsigned long *flags) 581{ 582 local_irq_save(*flags); 583 __get_cpu_var(irq_radix_reader) = 1; 584 smp_mb(); 585 if (likely(irq_radix_writer == 0)) 586 return; 587 __get_cpu_var(irq_radix_reader) = 0; 588 smp_wmb(); 589 spin_lock(&irq_big_lock); 590 __get_cpu_var(irq_radix_reader) = 1; 591 spin_unlock(&irq_big_lock); 592} 593 594static void irq_radix_rdunlock(unsigned long flags) 595{ 596 __get_cpu_var(irq_radix_reader) = 0; 597 local_irq_restore(flags); 598} 599 600 601unsigned int irq_create_mapping(struct irq_host *host, 602 irq_hw_number_t hwirq) 603{ 604 unsigned int virq, hint; 605 606 pr_debug("irq: irq_create_mapping(0x%p, 0x%lx)\n", host, hwirq); 607 608 /* Look for default host if nececssary */ 609 if (host == NULL) 610 host = irq_default_host; 611 if (host == NULL) { 612 printk(KERN_WARNING "irq_create_mapping called for" 613 " NULL host, hwirq=%lx\n", hwirq); 614 WARN_ON(1); 615 return NO_IRQ; 616 } 617 pr_debug("irq: -> using host @%p\n", host); 618 619 /* Check if mapping already exist, if it does, call 620 * host->ops->map() to update the flags 621 */ 622 virq = irq_find_mapping(host, hwirq); 623 if (virq != NO_IRQ) { 624 if (host->ops->remap) 625 host->ops->remap(host, virq, hwirq); 626 pr_debug("irq: -> existing mapping on virq %d\n", virq); 627 return virq; 628 } 629 630 /* Get a virtual interrupt number */ 631 if (host->revmap_type == IRQ_HOST_MAP_LEGACY) { 632 /* Handle legacy */ 633 virq = (unsigned int)hwirq; 634 if (virq == 0 || virq >= NUM_ISA_INTERRUPTS) 635 return NO_IRQ; 636 return virq; 637 } else { 638 /* Allocate a virtual interrupt number */ 639 hint = hwirq % irq_virq_count; 640 virq = irq_alloc_virt(host, 1, hint); 641 if (virq == NO_IRQ) { 642 pr_debug("irq: -> virq allocation failed\n"); 643 return NO_IRQ; 644 } 645 } 646 pr_debug("irq: -> obtained virq %d\n", virq); 647 648 /* Clear IRQ_NOREQUEST flag */ 649 get_irq_desc(virq)->status &= ~IRQ_NOREQUEST; 650 651 /* map it */ 652 smp_wmb(); 653 irq_map[virq].hwirq = hwirq; 654 smp_mb(); 655 if (host->ops->map(host, virq, hwirq)) { 656 pr_debug("irq: -> mapping failed, freeing\n"); 657 irq_free_virt(virq, 1); 658 return NO_IRQ; 659 } 660 return virq; 661} 662EXPORT_SYMBOL_GPL(irq_create_mapping); 663 664unsigned int irq_create_of_mapping(struct device_node *controller, 665 u32 *intspec, unsigned int intsize) 666{ 667 struct irq_host *host; 668 irq_hw_number_t hwirq; 669 unsigned int type = IRQ_TYPE_NONE; 670 unsigned int virq; 671 672 if (controller == NULL) 673 host = irq_default_host; 674 else 675 host = irq_find_host(controller); 676 if (host == NULL) { 677 printk(KERN_WARNING "irq: no irq host found for %s !\n", 678 controller->full_name); 679 return NO_IRQ; 680 } 681 682 /* If host has no translation, then we assume interrupt line */ 683 if (host->ops->xlate == NULL) 684 hwirq = intspec[0]; 685 else { 686 if (host->ops->xlate(host, controller, intspec, intsize, 687 &hwirq, &type)) 688 return NO_IRQ; 689 } 690 691 /* Create mapping */ 692 virq = irq_create_mapping(host, hwirq); 693 if (virq == NO_IRQ) 694 return virq; 695 696 /* Set type if specified and different than the current one */ 697 if (type != IRQ_TYPE_NONE && 698 type != (get_irq_desc(virq)->status & IRQF_TRIGGER_MASK)) 699 set_irq_type(virq, type); 700 return virq; 701} 702EXPORT_SYMBOL_GPL(irq_create_of_mapping); 703 704unsigned int irq_of_parse_and_map(struct device_node *dev, int index) 705{ 706 struct of_irq oirq; 707 708 if (of_irq_map_one(dev, index, &oirq)) 709 return NO_IRQ; 710 711 return irq_create_of_mapping(oirq.controller, oirq.specifier, 712 oirq.size); 713} 714EXPORT_SYMBOL_GPL(irq_of_parse_and_map); 715 716void irq_dispose_mapping(unsigned int virq) 717{ 718 struct irq_host *host; 719 irq_hw_number_t hwirq; 720 unsigned long flags; 721 722 if (virq == NO_IRQ) 723 return; 724 725 host = irq_map[virq].host; 726 WARN_ON (host == NULL); 727 if (host == NULL) 728 return; 729 730 /* Never unmap legacy interrupts */ 731 if (host->revmap_type == IRQ_HOST_MAP_LEGACY) 732 return; 733 734 /* remove chip and handler */ 735 set_irq_chip_and_handler(virq, NULL, NULL); 736 737 /* Make sure it's completed */ 738 synchronize_irq(virq); 739 740 /* Tell the PIC about it */ 741 if (host->ops->unmap) 742 host->ops->unmap(host, virq); 743 smp_mb(); 744 745 /* Clear reverse map */ 746 hwirq = irq_map[virq].hwirq; 747 switch(host->revmap_type) { 748 case IRQ_HOST_MAP_LINEAR: 749 if (hwirq < host->revmap_data.linear.size) 750 host->revmap_data.linear.revmap[hwirq] = NO_IRQ; 751 break; 752 case IRQ_HOST_MAP_TREE: 753 /* Check if radix tree allocated yet */ 754 if (host->revmap_data.tree.gfp_mask == 0) 755 break; 756 irq_radix_wrlock(&flags); 757 radix_tree_delete(&host->revmap_data.tree, hwirq); 758 irq_radix_wrunlock(flags); 759 break; 760 } 761 762 /* Destroy map */ 763 smp_mb(); 764 irq_map[virq].hwirq = host->inval_irq; 765 766 /* Set some flags */ 767 get_irq_desc(virq)->status |= IRQ_NOREQUEST; 768 769 /* Free it */ 770 irq_free_virt(virq, 1); 771} 772EXPORT_SYMBOL_GPL(irq_dispose_mapping); 773 774unsigned int irq_find_mapping(struct irq_host *host, 775 irq_hw_number_t hwirq) 776{ 777 unsigned int i; 778 unsigned int hint = hwirq % irq_virq_count; 779 780 /* Look for default host if nececssary */ 781 if (host == NULL) 782 host = irq_default_host; 783 if (host == NULL) 784 return NO_IRQ; 785 786 /* legacy -> bail early */ 787 if (host->revmap_type == IRQ_HOST_MAP_LEGACY) 788 return hwirq; 789 790 /* Slow path does a linear search of the map */ 791 if (hint < NUM_ISA_INTERRUPTS) 792 hint = NUM_ISA_INTERRUPTS; 793 i = hint; 794 do { 795 if (irq_map[i].host == host && 796 irq_map[i].hwirq == hwirq) 797 return i; 798 i++; 799 if (i >= irq_virq_count) 800 i = NUM_ISA_INTERRUPTS; 801 } while(i != hint); 802 return NO_IRQ; 803} 804EXPORT_SYMBOL_GPL(irq_find_mapping); 805 806 807unsigned int irq_radix_revmap(struct irq_host *host, 808 irq_hw_number_t hwirq) 809{ 810 struct radix_tree_root *tree; 811 struct irq_map_entry *ptr; 812 unsigned int virq; 813 unsigned long flags; 814 815 WARN_ON(host->revmap_type != IRQ_HOST_MAP_TREE); 816 817 /* Check if the radix tree exist yet. We test the value of 818 * the gfp_mask for that. Sneaky but saves another int in the 819 * structure. If not, we fallback to slow mode 820 */ 821 tree = &host->revmap_data.tree; 822 if (tree->gfp_mask == 0) 823 return irq_find_mapping(host, hwirq); 824 825 /* Now try to resolve */ 826 irq_radix_rdlock(&flags); 827 ptr = radix_tree_lookup(tree, hwirq); 828 irq_radix_rdunlock(flags); 829 830 /* Found it, return */ 831 if (ptr) { 832 virq = ptr - irq_map; 833 return virq; 834 } 835 836 /* If not there, try to insert it */ 837 virq = irq_find_mapping(host, hwirq); 838 if (virq != NO_IRQ) { 839 irq_radix_wrlock(&flags); 840 radix_tree_insert(tree, hwirq, &irq_map[virq]); 841 irq_radix_wrunlock(flags); 842 } 843 return virq; 844} 845 846unsigned int irq_linear_revmap(struct irq_host *host, 847 irq_hw_number_t hwirq) 848{ 849 unsigned int *revmap; 850 851 WARN_ON(host->revmap_type != IRQ_HOST_MAP_LINEAR); 852 853 /* Check revmap bounds */ 854 if (unlikely(hwirq >= host->revmap_data.linear.size)) 855 return irq_find_mapping(host, hwirq); 856 857 /* Check if revmap was allocated */ 858 revmap = host->revmap_data.linear.revmap; 859 if (unlikely(revmap == NULL)) 860 return irq_find_mapping(host, hwirq); 861 862 /* Fill up revmap with slow path if no mapping found */ 863 if (unlikely(revmap[hwirq] == NO_IRQ)) 864 revmap[hwirq] = irq_find_mapping(host, hwirq); 865 866 return revmap[hwirq]; 867} 868 869unsigned int irq_alloc_virt(struct irq_host *host, 870 unsigned int count, 871 unsigned int hint) 872{ 873 unsigned long flags; 874 unsigned int i, j, found = NO_IRQ; 875 876 if (count == 0 || count > (irq_virq_count - NUM_ISA_INTERRUPTS)) 877 return NO_IRQ; 878 879 spin_lock_irqsave(&irq_big_lock, flags); 880 881 /* Use hint for 1 interrupt if any */ 882 if (count == 1 && hint >= NUM_ISA_INTERRUPTS && 883 hint < irq_virq_count && irq_map[hint].host == NULL) { 884 found = hint; 885 goto hint_found; 886 } 887 888 /* Look for count consecutive numbers in the allocatable 889 * (non-legacy) space 890 */ 891 for (i = NUM_ISA_INTERRUPTS, j = 0; i < irq_virq_count; i++) { 892 if (irq_map[i].host != NULL) 893 j = 0; 894 else 895 j++; 896 897 if (j == count) { 898 found = i - count + 1; 899 break; 900 } 901 } 902 if (found == NO_IRQ) { 903 spin_unlock_irqrestore(&irq_big_lock, flags); 904 return NO_IRQ; 905 } 906 hint_found: 907 for (i = found; i < (found + count); i++) { 908 irq_map[i].hwirq = host->inval_irq; 909 smp_wmb(); 910 irq_map[i].host = host; 911 } 912 spin_unlock_irqrestore(&irq_big_lock, flags); 913 return found; 914} 915 916void irq_free_virt(unsigned int virq, unsigned int count) 917{ 918 unsigned long flags; 919 unsigned int i; 920 921 WARN_ON (virq < NUM_ISA_INTERRUPTS); 922 WARN_ON (count == 0 || (virq + count) > irq_virq_count); 923 924 spin_lock_irqsave(&irq_big_lock, flags); 925 for (i = virq; i < (virq + count); i++) { 926 struct irq_host *host; 927 928 if (i < NUM_ISA_INTERRUPTS || 929 (virq + count) > irq_virq_count) 930 continue; 931 932 host = irq_map[i].host; 933 irq_map[i].hwirq = host->inval_irq; 934 smp_wmb(); 935 irq_map[i].host = NULL; 936 } 937 spin_unlock_irqrestore(&irq_big_lock, flags); 938} 939 940void irq_early_init(void) 941{ 942 unsigned int i; 943 944 for (i = 0; i < NR_IRQS; i++) 945 get_irq_desc(i)->status |= IRQ_NOREQUEST; 946} 947 948/* We need to create the radix trees late */ 949static int irq_late_init(void) 950{ 951 struct irq_host *h; 952 unsigned long flags; 953 954 irq_radix_wrlock(&flags); 955 list_for_each_entry(h, &irq_hosts, link) { 956 if (h->revmap_type == IRQ_HOST_MAP_TREE) 957 INIT_RADIX_TREE(&h->revmap_data.tree, GFP_ATOMIC); 958 } 959 irq_radix_wrunlock(flags); 960 961 return 0; 962} 963arch_initcall(irq_late_init); 964 965#endif /* CONFIG_PPC_MERGE */ 966 967#ifdef CONFIG_PPC64 968static int __init setup_noirqdistrib(char *str) 969{ 970 distribute_irqs = 0; 971 return 1; 972} 973 974__setup("noirqdistrib", setup_noirqdistrib); 975#endif /* CONFIG_PPC64 */ 976