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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
irq.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：24k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

irq.c：源码内容
  1. /*
  2.  * BK Id: SCCS/s.irq.c 1.34 12/01/01 20:09:06 benh
  3.  */
  4. /*
  5.  *  arch/ppc/kernel/irq.c
  6.  *
  7.  *  Derived from arch/i386/kernel/irq.c
  8.  *    Copyright (C) 1992 Linus Torvalds
  9.  *  Adapted from arch/i386 by Gary Thomas
  10.  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
  11.  *  Updated and modified by Cort Dougan <cort@fsmlabs.com>
  12.  *    Copyright (C) 1996-2001 Cort Dougan
  13.  *  Adapted for Power Macintosh by Paul Mackerras
  14.  *    Copyright (C) 1996 Paul Mackerras (paulus@cs.anu.edu.au)
  15.  *  Amiga/APUS changes by Jesper Skov (jskov@cygnus.co.uk).
  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 compliment 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.  */
  33. #include <linux/ptrace.h>
  34. #include <linux/errno.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/ioport.h>
  40. #include <linux/interrupt.h>
  41. #include <linux/timex.h>
  42. #include <linux/config.h>
  43. #include <linux/init.h>
  44. #include <linux/slab.h>
  45. #include <linux/pci.h>
  46. #include <linux/delay.h>
  47. #include <linux/irq.h>
  48. #include <linux/proc_fs.h>
  49. #include <linux/random.h>
  51. #include <asm/uaccess.h>
  52. #include <asm/bitops.h>
  53. #include <asm/hydra.h>
  54. #include <asm/system.h>
  55. #include <asm/io.h>
  56. #include <asm/pgtable.h>
  57. #include <asm/irq.h>
  58. #include <asm/gg2.h>
  59. #include <asm/cache.h>
  60. #include <asm/prom.h>
  61. #include <asm/amigaints.h>
  62. #include <asm/amigahw.h>
  63. #include <asm/amigappc.h>
  64. #include <asm/ptrace.h>
  66. #include "local_irq.h"
  68. extern atomic_t ipi_recv;
  69. extern atomic_t ipi_sent;
  70. void enable_irq(unsigned int irq_nr);
  71. void disable_irq(unsigned int irq_nr);
  73. static void register_irq_proc (unsigned int irq);
  75. #define MAXCOUNT 10000000
  77. irq_desc_t irq_desc[NR_IRQS] __cacheline_aligned =
  78. { [0 ... NR_IRQS-1] = { 0, NULL, NULL, 0, SPIN_LOCK_UNLOCKED}};
  80. int ppc_spurious_interrupts = 0;
  81. struct irqaction *ppc_irq_action[NR_IRQS];
  82. unsigned long ppc_cached_irq_mask[NR_MASK_WORDS];
  83. unsigned long ppc_lost_interrupts[NR_MASK_WORDS];
  84. atomic_t ppc_n_lost_interrupts;
  86. /* nasty hack for shared irq's since we need to do kmalloc calls but
  87.  * can't very early in the boot when we need to do a request irq.
  88.  * this needs to be removed.
  89.  * -- Cort
  90.  */
  91. #define IRQ_KMALLOC_ENTRIES 8
  92. static int cache_bitmask = 0;
  93. static struct irqaction malloc_cache[IRQ_KMALLOC_ENTRIES];
  94. extern int mem_init_done;
  96. #if defined(CONFIG_TAU_INT)
  97. extern int tau_interrupts(unsigned long cpu);
  98. extern int tau_initialized;
  99. #endif
  101. void *irq_kmalloc(size_t size, int pri)
  102. {
  103. unsigned int i;
  104. if ( mem_init_done )
  105. return kmalloc(size,pri);
  106. for ( i = 0; i < IRQ_KMALLOC_ENTRIES ; i++ )
  107. if ( ! ( cache_bitmask & (1<<i) ) )
  108. {
  109. cache_bitmask |= (1<<i);
  110. return (void *)(&malloc_cache[i]);
  111. }
  112. return 0;
  113. }
  115. void irq_kfree(void *ptr)
  116. {
  117. unsigned int i;
  118. for ( i = 0 ; i < IRQ_KMALLOC_ENTRIES ; i++ )
  119. if ( ptr == &malloc_cache[i] )
  120. {
  121. cache_bitmask &= ~(1<<i);
  122. return;
  123. }
  124. kfree(ptr);
  125. }
  127. int
  128. setup_irq(unsigned int irq, struct irqaction * new)
  129. {
  130. int shared = 0;
  131. unsigned long flags;
  132. struct irqaction *old, **p;
  133. irq_desc_t *desc = irq_desc + irq;
  135. /*
  136.  * Some drivers like serial.c use request_irq() heavily,
  137.  * so we have to be careful not to interfere with a
  138.  * running system.
  139.  */
  140. if (new->flags & SA_SAMPLE_RANDOM) {
  141. /*
  142.  * This function might sleep, we want to call it first,
  143.  * outside of the atomic block.
  144.  * Yes, this might clear the entropy pool if the wrong
  145.  * driver is attempted to be loaded, without actually
  146.  * installing a new handler, but is this really a problem,
  147.  * only the sysadmin is able to do this.
  148.  */
  149. rand_initialize_irq(irq);
  150. }
  152. /*
  153.  * The following block of code has to be executed atomically
  154.  */
  155. spin_lock_irqsave(&desc->lock,flags);
  156. p = &desc->action;
  157. if ((old = *p) != NULL) {
  158. /* Can't share interrupts unless both agree to */
  159. if (!(old->flags & new->flags & SA_SHIRQ)) {
  160. spin_unlock_irqrestore(&desc->lock,flags);
  161. return -EBUSY;
  162. }
  164. /* add new interrupt at end of irq queue */
  165. do {
  166. p = &old->next;
  167. old = *p;
  168. } while (old);
  169. shared = 1;
  170. }
  172. *p = new;
  174. if (!shared) {
  175. desc->depth = 0;
  176. desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT | IRQ_WAITING);
  177. unmask_irq(irq);
  178. }
  179. spin_unlock_irqrestore(&desc->lock,flags);
  181. register_irq_proc(irq);
  182. return 0;
  183. }
  185. #if (defined(CONFIG_8xx) || defined(CONFIG_8260))
  186. /* Name change so we can catch standard drivers that potentially mess up
  187.  * the internal interrupt controller on 8xx and 8260.  Just bear with me,
  188.  * I don't like this either and I am searching a better solution.  For
  189.  * now, this is what I need. -- Dan
  190.  */
  191. #define request_irq request_8xxirq
  192. #elif defined(CONFIG_APUS)
  193. #define request_irq request_sysirq
  194. #define free_irq sys_free_irq
  195. #endif
  197. void free_irq(unsigned int irq, void* dev_id)
  198. {
  199. irq_desc_t *desc;
  200. struct irqaction **p;
  201. unsigned long flags;
  203. desc = irq_desc + irq;
  204. spin_lock_irqsave(&desc->lock,flags);
  205. p = &desc->action;
  206. for (;;) {
  207. struct irqaction * action = *p;
  208. if (action) {
  209. struct irqaction **pp = p;
  210. p = &action->next;
  211. if (action->dev_id != dev_id)
  212. continue;
  214. /* Found it - now remove it from the list of entries */
  215. *pp = action->next;
  216. if (!desc->action) {
  217. desc->status |= IRQ_DISABLED;
  218. mask_irq(irq);
  219. }
  220. spin_unlock_irqrestore(&desc->lock,flags);
  222. #ifdef CONFIG_SMP
  223. /* Wait to make sure it's not being used on another CPU */
  224. while (desc->status & IRQ_INPROGRESS)
  225. barrier();
  226. #endif
  227. irq_kfree(action);
  228. return;
  229. }
  230. printk("Trying to free free IRQ%dn",irq);
  231. spin_unlock_irqrestore(&desc->lock,flags);
  232. break;
  233. }
  234. return;
  235. }
  237. int request_irq(unsigned int irq, void (*handler)(int, void *, struct pt_regs *),
  238. unsigned long irqflags, const char * devname, void *dev_id)
  239. {
  240. struct irqaction *action;
  241. int retval;
  243. if (irq >= NR_IRQS)
  244. return -EINVAL;
  245. if (!handler)
  246. {
  247. /*
  248.  * free_irq() used to be implemented as a call to
  249.  * request_irq() with handler being NULL.  Now we have
  250.  * a real free_irq() but need to allow the old behavior
  251.  * for old code that hasn't caught up yet.
  252.  *  -- Cort <cort@fsmlabs.com>
  253.  */
  254. free_irq(irq, dev_id);
  255. return 0;
  256. }
  258. action = (struct irqaction *)
  259. irq_kmalloc(sizeof(struct irqaction), GFP_KERNEL);
  260. if (!action) {
  261. printk(KERN_ERR "irq_kmalloc() failed for irq %d !n", irq);
  262. return -ENOMEM;
  263. }
  265. action->handler = handler;
  266. action->flags = irqflags;
  267. action->mask = 0;
  268. action->name = devname;
  269. action->dev_id = dev_id;
  270. action->next = NULL;
  272. retval = setup_irq(irq, action);
  273. if (retval)
  274. {
  275. kfree(action);
  276. return retval;
  277. }
  279. return 0;
  280. }
  282. /*
  283.  * Generic enable/disable code: this just calls
  284.  * down into the PIC-specific version for the actual
  285.  * hardware disable after having gotten the irq
  286.  * controller lock. 
  287.  */
  288.  
  289. /**
  290.  * disable_irq_nosync - disable an irq without waiting
  291.  * @irq: Interrupt to disable
  292.  *
  293.  * Disable the selected interrupt line. Disables of an interrupt
  294.  * stack. Unlike disable_irq(), this function does not ensure existing
  295.  * instances of the IRQ handler have completed before returning.
  296.  *
  297.  * This function may be called from IRQ context.
  298.  */
  299.  
  300.  void disable_irq_nosync(unsigned int irq)
  301. {
  302. irq_desc_t *desc = irq_desc + irq;
  303. unsigned long flags;
  305. spin_lock_irqsave(&desc->lock, flags);
  306. if (!desc->depth++) {
  307. if (!(desc->status & IRQ_PER_CPU))
  308. desc->status |= IRQ_DISABLED;
  309. mask_irq(irq);
  310. }
  311. spin_unlock_irqrestore(&desc->lock, flags);
  312. }
  314. /**
  315.  * disable_irq - disable an irq and wait for completion
  316.  * @irq: Interrupt to disable
  317.  *
  318.  * Disable the selected interrupt line. Disables of an interrupt
  319.  * stack. That is for two disables you need two enables. This
  320.  * function waits for any pending IRQ handlers for this interrupt
  321.  * to complete before returning. If you use this function while
  322.  * holding a resource the IRQ handler may need you will deadlock.
  323.  *
  324.  * This function may be called - with care - from IRQ context.
  325.  */
  326.  
  327. void disable_irq(unsigned int irq)
  328. {
  329. disable_irq_nosync(irq);
  331. if (!local_irq_count(smp_processor_id())) {
  332. do {
  333. barrier();
  334. } while (irq_desc[irq].status & IRQ_INPROGRESS);
  335. }
  336. }
  338. /**
  339.  * enable_irq - enable interrupt handling on an irq
  340.  * @irq: Interrupt to enable
  341.  *
  342.  * Re-enables the processing of interrupts on this IRQ line
  343.  * providing no disable_irq calls are now in effect.
  344.  *
  345.  * This function may be called from IRQ context.
  346.  */
  347.  
  348. void enable_irq(unsigned int irq)
  349. {
  350. irq_desc_t *desc = irq_desc + irq;
  351. unsigned long flags;
  353. spin_lock_irqsave(&desc->lock, flags);
  354. switch (desc->depth) {
  355. case 1: {
  356. unsigned int status = desc->status & ~IRQ_DISABLED;
  357. desc->status = status;
  358. if ((status & (IRQ_PENDING | IRQ_REPLAY)) == IRQ_PENDING) {
  359. desc->status = status | IRQ_REPLAY;
  360. hw_resend_irq(desc->handler,irq);
  361. }
  362. unmask_irq(irq);
  363. /* fall-through */
  364. }
  365. default:
  366. desc->depth--;
  367. break;
  368. case 0:
  369. printk("enable_irq(%u) unbalancedn", irq);
  370. }
  371. spin_unlock_irqrestore(&desc->lock, flags);
  372. }
  374. int get_irq_list(char *buf)
  375. {
  376. #ifdef CONFIG_APUS
  377. return apus_get_irq_list (buf);
  378. #else
  379. int i, len = 0, j;
  380. struct irqaction * action;
  382. len += sprintf(buf+len, "           ");
  383. for (j=0; j<smp_num_cpus; j++)
  384. len += sprintf(buf+len, "CPU%d       ",j);
  385. *(char *)(buf+len++) = 'n';
  387. for (i = 0 ; i < NR_IRQS ; i++) {
  388. action = irq_desc[i].action;
  389. if ( !action || !action->handler )
  390. continue;
  391. len += sprintf(buf+len, "%3d: ", i);
  392. #ifdef CONFIG_SMP
  393. for (j = 0; j < smp_num_cpus; j++)
  394. len += sprintf(buf+len, "%10u ",
  395. kstat.irqs[cpu_logical_map(j)][i]);
  396. #else
  397. len += sprintf(buf+len, "%10u ", kstat_irqs(i));
  398. #endif /* CONFIG_SMP */
  399. if ( irq_desc[i].handler )
  400. len += sprintf(buf+len, " %s ", irq_desc[i].handler->typename );
  401. else
  402. len += sprintf(buf+len, "  None      ");
  403. len += sprintf(buf+len, "%s", (irq_desc[i].status & IRQ_LEVEL) ? "Level " : "Edge  ");
  404. len += sprintf(buf+len, "    %s",action->name);
  405. for (action=action->next; action; action = action->next) {
  406. len += sprintf(buf+len, ", %s", action->name);
  407. }
  408. len += sprintf(buf+len, "n");
  409. }
  410. #ifdef CONFIG_TAU_INT
  411. if (tau_initialized){
  412. len += sprintf(buf+len, "TAU: ");
  413. for (j = 0; j < smp_num_cpus; j++)
  414. len += sprintf(buf+len, "%10u ",
  415. tau_interrupts(j));
  416. len += sprintf(buf+len, "  PowerPC             Thermal Assist (cpu temp)n");
  417. }
  418. #endif
  419. #ifdef CONFIG_SMP
  420. /* should this be per processor send/receive? */
  421. len += sprintf(buf+len, "IPI (recv/sent): %10u/%un",
  422.        atomic_read(&ipi_recv), atomic_read(&ipi_sent));
  423. #endif
  424. len += sprintf(buf+len, "BAD: %10un", ppc_spurious_interrupts);
  425. return len;
  426. #endif /* CONFIG_APUS */
  427. }
  429. static inline void
  430. handle_irq_event(int irq, struct pt_regs *regs, struct irqaction *action)
  431. {
  432. int status = 0;
  434. if (!(action->flags & SA_INTERRUPT))
  435. __sti();
  437. do {
  438. status |= action->flags;
  439. action->handler(irq, action->dev_id, regs);
  440. action = action->next;
  441. } while (action);
  442. if (status & SA_SAMPLE_RANDOM)
  443. add_interrupt_randomness(irq);
  444. __cli();
  445. }
  447. /*
  448.  * Eventually, this should take an array of interrupts and an array size
  449.  * so it can dispatch multiple interrupts.
  450.  */
  451. void ppc_irq_dispatch_handler(struct pt_regs *regs, int irq)
  452. {
  453. int status;
  454. struct irqaction *action;
  455. int cpu = smp_processor_id();
  456. irq_desc_t *desc = irq_desc + irq;
  458. kstat.irqs[cpu][irq]++;
  459. spin_lock(&desc->lock);
  460. ack_irq(irq);
  461. /*
  462.    REPLAY is when Linux resends an IRQ that was dropped earlier
  463.    WAITING is used by probe to mark irqs that are being tested
  464.    */
  465. status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING);
  466. if (!(status & IRQ_PER_CPU))
  467. status |= IRQ_PENDING; /* we _want_ to handle it */
  469. /*
  470.  * If the IRQ is disabled for whatever reason, we cannot
  471.  * use the action we have.
  472.  */
  473. action = NULL;
  474. if (!(status & (IRQ_DISABLED | IRQ_INPROGRESS))) {
  475. action = desc->action;
  476. if (!action || !action->handler) {
  477. ppc_spurious_interrupts++;
  478. printk(KERN_DEBUG "Unhandled interrupt %x, disabledn", irq);
  479. /* We can't call disable_irq here, it would deadlock */
  480. ++desc->depth;
  481. desc->status |= IRQ_DISABLED;
  482. mask_irq(irq);
  483. /* This is a real interrupt, we have to eoi it,
  484.    so we jump to out */
  485. goto out;
  486. }
  487. status &= ~IRQ_PENDING; /* we commit to handling */
  488. if (!(status & IRQ_PER_CPU))
  489. status |= IRQ_INPROGRESS; /* we are handling it */
  490. }
  491. desc->status = status;
  493. /*
  494.  * If there is no IRQ handler or it was disabled, exit early.
  495.    Since we set PENDING, if another processor is handling
  496.    a different instance of this same irq, the other processor
  497.    will take care of it.
  498.  */
  499. if (!action)
  500. goto out;
  503. /*
  504.  * Edge triggered interrupts need to remember
  505.  * pending events.
  506.  * This applies to any hw interrupts that allow a second
  507.  * instance of the same irq to arrive while we are in do_IRQ
  508.  * or in the handler. But the code here only handles the _second_
  509.  * instance of the irq, not the third or fourth. So it is mostly
  510.  * useful for irq hardware that does not mask cleanly in an
  511.  * SMP environment.
  512.  */
  513. for (;;) {
  514. spin_unlock(&desc->lock);
  515. handle_irq_event(irq, regs, action);
  516. spin_lock(&desc->lock);
  518. if (!(desc->status & IRQ_PENDING))
  519. break;
  520. desc->status &= ~IRQ_PENDING;
  521. }
  522. desc->status &= ~IRQ_INPROGRESS;
  523. out:
  524. /*
  525.  * The ->end() handler has to deal with interrupts which got
  526.  * disabled while the handler was running.
  527.  */
  528. if (irq_desc[irq].handler) {
  529. if (irq_desc[irq].handler->end)
  530. irq_desc[irq].handler->end(irq);
  531. else if (irq_desc[irq].handler->enable)
  532. irq_desc[irq].handler->enable(irq);
  533. }
  534. spin_unlock(&desc->lock);
  535. }
  537. int do_IRQ(struct pt_regs *regs)
  538. {
  539. int cpu = smp_processor_id();
  540. int irq, first = 1;
  541.         hardirq_enter( cpu );
  543. for (;;) {
  544. /*
  545.  * Every arch is required to implement ppc_md.get_irq.
  546.  * This function will either return an irq number or -1 to
  547.  * indicate there are no more pending.  But the first time
  548.  * through the loop this means there wasn't and IRQ pending.
  549.  * The value -2 is for buggy hardware and means that this IRQ
  550.  * has already been handled. -- Tom
  551.  */
  552. irq = ppc_md.get_irq( regs );
  554. if (irq >= 0)
  555. ppc_irq_dispatch_handler( regs, irq );
  556. else {
  557. if (irq != -2 && first)
  558. /* That's not SMP safe ... but who cares ? */
  559. ppc_spurious_interrupts++;
  560. break;
  561. }
  562. first = 0;
  563. }
  564.         hardirq_exit( cpu );
  566. if (softirq_pending(cpu))
  567. do_softirq();
  568. return 1; /* lets ret_from_int know we can do checks */
  569. }
  571. unsigned long probe_irq_on (void)
  572. {
  573. return 0;
  574. }
  576. int probe_irq_off (unsigned long irqs)
  577. {
  578. return 0;
  579. }
  581. unsigned int probe_irq_mask(unsigned long irqs)
  582. {
  583. return 0;
  584. }
  586. void __init init_IRQ(void)
  587. {
  588. static int once = 0;
  590. if ( once )
  591. return;
  592. else
  593. once++;
  595. ppc_md.init_IRQ();
  596. }
  598. #ifdef CONFIG_SMP
  599. unsigned char global_irq_holder = NO_PROC_ID;
  600. unsigned volatile long global_irq_lock; /* pendantic :long for set_bit--RR*/
  601. atomic_t global_irq_count;
  603. atomic_t global_bh_count;
  605. static void show(char * str)
  606. {
  607. int i;
  608. unsigned long *stack;
  609. int cpu = smp_processor_id();
  611. printk("n%s, CPU %d:n", str, cpu);
  612. printk("irq:  %d [%d %d]n",
  613.        atomic_read(&global_irq_count),
  614.        local_irq_count(0),
  615.        local_irq_count(1));
  616. printk("bh:   %d [%d %d]n",
  617.        atomic_read(&global_bh_count),
  618.        local_bh_count(0),
  619.        local_bh_count(1));
  620. stack = (unsigned long *) &str;
  621. for (i = 40; i ; i--) {
  622. unsigned long x = *++stack;
  623. if (x > (unsigned long) &init_task_union && x < (unsigned long) &vsprintf) {
  624. printk("<[%08lx]> ", x);
  625. }
  626. }
  627. }
  629. static inline void wait_on_bh(void)
  630. {
  631. int count = MAXCOUNT;
  632. do {
  633. if (!--count) {
  634. show("wait_on_bh");
  635. count = ~0;
  636. }
  637. /* nothing .. wait for the other bh's to go away */
  638. } while (atomic_read(&global_bh_count) != 0);
  639. }
  642. static inline void wait_on_irq(int cpu)
  643. {
  644. int count = MAXCOUNT;
  646. for (;;) {
  648. /*
  649.  * Wait until all interrupts are gone. Wait
  650.  * for bottom half handlers unless we're
  651.  * already executing in one..
  652.  */
  653. if (!atomic_read(&global_irq_count)) {
  654. if (local_bh_count(cpu)
  655.     || !atomic_read(&global_bh_count))
  656. break;
  657. }
  659. /* Duh, we have to loop. Release the lock to avoid deadlocks */
  660. clear_bit(0,&global_irq_lock);
  662. for (;;) {
  663. if (!--count) {
  664. show("wait_on_irq");
  665. count = ~0;
  666. }
  667. __sti();
  668. /* don't worry about the lock race Linus found
  669.  * on intel here. -- Cort
  670.  */
  671. __cli();
  672. if (atomic_read(&global_irq_count))
  673. continue;
  674. if (global_irq_lock)
  675. continue;
  676. if (!local_bh_count(cpu)
  677.     && atomic_read(&global_bh_count))
  678. continue;
  679. if (!test_and_set_bit(0,&global_irq_lock))
  680. break;
  681. }
  682. }
  683. }
  685. /*
  686.  * This is called when we want to synchronize with
  687.  * bottom half handlers. We need to wait until
  688.  * no other CPU is executing any bottom half handler.
  689.  *
  690.  * Don't wait if we're already running in an interrupt
  691.  * context or are inside a bh handler.
  692.  */
  693. void synchronize_bh(void)
  694. {
  695. if (atomic_read(&global_bh_count) && !in_interrupt())
  696. wait_on_bh();
  697. }
  699. /*
  700.  * This is called when we want to synchronize with
  701.  * interrupts. We may for example tell a device to
  702.  * stop sending interrupts: but to make sure there
  703.  * are no interrupts that are executing on another
  704.  * CPU we need to call this function.
  705.  */
  706. void synchronize_irq(void)
  707. {
  708. if (atomic_read(&global_irq_count)) {
  709. /* Stupid approach */
  710. cli();
  711. sti();
  712. }
  713. }
  715. static inline void get_irqlock(int cpu)
  716. {
  717. unsigned int loops = MAXCOUNT;
  719. if (test_and_set_bit(0,&global_irq_lock)) {
  720. /* do we already hold the lock? */
  721. if ((unsigned char) cpu == global_irq_holder)
  722. return;
  723. /* Uhhuh.. Somebody else got it. Wait.. */
  724. do {
  725. do {
  726. if (loops-- == 0) {
  727. printk("get_irqlock(%d) waiting, global_irq_holder=%dn", cpu, global_irq_holder);
  728. #ifdef CONFIG_XMON
  729. xmon(0);
  730. #endif
  731. }
  732. } while (test_bit(0,&global_irq_lock));
  733. } while (test_and_set_bit(0,&global_irq_lock));
  734. }
  735. /* 
  736.  * We also need to make sure that nobody else is running
  737.  * in an interrupt context. 
  738.  */
  739. wait_on_irq(cpu);
  741. /*
  742.  * Ok, finally..
  743.  */
  744. global_irq_holder = cpu;
  745. }
  747. /*
  748.  * A global "cli()" while in an interrupt context
  749.  * turns into just a local cli(). Interrupts
  750.  * should use spinlocks for the (very unlikely)
  751.  * case that they ever want to protect against
  752.  * each other.
  753.  *
  754.  * If we already have local interrupts disabled,
  755.  * this will not turn a local disable into a
  756.  * global one (problems with spinlocks: this makes
  757.  * save_flags+cli+sti usable inside a spinlock).
  758.  */
  759. void __global_cli(void)
  760. {
  761. unsigned long flags;
  763. __save_flags(flags);
  764. if (flags & (1 << 15)) {
  765. int cpu = smp_processor_id();
  766. __cli();
  767. if (!local_irq_count(cpu))
  768. get_irqlock(cpu);
  769. }
  770. }
  772. void __global_sti(void)
  773. {
  774. int cpu = smp_processor_id();
  776. if (!local_irq_count(cpu))
  777. release_irqlock(cpu);
  778. __sti();
  779. }
  781. /*
  782.  * SMP flags value to restore to:
  783.  * 0 - global cli
  784.  * 1 - global sti
  785.  * 2 - local cli
  786.  * 3 - local sti
  787.  */
  788. unsigned long __global_save_flags(void)
  789. {
  790. int retval;
  791. int local_enabled;
  792. unsigned long flags;
  794. __save_flags(flags);
  795. local_enabled = (flags >> 15) & 1;
  796. /* default to local */
  797. retval = 2 + local_enabled;
  799. /* check for global flags if we're not in an interrupt */
  800. if (!local_irq_count(smp_processor_id())) {
  801. if (local_enabled)
  802. retval = 1;
  803. if (global_irq_holder == (unsigned char) smp_processor_id())
  804. retval = 0;
  805. }
  806. return retval;
  807. }
  809. int
  810. tb(long vals[],
  811.    int  max_size)
  812. {
  813.    register unsigned long *orig_sp __asm__ ("r1");
  814.    register unsigned long lr __asm__ ("r3");
  815.    unsigned long *sp;
  816.    int i;
  818.    asm volatile ("mflr 3");
  819.    vals[0] = lr;
  820.    sp = (unsigned long *) *orig_sp;
  821.    sp = (unsigned long *) *sp;
  822.    for (i=1; i<max_size; i++) {
  823.       if (sp == 0) {
  824.          break;
  825.       }
  827.       vals[i] = *(sp+1);
  828.       sp = (unsigned long *) *sp;
  829.    }
  831.    return i;
  832. }
  834. void __global_restore_flags(unsigned long flags)
  835. {
  836. switch (flags) {
  837. case 0:
  838. __global_cli();
  839. break;
  840. case 1:
  841. __global_sti();
  842. break;
  843. case 2:
  844. __cli();
  845. break;
  846. case 3:
  847. __sti();
  848. break;
  849. default:
  850. {
  851. unsigned long trace[5];
  852.                 int           count;
  853.                 int           i;
  855. printk("global_restore_flags: %08lx (%08lx)n",
  856. flags, (&flags)[-1]);
  857.                 count = tb(trace, 5);
  858.                 printk("tb:");
  859.                 for(i=0; i<count; i++) {
  860. printk(" %8.8lx", trace[i]);
  861. }
  862. printk("n");
  863. }
  864. }
  865. }
  866. #endif /* CONFIG_SMP */
  868. static struct proc_dir_entry *root_irq_dir;
  869. static struct proc_dir_entry *irq_dir[NR_IRQS];
  870. static struct proc_dir_entry *smp_affinity_entry[NR_IRQS];
  872. #ifdef CONFIG_IRQ_ALL_CPUS
  873. #define DEFAULT_CPU_AFFINITY 0xffffffff
  874. #else
  875. #define DEFAULT_CPU_AFFINITY 0x00000001
  876. #endif
  878. unsigned int irq_affinity [NR_IRQS] =
  879. { [0 ... NR_IRQS-1] = DEFAULT_CPU_AFFINITY };
  881. #define HEX_DIGITS 8
  883. static int irq_affinity_read_proc (char *page, char **start, off_t off,
  884. int count, int *eof, void *data)
  885. {
  886. if (count < HEX_DIGITS+1)
  887. return -EINVAL;
  888. return sprintf (page, "%08xn", irq_affinity[(int)data]);
  889. }
  891. static unsigned int parse_hex_value (const char *buffer,
  892. unsigned long count, unsigned long *ret)
  893. {
  894. unsigned char hexnum [HEX_DIGITS];
  895. unsigned long value;
  896. int i;
  898. if (!count)
  899. return -EINVAL;
  900. if (count > HEX_DIGITS)
  901. count = HEX_DIGITS;
  902. if (copy_from_user(hexnum, buffer, count))
  903. return -EFAULT;
  905. /*
  906.  * Parse the first 8 characters as a hex string, any non-hex char
  907.  * is end-of-string. '00e1', 'e1', '00E1', 'E1' are all the same.
  908.  */
  909. value = 0;
  911. for (i = 0; i < count; i++) {
  912. unsigned int c = hexnum[i];
  914. switch (c) {
  915. case '0' ... '9': c -= '0'; break;
  916. case 'a' ... 'f': c -= 'a'-10; break;
  917. case 'A' ... 'F': c -= 'A'-10; break;
  918. default:
  919. goto out;
  920. }
  921. value = (value << 4) | c;
  922. }
  923. out:
  924. *ret = value;
  925. return 0;
  926. }
  928. static int irq_affinity_write_proc (struct file *file, const char *buffer,
  929. unsigned long count, void *data)
  930. {
  931. int irq = (int) data, full_count = count, err;
  932. unsigned long new_value;
  934. if (!irq_desc[irq].handler->set_affinity)
  935. return -EIO;
  937. err = parse_hex_value(buffer, count, &new_value);
  939. /*
  940.  * Do not allow disabling IRQs completely - it's a too easy
  941.  * way to make the system unusable accidentally :-) At least
  942.  * one online CPU still has to be targeted.
  943.  *
  944.  * We assume a 1-1 logical<->physical cpu mapping here.  If
  945.  * we assume that the cpu indices in /proc/irq/../smp_affinity
  946.  * are actually logical cpu #'s then we have no problem.
  947.  *  -- Cort <cort@fsmlabs.com>
  948.  */
  949. if (!(new_value & cpu_online_map))
  950. return -EINVAL;
  952. irq_affinity[irq] = new_value;
  953. irq_desc[irq].handler->set_affinity(irq, new_value);
  955. return full_count;
  956. }
  958. static int prof_cpu_mask_read_proc (char *page, char **start, off_t off,
  959. int count, int *eof, void *data)
  960. {
  961. unsigned long *mask = (unsigned long *) data;
  962. if (count < HEX_DIGITS+1)
  963. return -EINVAL;
  964. return sprintf (page, "%08lxn", *mask);
  965. }
  967. static int prof_cpu_mask_write_proc (struct file *file, const char *buffer,
  968. unsigned long count, void *data)
  969. {
  970. unsigned long *mask = (unsigned long *) data, full_count = count, err;
  971. unsigned long new_value;
  973. err = parse_hex_value(buffer, count, &new_value);
  974. if (err)
  975. return err;
  977. *mask = new_value;
  978. return full_count;
  979. }
  981. #define MAX_NAMELEN 10
  983. static void register_irq_proc (unsigned int irq)
  984. {
  985. struct proc_dir_entry *entry;
  986. char name [MAX_NAMELEN];
  988. if (!root_irq_dir || (irq_desc[irq].handler == NULL))
  989. return;
  991. memset(name, 0, MAX_NAMELEN);
  992. sprintf(name, "%d", irq);
  994. /* create /proc/irq/1234 */
  995. irq_dir[irq] = proc_mkdir(name, root_irq_dir);
  997. /* create /proc/irq/1234/smp_affinity */
  998. entry = create_proc_entry("smp_affinity", 0600, irq_dir[irq]);
  1000. entry->nlink = 1;
  1001. entry->data = (void *)irq;
  1002. entry->read_proc = irq_affinity_read_proc;
  1003. entry->write_proc = irq_affinity_write_proc;
  1005. smp_affinity_entry[irq] = entry;
  1006. }
  1008. unsigned long prof_cpu_mask = -1;
  1010. void init_irq_proc (void)
  1011. {
  1012. struct proc_dir_entry *entry;
  1013. int i;
  1015. /* create /proc/irq */
  1016. root_irq_dir = proc_mkdir("irq", 0);
  1018. /* create /proc/irq/prof_cpu_mask */
  1019. entry = create_proc_entry("prof_cpu_mask", 0600, root_irq_dir);
  1021. entry->nlink = 1;
  1022. entry->data = (void *)&prof_cpu_mask;
  1023. entry->read_proc = prof_cpu_mask_read_proc;
  1024. entry->write_proc = prof_cpu_mask_write_proc;
  1026. /*
  1027.  * Create entries for all existing IRQs.
  1028.  */
  1029. for (i = 0; i < NR_IRQS; i++) {
  1030. if (irq_desc[i].handler == NULL)
  1031. continue;
  1032. register_irq_proc(i);
  1033. }
  1034. }
  1036. void no_action(int irq, void *dev, struct pt_regs *regs)
  1037. {
  1038. }