开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
irq.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：24k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

irq.c：源码内容
  1. /*
  2.  *  arch/ppc/kernel/irq.c
  3.  *
  4.  *  Derived from arch/i386/kernel/irq.c
  5.  *    Copyright (C) 1992 Linus Torvalds
  6.  *  Adapted from arch/i386 by Gary Thomas
  7.  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
  8.  *  Updated and modified by Cort Dougan (cort@cs.nmt.edu)
  9.  *    Copyright (C) 1996 Cort Dougan
  10.  *  Adapted for Power Macintosh by Paul Mackerras
  11.  *    Copyright (C) 1996 Paul Mackerras (paulus@cs.anu.edu.au)
  12.  *  Amiga/APUS changes by Jesper Skov (jskov@cygnus.co.uk).
  13.  * 
  14.  * This program is free software; you can redistribute it and/or
  15.  * modify it under the terms of the GNU General Public License
  16.  * as published by the Free Software Foundation; either version
  17.  * 2 of the License, or (at your option) any later version.
  18.  *
  19.  * This file contains the code used by various IRQ handling routines:
  20.  * asking for different IRQ's should be done through these routines
  21.  * instead of just grabbing them. Thus setups with different IRQ numbers
  22.  * shouldn't result in any weird surprises, and installing new handlers
  23.  * should be easier.
  24.  */
  26. #include <linux/ptrace.h>
  27. #include <linux/errno.h>
  28. #include <linux/threads.h>
  29. #include <linux/kernel_stat.h>
  30. #include <linux/signal.h>
  31. #include <linux/sched.h>
  32. #include <linux/ioport.h>
  33. #include <linux/interrupt.h>
  34. #include <linux/timex.h>
  35. #include <linux/config.h>
  36. #include <linux/init.h>
  37. #include <linux/slab.h>
  38. #include <linux/pci.h>
  39. #include <linux/delay.h>
  40. #include <linux/irq.h>
  41. #include <linux/proc_fs.h>
  42. #include <linux/seq_file.h>
  43. #include <linux/random.h>
  45. #include <asm/uaccess.h>
  46. #include <asm/bitops.h>
  47. #include <asm/system.h>
  48. #include <asm/io.h>
  49. #include <asm/pgtable.h>
  50. #include <asm/irq.h>
  51. #include <asm/cache.h>
  52. #include <asm/prom.h>
  53. #include <asm/ptrace.h>
  54. #include <asm/iSeries/LparData.h>
  55. #include <asm/machdep.h>
  56. #include <asm/paca.h>
  57. #include <asm/perfmon.h>
  59. #include "local_irq.h"
  61. atomic_t ipi_recv;
  62. atomic_t ipi_sent;
  63. void enable_irq(unsigned int irq_nr);
  64. void disable_irq(unsigned int irq_nr);
  66. #ifdef CONFIG_SMP
  67. extern void iSeries_smp_message_recv( struct pt_regs * );
  68. #endif
  70. volatile unsigned char *chrp_int_ack_special;
  71. static void register_irq_proc (unsigned int irq);
  73. irq_desc_t irq_desc[NR_IRQS] __cacheline_aligned =
  74. { [0 ... NR_IRQS-1] = { 0, NULL, NULL, 0, SPIN_LOCK_UNLOCKED}};
  76. int ppc_spurious_interrupts = 0;
  77. struct irqaction *ppc_irq_action[NR_IRQS];
  78. unsigned long lpEvent_count = 0;
  79. #ifdef CONFIG_XMON
  80. extern void xmon(struct pt_regs *regs);
  81. extern int xmon_bpt(struct pt_regs *regs);
  82. extern int xmon_sstep(struct pt_regs *regs);
  83. extern int xmon_iabr_match(struct pt_regs *regs);
  84. extern int xmon_dabr_match(struct pt_regs *regs);
  85. extern void (*xmon_fault_handler)(struct pt_regs *regs);
  86. #endif
  87. #ifdef CONFIG_XMON
  88. extern void (*debugger)(struct pt_regs *regs);
  89. extern int (*debugger_bpt)(struct pt_regs *regs);
  90. extern int (*debugger_sstep)(struct pt_regs *regs);
  91. extern int (*debugger_iabr_match)(struct pt_regs *regs);
  92. extern int (*debugger_dabr_match)(struct pt_regs *regs);
  93. extern void (*debugger_fault_handler)(struct pt_regs *regs);
  94. #endif
  96. /* nasty hack for shared irq's since we need to do kmalloc calls but
  97.  * can't very early in the boot when we need to do a request irq.
  98.  * this needs to be removed.
  99.  * -- Cort
  100.  */
  101. #define IRQ_KMALLOC_ENTRIES 16
  102. static int cache_bitmask = 0;
  103. static struct irqaction malloc_cache[IRQ_KMALLOC_ENTRIES];
  104. extern int mem_init_done;
  106. void *irq_kmalloc(size_t size, int pri)
  107. {
  108. unsigned int i;
  109. if ( mem_init_done )
  110. return kmalloc(size,pri);
  111. for ( i = 0; i < IRQ_KMALLOC_ENTRIES ; i++ )
  112. if ( ! ( cache_bitmask & (1<<i) ) ) {
  113. cache_bitmask |= (1<<i);
  114. return (void *)(&malloc_cache[i]);
  115. }
  116. return 0;
  117. }
  119. void irq_kfree(void *ptr)
  120. {
  121. unsigned int i;
  122. for ( i = 0 ; i < IRQ_KMALLOC_ENTRIES ; i++ )
  123. if ( ptr == &malloc_cache[i] ) {
  124. cache_bitmask &= ~(1<<i);
  125. return;
  126. }
  127. kfree(ptr);
  128. }
  130. int
  131. setup_irq(unsigned int irq, struct irqaction * new)
  132. {
  133. int shared = 0;
  134. unsigned long flags;
  135. struct irqaction *old, **p;
  136. irq_desc_t *desc = irq_desc + irq;
  138. /*
  139.  * Some drivers like serial.c use request_irq() heavily,
  140.  * so we have to be careful not to interfere with a
  141.  * running system.
  142.  */
  143. if (new->flags & SA_SAMPLE_RANDOM) {
  144. /*
  145.  * This function might sleep, we want to call it first,
  146.  * outside of the atomic block.
  147.  * Yes, this might clear the entropy pool if the wrong
  148.  * driver is attempted to be loaded, without actually
  149.  * installing a new handler, but is this really a problem,
  150.  * only the sysadmin is able to do this.
  151.  */
  152. rand_initialize_irq(irq);
  153. }
  155. /*
  156.  * The following block of code has to be executed atomically
  157.  */
  158. spin_lock_irqsave(&desc->lock,flags);
  159. p = &desc->action;
  160. if ((old = *p) != NULL) {
  161. /* Can't share interrupts unless both agree to */
  162. if (!(old->flags & new->flags & SA_SHIRQ)) {
  163. spin_unlock_irqrestore(&desc->lock,flags);
  164. return -EBUSY;
  165. }
  167. /* add new interrupt at end of irq queue */
  168. do {
  169. p = &old->next;
  170. old = *p;
  171. } while (old);
  172. shared = 1;
  173. }
  175. *p = new;
  177. if (!shared) {
  178. desc->depth = 0;
  179. desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT | IRQ_WAITING);
  180. unmask_irq(irq);
  181. }
  182. spin_unlock_irqrestore(&desc->lock,flags);
  184. register_irq_proc(irq);
  185. return 0;
  186. }
  188. /* This could be promoted to a real free_irq() ... */
  189. static int
  190. do_free_irq(int irq, void* dev_id)
  191. {
  192. irq_desc_t *desc;
  193. struct irqaction **p;
  194. unsigned long flags;
  196. desc = irq_desc + irq;
  197. spin_lock_irqsave(&desc->lock,flags);
  198. p = &desc->action;
  199. for (;;) {
  200. struct irqaction * action = *p;
  201. if (action) {
  202. struct irqaction **pp = p;
  203. p = &action->next;
  204. if (action->dev_id != dev_id)
  205. continue;
  207. /* Found it - now remove it from the list of entries */
  208. *pp = action->next;
  209. if (!desc->action) {
  210. desc->status |= IRQ_DISABLED;
  211. mask_irq(irq);
  212. }
  213. spin_unlock_irqrestore(&desc->lock,flags);
  215. #ifdef CONFIG_SMP
  216. /* Wait to make sure it's not being used on another CPU */
  217. while (desc->status & IRQ_INPROGRESS)
  218. barrier();
  219. #endif
  220. irq_kfree(action);
  221. return 0;
  222. }
  223. printk("Trying to free free IRQ%dn",irq);
  224. spin_unlock_irqrestore(&desc->lock,flags);
  225. break;
  226. }
  227. return -ENOENT;
  228. }
  230. int request_irq(unsigned int irq, void (*handler)(int, void *, struct pt_regs *),
  231. unsigned long irqflags, const char * devname, void *dev_id)
  232. {
  233. struct irqaction *action;
  234. int retval;
  236. if (irq >= NR_IRQS)
  237. return -EINVAL;
  238. if (!handler)
  239. /* We could implement really free_irq() instead of that... */
  240. return do_free_irq(irq, dev_id);
  242. action = (struct irqaction *)
  243. irq_kmalloc(sizeof(struct irqaction), GFP_KERNEL);
  244. if (!action) {
  245. printk(KERN_ERR "irq_kmalloc() failed for irq %d !n", irq);
  246. return -ENOMEM;
  247. }
  249. action->handler = handler;
  250. action->flags = irqflags;
  251. action->mask = 0;
  252. action->name = devname;
  253. action->dev_id = dev_id;
  254. action->next = NULL;
  256. retval = setup_irq(irq, action);
  257. if (retval)
  258. kfree(action);
  260. return 0;
  261. }
  263. void free_irq(unsigned int irq, void *dev_id)
  264. {
  265. request_irq(irq, NULL, 0, NULL, dev_id);
  266. }
  268. /*
  269.  * Generic enable/disable code: this just calls
  270.  * down into the PIC-specific version for the actual
  271.  * hardware disable after having gotten the irq
  272.  * controller lock. 
  273.  */
  274.  
  275. /**
  276.  * disable_irq_nosync - disable an irq without waiting
  277.  * @irq: Interrupt to disable
  278.  *
  279.  * Disable the selected interrupt line. Disables of an interrupt
  280.  * stack. Unlike disable_irq(), this function does not ensure existing
  281.  * instances of the IRQ handler have completed before returning.
  282.  *
  283.  * This function may be called from IRQ context.
  284.  */
  285.  
  286.  void disable_irq_nosync(unsigned int irq)
  287. {
  288. irq_desc_t *desc = irq_desc + irq;
  289. unsigned long flags;
  291. spin_lock_irqsave(&desc->lock, flags);
  292. if (!desc->depth++) {
  293. if (!(desc->status & IRQ_PER_CPU))
  294. desc->status |= IRQ_DISABLED;
  295. mask_irq(irq);
  296. }
  297. spin_unlock_irqrestore(&desc->lock, flags);
  298. }
  300. /**
  301.  * disable_irq - disable an irq and wait for completion
  302.  * @irq: Interrupt to disable
  303.  *
  304.  * Disable the selected interrupt line. Disables of an interrupt
  305.  * stack. That is for two disables you need two enables. This
  306.  * function waits for any pending IRQ handlers for this interrupt
  307.  * to complete before returning. If you use this function while
  308.  * holding a resource the IRQ handler may need you will deadlock.
  309.  *
  310.  * This function may be called - with care - from IRQ context.
  311.  */
  312.  
  313. void disable_irq(unsigned int irq)
  314. {
  315. disable_irq_nosync(irq);
  317. if (!local_irq_count(smp_processor_id())) {
  318. do {
  319. barrier();
  320. } while (irq_desc[irq].status & IRQ_INPROGRESS);
  321. }
  322. }
  324. /**
  325.  * enable_irq - enable interrupt handling on an irq
  326.  * @irq: Interrupt to enable
  327.  *
  328.  * Re-enables the processing of interrupts on this IRQ line
  329.  * providing no disable_irq calls are now in effect.
  330.  *
  331.  * This function may be called from IRQ context.
  332.  */
  333.  
  334. void enable_irq(unsigned int irq)
  335. {
  336. irq_desc_t *desc = irq_desc + irq;
  337. unsigned long flags;
  339. spin_lock_irqsave(&desc->lock, flags);
  340. switch (desc->depth) {
  341. case 1: {
  342. unsigned int status = desc->status & ~IRQ_DISABLED;
  343. desc->status = status;
  344. if ((status & (IRQ_PENDING | IRQ_REPLAY)) == IRQ_PENDING) {
  345. desc->status = status | IRQ_REPLAY;
  346. hw_resend_irq(desc->handler,irq);
  347. }
  348. unmask_irq(irq);
  349. /* fall-through */
  350. }
  351. default:
  352. desc->depth--;
  353. break;
  354. case 0:
  355. printk("enable_irq(%u) unbalancedn", irq);
  356. }
  357. spin_unlock_irqrestore(&desc->lock, flags);
  358. }
  360. /* one would think this function has one foot in the grave */
  361. int get_irq_list(char *buf)
  362. {
  363.    int i, len = 0, j;
  364.    struct irqaction * action;
  366.    len += sprintf(buf+len, "           ");
  367.    for (j=0; j<smp_num_cpus; j++)
  368.        len += sprintf(buf+len, "CPU%d       ",j);
  369.    *(char *)(buf+len++) = 'n';
  371.    for (i = 0 ; i < NR_IRQS ; i++) {
  372.        action = irq_desc[i].action;
  373.        if ( !action || !action->handler )
  374.            continue;
  375.        len += sprintf(buf+len, "%3d: ", i);
  376. #ifdef CONFIG_SMP
  377.        for (j = 0; j < smp_num_cpus; j++)
  378.            len += sprintf(buf+len, "%10u ",
  379.                kstat.irqs[cpu_logical_map(j)][i]);
  380. #else
  381.        len += sprintf(buf+len, "%10u ", kstat_irqs(i));
  382. #endif /* CONFIG_SMP */
  383. if ( irq_desc[i].handler )
  384. len += sprintf(buf+len, " %s ", irq_desc[i].handler->typename );
  385. else
  386. len += sprintf(buf+len, "  None      ");
  387. len += sprintf(buf+len, "%s", (irq_desc[i].status & IRQ_LEVEL) ? "Level " : "Edge  ");
  388. len += sprintf(buf+len, "    %s",action->name);
  389. for (action=action->next; action; action = action->next) {
  390. len += sprintf(buf+len, ", %s", action->name);
  391. }
  392. len += sprintf(buf+len, "n");
  393. }
  394. #ifdef CONFIG_SMP
  395. /* should this be per processor send/receive? */
  396. len += sprintf(buf+len, "IPI (recv/sent): %10u/%un",
  397. atomic_read(&ipi_recv), atomic_read(&ipi_sent));
  398. #endif
  399. len += sprintf(buf+len, "BAD: %10un", ppc_spurious_interrupts);
  400. return len;
  401. }
  405. int show_interrupts(struct seq_file *p, void *v)
  406. {
  407. int i, j;
  408. struct irqaction * action;
  410. seq_printf(p, "           ");
  411. for (j=0; j<smp_num_cpus; j++)
  412. seq_printf(p, "CPU%d       ",j);
  413. seq_putc(p, 'n');
  415. for (i = 0 ; i < NR_IRQS ; i++) {
  416. action = irq_desc[i].action;
  417. if (!action || !action->handler)
  418. continue;
  419. seq_printf(p, "%3d: ", i);
  420. #ifdef CONFIG_SMP
  421. for (j = 0; j < smp_num_cpus; j++)
  422. seq_printf(p, "%10u ",
  423. kstat.irqs[cpu_logical_map(j)][i]);
  424. #else
  425. seq_printf(p, "%10u ", kstat_irqs(i));
  426. #endif /* CONFIG_SMP */
  427. if (irq_desc[i].handler)
  428. seq_printf(p, " %s ", irq_desc[i].handler->typename );
  429. else
  430. seq_printf(p, "  None      ");
  431. seq_printf(p, "%s", (irq_desc[i].status & IRQ_LEVEL) ? "Level " : "Edge  ");
  432. seq_printf(p, "    %s",action->name);
  433. for (action=action->next; action; action = action->next)
  434. seq_printf(p, ", %s", action->name);
  435. seq_putc(p, 'n');
  436. }
  437. #ifdef CONFIG_SMP
  438. /* should this be per processor send/receive? */
  439. seq_printf(p, "IPI (recv/sent): %10u/%un",
  440.        atomic_read(&ipi_recv), atomic_read(&ipi_sent));
  441. #endif
  442. seq_printf(p, "BAD: %10un", ppc_spurious_interrupts);
  443. return 0;
  444. }
  446. static inline void
  447. handle_irq_event(int irq, struct pt_regs *regs, struct irqaction *action)
  448. {
  449. int status = 0;
  451. if (!(action->flags & SA_INTERRUPT))
  452. __sti();
  454. do {
  455. status |= action->flags;
  456. action->handler(irq, action->dev_id, regs);
  457. action = action->next;
  458. } while (action);
  459. if (status & SA_SAMPLE_RANDOM)
  460. add_interrupt_randomness(irq);
  461. __cli();
  462. }
  464. /*
  465.  * Eventually, this should take an array of interrupts and an array size
  466.  * so it can dispatch multiple interrupts.
  467.  */
  468. void ppc_irq_dispatch_handler(struct pt_regs *regs, int irq)
  469. {
  470. int status;
  471. struct irqaction *action;
  472. int cpu = smp_processor_id();
  473. irq_desc_t *desc = irq_desc + irq;
  475. kstat.irqs[cpu][irq]++;
  476. spin_lock(&desc->lock);
  477. ack_irq(irq);
  478. /*
  479.    REPLAY is when Linux resends an IRQ that was dropped earlier
  480.    WAITING is used by probe to mark irqs that are being tested
  481.    */
  482. status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING);
  483. if (!(status & IRQ_PER_CPU))
  484. status |= IRQ_PENDING; /* we _want_ to handle it */
  486. /*
  487.  * If the IRQ is disabled for whatever reason, we cannot
  488.  * use the action we have.
  489.  */
  490. action = NULL;
  491. if (!(status & (IRQ_DISABLED | IRQ_INPROGRESS))) {
  492. action = desc->action;
  493. if (!action || !action->handler) {
  494. ppc_spurious_interrupts++;
  495. printk(KERN_DEBUG "Unhandled interrupt %x, disabledn", irq);
  496. /* We can't call disable_irq here, it would deadlock */
  497. if (!desc->depth)
  498. desc->depth = 1;
  499. desc->status |= IRQ_DISABLED;
  500. /* This is not a real spurrious interrupt, we
  501.  * have to eoi it, so we jump to out
  502.  */
  503. mask_irq(irq);
  504. goto out;
  505. }
  506. status &= ~IRQ_PENDING; /* we commit to handling */
  507. if (!(status & IRQ_PER_CPU))
  508. status |= IRQ_INPROGRESS; /* we are handling it */
  509. }
  510. desc->status = status;
  512. /*
  513.  * If there is no IRQ handler or it was disabled, exit early.
  514.    Since we set PENDING, if another processor is handling
  515.    a different instance of this same irq, the other processor
  516.    will take care of it.
  517.  */
  518. if (!action)
  519. goto out;
  522. /*
  523.  * Edge triggered interrupts need to remember
  524.  * pending events.
  525.  * This applies to any hw interrupts that allow a second
  526.  * instance of the same irq to arrive while we are in do_IRQ
  527.  * or in the handler. But the code here only handles the _second_
  528.  * instance of the irq, not the third or fourth. So it is mostly
  529.  * useful for irq hardware that does not mask cleanly in an
  530.  * SMP environment.
  531.  */
  532. for (;;) {
  533. spin_unlock(&desc->lock);
  534. handle_irq_event(irq, regs, action);
  535. spin_lock(&desc->lock);
  537. if (!(desc->status & IRQ_PENDING))
  538. break;
  539. desc->status &= ~IRQ_PENDING;
  540. }
  541. desc->status &= ~IRQ_INPROGRESS;
  542. out:
  543. /*
  544.  * The ->end() handler has to deal with interrupts which got
  545.  * disabled while the handler was running.
  546.  */
  547. if (irq_desc[irq].handler) {
  548. if (irq_desc[irq].handler->end)
  549. irq_desc[irq].handler->end(irq);
  550. else if (irq_desc[irq].handler->enable)
  551. irq_desc[irq].handler->enable(irq);
  552. }
  553. spin_unlock(&desc->lock);
  554. }
  556. int do_IRQ(struct pt_regs *regs)
  557. {
  558. int cpu = smp_processor_id();
  559. int irq, first = 1;
  560. #ifdef CONFIG_PPC_ISERIES
  561. struct paca_struct *lpaca;
  562. struct ItLpQueue *lpq;
  563. #endif
  565. irq_enter(cpu);
  567. #ifdef CONFIG_PPC_ISERIES
  568. lpaca = get_paca();
  569. #ifdef CONFIG_SMP
  570. if (lpaca->xLpPaca.xIntDword.xFields.xIpiCnt) {
  571. lpaca->xLpPaca.xIntDword.xFields.xIpiCnt = 0;
  572. iSeries_smp_message_recv(regs);
  573. }
  574. #endif /* CONFIG_SMP */
  575. lpq = lpaca->lpQueuePtr;
  576. if (lpq && ItLpQueue_isLpIntPending(lpq))
  577. lpEvent_count += ItLpQueue_process(lpq, regs);
  578. #else
  579. /*
  580.  * Every arch is required to implement ppc_md.get_irq.
  581.  * This function will either return an irq number or -1 to
  582.  * indicate there are no more pending.  But the first time
  583.  * through the loop this means there wasn't an IRQ pending.
  584.  * The value -2 is for buggy hardware and means that this IRQ
  585.  * has already been handled. -- Tom
  586.  */
  587. while ((irq = ppc_md.get_irq(regs)) >= 0) {
  588. ppc_irq_dispatch_handler(regs, irq);
  589. first = 0;
  590. }
  591. if (irq != -2 && first)
  592. /* That's not SMP safe ... but who cares ? */
  593. ppc_spurious_interrupts++;
  594. #endif
  596.         irq_exit(cpu);
  598. #ifdef CONFIG_PPC_ISERIES
  599. if (lpaca->xLpPaca.xIntDword.xFields.xDecrInt) {
  600. lpaca->xLpPaca.xIntDword.xFields.xDecrInt = 0;
  601. /* Signal a fake decrementer interrupt */
  602. timer_interrupt(regs);
  603. }
  605. if (lpaca->xLpPaca.xIntDword.xFields.xPdcInt) {
  606. lpaca->xLpPaca.xIntDword.xFields.xPdcInt = 0;
  607. /* Signal a fake PMC interrupt */
  608. PerformanceMonitorException();
  609. }
  610. #endif
  612. if (softirq_pending(cpu))
  613. do_softirq();
  615. return 1; /* lets ret_from_int know we can do checks */
  616. }
  618. unsigned long probe_irq_on (void)
  619. {
  620. return 0;
  621. }
  623. int probe_irq_off (unsigned long irqs)
  624. {
  625. return 0;
  626. }
  628. unsigned int probe_irq_mask(unsigned long irqs)
  629. {
  630. return 0;
  631. }
  633. void __init init_IRQ(void)
  634. {
  635. static int once = 0;
  637. if ( once )
  638. return;
  639. else
  640. once++;
  642. ppc_md.init_IRQ();
  643. if(ppc_md.init_ras_IRQ) ppc_md.init_ras_IRQ(); 
  644. }
  646. #ifdef CONFIG_SMP
  647. unsigned char global_irq_holder = NO_PROC_ID;
  649. static void show(char * str)
  650. {
  651. int cpu = smp_processor_id();
  652. int i;
  654. printk("n%s, CPU %d:n", str, cpu);
  655. printk("irq:  %d [ ", irqs_running());
  656. for (i = 0; i < smp_num_cpus; i++)
  657. printk("%u ", __brlock_array[i][BR_GLOBALIRQ_LOCK]);
  658. printk("]nbh:   %d [ ",
  659. (spin_is_locked(&global_bh_lock) ? 1 : 0));
  660. for (i = 0; i < smp_num_cpus; i++)
  661. printk("%u ", local_bh_count(i));
  662. printk("]n");
  663. }
  665. #define MAXCOUNT 10000000
  667. void synchronize_irq(void)
  668. {
  669. if (irqs_running()) {
  670. cli();
  671. sti();
  672. }
  673. }
  675. static inline void get_irqlock(int cpu)
  676. {
  677.         int count;
  679.         if ((unsigned char)cpu == global_irq_holder)
  680.                 return;
  682.         count = MAXCOUNT;
  683. again:
  684.         br_write_lock(BR_GLOBALIRQ_LOCK);
  685.         for (;;) {
  686.                 spinlock_t *lock;
  688.                 if (!irqs_running() &&
  689.                     (local_bh_count(smp_processor_id()) || !spin_is_locked(&global_bh_lock)))
  690.                         break;
  692.                 br_write_unlock(BR_GLOBALIRQ_LOCK);
  693.                 lock = &__br_write_locks[BR_GLOBALIRQ_LOCK].lock;
  694.                 while (irqs_running() ||
  695.                        spin_is_locked(lock) ||
  696.                        (!local_bh_count(smp_processor_id()) && spin_is_locked(&global_bh_lock))) {
  697.                         if (!--count) {
  698.                                 show("get_irqlock");
  699.                                 count = (~0 >> 1);
  700.                         }
  701.                         __sti();
  702.                         barrier();
  703.                         __cli();
  704.                 }
  705.                 goto again;
  706.         }
  708.         global_irq_holder = cpu;
  709. }
  711. /*
  712.  * A global "cli()" while in an interrupt context
  713.  * turns into just a local cli(). Interrupts
  714.  * should use spinlocks for the (very unlikely)
  715.  * case that they ever want to protect against
  716.  * each other.
  717.  *
  718.  * If we already have local interrupts disabled,
  719.  * this will not turn a local disable into a
  720.  * global one (problems with spinlocks: this makes
  721.  * save_flags+cli+sti usable inside a spinlock).
  722.  */
  723. void __global_cli(void)
  724. {
  725. unsigned long flags;
  727. __save_flags(flags);
  728. if (flags & (1UL << 15)) {
  729. int cpu = smp_processor_id();
  730. __cli();
  731. if (!local_irq_count(cpu))
  732. get_irqlock(cpu);
  733. }
  734. }
  736. void __global_sti(void)
  737. {
  738. int cpu = smp_processor_id();
  740. if (!local_irq_count(cpu))
  741. release_irqlock(cpu);
  742. __sti();
  743. }
  745. /*
  746.  * SMP flags value to restore to:
  747.  * 0 - global cli
  748.  * 1 - global sti
  749.  * 2 - local cli
  750.  * 3 - local sti
  751.  */
  752. unsigned long __global_save_flags(void)
  753. {
  754. int retval;
  755. int local_enabled;
  756. unsigned long flags;
  758. __save_flags(flags);
  759. local_enabled = (flags >> 15) & 1;
  760. /* default to local */
  761. retval = 2 + local_enabled;
  763. /* check for global flags if we're not in an interrupt */
  764. if (!local_irq_count(smp_processor_id())) {
  765. if (local_enabled)
  766. retval = 1;
  767. if (global_irq_holder == (unsigned char) smp_processor_id())
  768. retval = 0;
  769. }
  770. return retval;
  771. }
  773. void __global_restore_flags(unsigned long flags)
  774. {
  775. switch (flags) {
  776. case 0:
  777. __global_cli();
  778. break;
  779. case 1:
  780. __global_sti();
  781. break;
  782. case 2:
  783. __cli();
  784. break;
  785. case 3:
  786. __sti();
  787. break;
  788. default:
  789. printk("global_restore_flags: %016lx caller %pn",
  790. flags, __builtin_return_address(0));
  791. }
  792. }
  794. #endif /* CONFIG_SMP */
  796. static struct proc_dir_entry * root_irq_dir;
  797. static struct proc_dir_entry * irq_dir [NR_IRQS];
  798. static struct proc_dir_entry * smp_affinity_entry [NR_IRQS];
  800. #ifdef CONFIG_IRQ_ALL_CPUS
  801. unsigned int irq_affinity [NR_IRQS] = { [0 ... NR_IRQS-1] = 0xffffffff};
  802. #else  /* CONFIG_IRQ_ALL_CPUS */
  803. unsigned int irq_affinity [NR_IRQS] = { [0 ... NR_IRQS-1] = 0x00000000};
  804. #endif /* CONFIG_IRQ_ALL_CPUS */
  806. #define HEX_DIGITS 8
  808. static int irq_affinity_read_proc (char *page, char **start, off_t off,
  809. int count, int *eof, void *data)
  810. {
  811. if (count < HEX_DIGITS+1)
  812. return -EINVAL;
  813. return sprintf (page, "%08xn", irq_affinity[(int)(long)data]);
  814. }
  816. static unsigned int parse_hex_value (const char *buffer,
  817. unsigned long count, unsigned long *ret)
  818. {
  819. unsigned char hexnum [HEX_DIGITS];
  820. unsigned long value;
  821. int i;
  823. if (!count)
  824. return -EINVAL;
  825. if (count > HEX_DIGITS)
  826. count = HEX_DIGITS;
  827. if (copy_from_user(hexnum, buffer, count))
  828. return -EFAULT;
  830. /*
  831.  * Parse the first 8 characters as a hex string, any non-hex char
  832.  * is end-of-string. '00e1', 'e1', '00E1', 'E1' are all the same.
  833.  */
  834. value = 0;
  836. for (i = 0; i < count; i++) {
  837. unsigned int c = hexnum[i];
  839. switch (c) {
  840. case '0' ... '9': c -= '0'; break;
  841. case 'a' ... 'f': c -= 'a'-10; break;
  842. case 'A' ... 'F': c -= 'A'-10; break;
  843. default:
  844. goto out;
  845. }
  846. value = (value << 4) | c;
  847. }
  848. out:
  849. *ret = value;
  850. return 0;
  851. }
  853. static int irq_affinity_write_proc (struct file *file, const char *buffer,
  854. unsigned long count, void *data)
  855. {
  856. int irq = (int)(long) data, full_count = count, err;
  857. unsigned long new_value;
  859. if (!irq_desc[irq].handler->set_affinity)
  860. return -EIO;
  862. err = parse_hex_value(buffer, count, &new_value);
  864. /* Why is this disabled ? --BenH */
  865. #if 0/*CONFIG_SMP*/
  866. /*
  867.  * Do not allow disabling IRQs completely - it's a too easy
  868.  * way to make the system unusable accidentally :-) At least
  869.  * one online CPU still has to be targeted.
  870.  */
  871. if (!(new_value & cpu_online_map))
  872. return -EINVAL;
  873. #endif
  875. irq_affinity[irq] = new_value;
  876. irq_desc[irq].handler->set_affinity(irq, new_value);
  878. return full_count;
  879. }
  881. static int prof_cpu_mask_read_proc (char *page, char **start, off_t off,
  882. int count, int *eof, void *data)
  883. {
  884. unsigned long *mask = (unsigned long *) data;
  885. if (count < HEX_DIGITS+1)
  886. return -EINVAL;
  887. return sprintf (page, "%08lxn", *mask);
  888. }
  890. static int prof_cpu_mask_write_proc (struct file *file, const char *buffer,
  891. unsigned long count, void *data)
  892. {
  893. unsigned long *mask = (unsigned long *) data, full_count = count, err;
  894. unsigned long new_value;
  896. err = parse_hex_value(buffer, count, &new_value);
  897. if (err)
  898. return err;
  900. *mask = new_value;
  902. #ifdef CONFIG_PPC_ISERIES
  903. {
  904. unsigned i;
  905. for (i=0; i<MAX_PACAS; ++i) {
  906. if ( paca[i].prof_buffer && (new_value & 1) )
  907. paca[i].prof_mode = PMC_STATE_DECR_PROFILE;
  908. else {
  909. if(paca[i].prof_mode != PMC_STATE_INITIAL) 
  910. paca[i].prof_mode = PMC_STATE_READY;
  911. }
  912. new_value >>= 1;
  913. }
  914. }
  915. #endif
  917. return full_count;
  918. }
  920. #define MAX_NAMELEN 10
  922. static void register_irq_proc (unsigned int irq)
  923. {
  924. struct proc_dir_entry *entry;
  925. char name [MAX_NAMELEN];
  927. if (!root_irq_dir || (irq_desc[irq].handler == NULL))
  928. return;
  930. memset(name, 0, MAX_NAMELEN);
  931. sprintf(name, "%d", irq);
  933. /* create /proc/irq/1234 */
  934. irq_dir[irq] = proc_mkdir(name, root_irq_dir);
  936. /* create /proc/irq/1234/smp_affinity */
  937. entry = create_proc_entry("smp_affinity", 0600, irq_dir[irq]);
  939. entry->nlink = 1;
  940. entry->data = (void *)(long)irq;
  941. entry->read_proc = irq_affinity_read_proc;
  942. entry->write_proc = irq_affinity_write_proc;
  944. smp_affinity_entry[irq] = entry;
  945. }
  947. unsigned long prof_cpu_mask = -1;
  949. void init_irq_proc (void)
  950. {
  951. struct proc_dir_entry *entry;
  952. int i;
  954. /* create /proc/irq */
  955. root_irq_dir = proc_mkdir("irq", 0);
  957. /* create /proc/irq/prof_cpu_mask */
  958. entry = create_proc_entry("prof_cpu_mask", 0600, root_irq_dir);
  960. entry->nlink = 1;
  961. entry->data = (void *)&prof_cpu_mask;
  962. entry->read_proc = prof_cpu_mask_read_proc;
  963. entry->write_proc = prof_cpu_mask_write_proc;
  965. /*
  966.  * Create entries for all existing IRQs.
  967.  */
  968. for (i = 0; i < NR_IRQS; i++) {
  969. if (irq_desc[i].handler == NULL)
  970. continue;
  971. register_irq_proc(i);
  972. }
  973. }
  975. void no_action(int irq, void *dev, struct pt_regs *regs)
  976. {
  977. }