fiq.c 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182
  1. /*
  2. * linux/arch/arm/kernel/fiq.c
  3. *
  4. * Copyright (C) 1998 Russell King
  5. * Copyright (C) 1998, 1999 Phil Blundell
  6. *
  7. * FIQ support written by Philip Blundell <philb@gnu.org>, 1998.
  8. *
  9. * FIQ support re-written by Russell King to be more generic
  10. *
  11. * We now properly support a method by which the FIQ handlers can
  12. * be stacked onto the vector. We still do not support sharing
  13. * the FIQ vector itself.
  14. *
  15. * Operation is as follows:
  16. * 1. Owner A claims FIQ:
  17. * - default_fiq relinquishes control.
  18. * 2. Owner A:
  19. * - inserts code.
  20. * - sets any registers,
  21. * - enables FIQ.
  22. * 3. Owner B claims FIQ:
  23. * - if owner A has a relinquish function.
  24. * - disable FIQs.
  25. * - saves any registers.
  26. * - returns zero.
  27. * 4. Owner B:
  28. * - inserts code.
  29. * - sets any registers,
  30. * - enables FIQ.
  31. * 5. Owner B releases FIQ:
  32. * - Owner A is asked to reacquire FIQ:
  33. * - inserts code.
  34. * - restores saved registers.
  35. * - enables FIQ.
  36. * 6. Goto 3
  37. */
  38. #include <linux/module.h>
  39. #include <linux/kernel.h>
  40. #include <linux/init.h>
  41. #include <linux/interrupt.h>
  42. #include <linux/seq_file.h>
  43. #include <asm/cacheflush.h>
  44. #include <asm/fiq.h>
  45. #include <asm/irq.h>
  46. #include <asm/system.h>
  47. #include <asm/uaccess.h>
  48. static unsigned long no_fiq_insn;
  49. /* Default reacquire function
  50. * - we always relinquish FIQ control
  51. * - we always reacquire FIQ control
  52. */
  53. static int fiq_def_op(void *ref, int relinquish)
  54. {
  55. if (!relinquish)
  56. set_fiq_handler(&no_fiq_insn, sizeof(no_fiq_insn));
  57. return 0;
  58. }
  59. static struct fiq_handler default_owner = {
  60. .name = "default",
  61. .fiq_op = fiq_def_op,
  62. };
  63. static struct fiq_handler *current_fiq = &default_owner;
  64. int show_fiq_list(struct seq_file *p, void *v)
  65. {
  66. if (current_fiq != &default_owner)
  67. seq_printf(p, "FIQ: %s\n", current_fiq->name);
  68. return 0;
  69. }
  70. void set_fiq_handler(void *start, unsigned int length)
  71. {
  72. memcpy((void *)0xffff001c, start, length);
  73. flush_icache_range(0xffff001c, 0xffff001c + length);
  74. if (!vectors_high())
  75. flush_icache_range(0x1c, 0x1c + length);
  76. }
  77. /*
  78. * Taking an interrupt in FIQ mode is death, so both these functions
  79. * disable irqs for the duration. Note - these functions are almost
  80. * entirely coded in assembly.
  81. */
  82. void __attribute__((naked)) set_fiq_regs(struct pt_regs *regs)
  83. {
  84. register unsigned long tmp;
  85. asm volatile (
  86. "mov ip, sp\n\
  87. stmfd sp!, {fp, ip, lr, pc}\n\
  88. sub fp, ip, #4\n\
  89. mrs %0, cpsr\n\
  90. msr cpsr_c, %2 @ select FIQ mode\n\
  91. mov r0, r0\n\
  92. ldmia %1, {r8 - r14}\n\
  93. msr cpsr_c, %0 @ return to SVC mode\n\
  94. mov r0, r0\n\
  95. ldmfd sp, {fp, sp, pc}"
  96. : "=&r" (tmp)
  97. : "r" (&regs->ARM_r8), "I" (PSR_I_BIT | PSR_F_BIT | FIQ_MODE));
  98. }
  99. void __attribute__((naked)) get_fiq_regs(struct pt_regs *regs)
  100. {
  101. register unsigned long tmp;
  102. asm volatile (
  103. "mov ip, sp\n\
  104. stmfd sp!, {fp, ip, lr, pc}\n\
  105. sub fp, ip, #4\n\
  106. mrs %0, cpsr\n\
  107. msr cpsr_c, %2 @ select FIQ mode\n\
  108. mov r0, r0\n\
  109. stmia %1, {r8 - r14}\n\
  110. msr cpsr_c, %0 @ return to SVC mode\n\
  111. mov r0, r0\n\
  112. ldmfd sp, {fp, sp, pc}"
  113. : "=&r" (tmp)
  114. : "r" (&regs->ARM_r8), "I" (PSR_I_BIT | PSR_F_BIT | FIQ_MODE));
  115. }
  116. int claim_fiq(struct fiq_handler *f)
  117. {
  118. int ret = 0;
  119. if (current_fiq) {
  120. ret = -EBUSY;
  121. if (current_fiq->fiq_op != NULL)
  122. ret = current_fiq->fiq_op(current_fiq->dev_id, 1);
  123. }
  124. if (!ret) {
  125. f->next = current_fiq;
  126. current_fiq = f;
  127. }
  128. return ret;
  129. }
  130. void release_fiq(struct fiq_handler *f)
  131. {
  132. if (current_fiq != f) {
  133. printk(KERN_ERR "%s FIQ trying to release %s FIQ\n",
  134. f->name, current_fiq->name);
  135. dump_stack();
  136. return;
  137. }
  138. do
  139. current_fiq = current_fiq->next;
  140. while (current_fiq->fiq_op(current_fiq->dev_id, 0));
  141. }
  142. void enable_fiq(int fiq)
  143. {
  144. enable_irq(fiq + FIQ_START);
  145. }
  146. void disable_fiq(int fiq)
  147. {
  148. disable_irq(fiq + FIQ_START);
  149. }
  150. EXPORT_SYMBOL(set_fiq_handler);
  151. EXPORT_SYMBOL(set_fiq_regs);
  152. EXPORT_SYMBOL(get_fiq_regs);
  153. EXPORT_SYMBOL(claim_fiq);
  154. EXPORT_SYMBOL(release_fiq);
  155. EXPORT_SYMBOL(enable_fiq);
  156. EXPORT_SYMBOL(disable_fiq);
  157. void __init init_FIQ(void)
  158. {
  159. no_fiq_insn = *(unsigned long *)0xffff001c;
  160. }