irq.h
上传用户:jlfgdled
上传日期:2013-04-10
资源大小:33168k
文件大小:5k
源码类别:

Linux/Unix编程

开发平台:

Unix_Linux

  1. /*
  2.  * include/asm-arm/arch-cl7500/irq.h
  3.  *
  4.  * Copyright (C) 1996 Russell King
  5.  * Copyright (C) 1999, 2001 Nexus Electronics Ltd.
  6.  *
  7.  * Changelog:
  8.  *   10-10-1996 RMK Brought up to date with arch-sa110eval
  9.  *   22-08-1998 RMK Restructured IRQ routines
  10.  *   11-08-1999 PJB Created ARM7500 version, derived from RiscPC code
  11.  */
  12. #include <asm/hardware/iomd.h>
  13. #include <asm/io.h>
  14. static inline int fixup_irq(unsigned int irq)
  15. {
  16. if (irq == IRQ_ISA) {
  17. int isabits = *((volatile unsigned int *)0xe002b700);
  18. if (isabits == 0) {
  19. printk("Spurious ISA IRQ!n");
  20. return irq;
  21. }
  22. irq = IRQ_ISA_BASE;
  23. while (!(isabits & 1)) {
  24. irq++;
  25. isabits >>= 1;
  26. }
  27. }
  28. return irq;
  29. }
  30. static void cl7500_mask_irq_ack_a(unsigned int irq)
  31. {
  32. unsigned int val, mask;
  33. mask = 1 << irq;
  34. val = iomd_readb(IOMD_IRQMASKA);
  35. iomd_writeb(val & ~mask, IOMD_IRQMASKA);
  36. iomd_writeb(mask, IOMD_IRQCLRA);
  37. }
  38. static void cl7500_mask_irq_a(unsigned int irq)
  39. {
  40. unsigned int val, mask;
  41. mask = 1 << irq;
  42. val = iomd_readb(IOMD_IRQMASKA);
  43. iomd_writeb(val & ~mask, IOMD_IRQMASKA);
  44. }
  45. static void cl7500_unmask_irq_a(unsigned int irq)
  46. {
  47. unsigned int val, mask;
  48. mask = 1 << irq;
  49. val = iomd_readb(IOMD_IRQMASKA);
  50. iomd_writeb(val | mask, IOMD_IRQMASKA);
  51. }
  52. static void cl7500_mask_irq_b(unsigned int irq)
  53. {
  54. unsigned int val, mask;
  55. mask = 1 << (irq & 7);
  56. val = iomd_readb(IOMD_IRQMASKB);
  57. iomd_writeb(val & ~mask, IOMD_IRQMASKB);
  58. }
  59. static void cl7500_unmask_irq_b(unsigned int irq)
  60. {
  61. unsigned int val, mask;
  62. mask = 1 << (irq & 7);
  63. val = iomd_readb(IOMD_IRQMASKB);
  64. iomd_writeb(val | mask, IOMD_IRQMASKB);
  65. }
  66. static void cl7500_mask_irq_c(unsigned int irq)
  67. {
  68. unsigned int val, mask;
  69. mask = 1 << (irq & 7);
  70. val = iomd_readb(IOMD_IRQMASKC);
  71. iomd_writeb(val & ~mask, IOMD_IRQMASKC);
  72. }
  73. static void cl7500_unmask_irq_c(unsigned int irq)
  74. {
  75. unsigned int val, mask;
  76. mask = 1 << (irq & 7);
  77. val = iomd_readb(IOMD_IRQMASKC);
  78. iomd_writeb(val | mask, IOMD_IRQMASKC);
  79. }
  80. static void cl7500_mask_irq_d(unsigned int irq)
  81. {
  82. unsigned int val, mask;
  83. mask = 1 << (irq & 7);
  84. val = iomd_readb(IOMD_IRQMASKD);
  85. iomd_writeb(val & ~mask, IOMD_IRQMASKD);
  86. }
  87. static void cl7500_unmask_irq_d(unsigned int irq)
  88. {
  89. unsigned int val, mask;
  90. mask = 1 << (irq & 7);
  91. val = iomd_readb(IOMD_IRQMASKD);
  92. iomd_writeb(val | mask, IOMD_IRQMASKD);
  93. }
  94. static void cl7500_mask_irq_dma(unsigned int irq)
  95. {
  96. unsigned int val, mask;
  97. mask = 1 << (irq & 7);
  98. val = iomd_readb(IOMD_DMAMASK);
  99. iomd_writeb(val & ~mask, IOMD_DMAMASK);
  100. }
  101. static void cl7500_unmask_irq_dma(unsigned int irq)
  102. {
  103. unsigned int val, mask;
  104. mask = 1 << (irq & 7);
  105. val = iomd_readb(IOMD_DMAMASK);
  106. iomd_writeb(val | mask, IOMD_DMAMASK);
  107. }
  108. static void cl7500_mask_irq_fiq(unsigned int irq)
  109. {
  110. unsigned int val, mask;
  111. mask = 1 << (irq & 7);
  112. val = iomd_readb(IOMD_FIQMASK);
  113. iomd_writeb(val & ~mask, IOMD_FIQMASK);
  114. }
  115. static void cl7500_unmask_irq_fiq(unsigned int irq)
  116. {
  117. unsigned int val, mask;
  118. mask = 1 << (irq & 7);
  119. val = iomd_readb(IOMD_FIQMASK);
  120. iomd_writeb(val | mask, IOMD_FIQMASK);
  121. }
  122. static void no_action(int cpl, void *dev_id, struct pt_regs *regs)
  123. {
  124. }
  125. static struct irqaction irq_isa = { no_action, 0, 0, "isa", NULL, NULL };
  126. static __inline__ void irq_init_irq(void)
  127. {
  128. int irq;
  129. iomd_writeb(0, IOMD_IRQMASKA);
  130. iomd_writeb(0, IOMD_IRQMASKB);
  131. iomd_writeb(0, IOMD_FIQMASK);
  132. iomd_writeb(0, IOMD_DMAMASK);
  133. for (irq = 0; irq < NR_IRQS; irq++) {
  134. switch (irq) {
  135. case 0 ... 6:
  136. irq_desc[irq].probe_ok = 1;
  137. case 7:
  138. irq_desc[irq].valid    = 1;
  139. irq_desc[irq].mask_ack = cl7500_mask_irq_ack_a;
  140. irq_desc[irq].mask     = cl7500_mask_irq_a;
  141. irq_desc[irq].unmask   = cl7500_unmask_irq_a;
  142. break;
  143. case 9 ... 15:
  144. irq_desc[irq].probe_ok = 1;
  145. case 8:
  146. irq_desc[irq].valid    = 1;
  147. irq_desc[irq].mask_ack = cl7500_mask_irq_b;
  148. irq_desc[irq].mask     = cl7500_mask_irq_b;
  149. irq_desc[irq].unmask   = cl7500_unmask_irq_b;
  150. break;
  151. case 16 ... 22:
  152. irq_desc[irq].valid    = 1;
  153. irq_desc[irq].mask_ack = cl7500_mask_irq_dma;
  154. irq_desc[irq].mask     = cl7500_mask_irq_dma;
  155. irq_desc[irq].unmask   = cl7500_unmask_irq_dma;
  156. break;
  157. case 24 ... 31:
  158. irq_desc[irq].valid    = 1;
  159. irq_desc[irq].mask_ack = cl7500_mask_irq_c;
  160. irq_desc[irq].mask     = cl7500_mask_irq_c;
  161. irq_desc[irq].unmask   = cl7500_unmask_irq_c;
  162. break;
  163. case 40 ... 47:
  164. irq_desc[irq].valid    = 1;
  165. irq_desc[irq].mask_ack = cl7500_mask_irq_d;
  166. irq_desc[irq].mask     = cl7500_mask_irq_d;
  167. irq_desc[irq].unmask   = cl7500_unmask_irq_d;
  168. break;
  169. case 48 ... 55:
  170. irq_desc[irq].valid      = 1;
  171. irq_desc[irq].probe_ok   = 1;
  172. irq_desc[irq].mask_ack   = no_action;
  173. irq_desc[irq].mask       = no_action;
  174. irq_desc[irq].unmask     = no_action;
  175. break;
  176. case 64 ... 72:
  177. irq_desc[irq].valid    = 1;
  178. irq_desc[irq].mask_ack = cl7500_mask_irq_fiq;
  179. irq_desc[irq].mask     = cl7500_mask_irq_fiq;
  180. irq_desc[irq].unmask   = cl7500_unmask_irq_fiq;
  181. break;
  182. }
  183. }
  184. setup_arm_irq(IRQ_ISA, &irq_isa);
  185. }