lapic.c 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184
  1. /* Local APIC driver. The MMIO window must already be mapped by smp.c. */
  2. #include "lapic.h"
  3. #include "timer.h"
  4. #define LAPIC_ID 0x020
  5. #define LAPIC_TPR 0x080
  6. #define LAPIC_EOI 0x0B0
  7. #define LAPIC_SVR 0x0F0
  8. #define LAPIC_ICR_LO 0x300
  9. #define LAPIC_ICR_HI 0x310
  10. #define LAPIC_LVT_TIMER 0x320
  11. #define LAPIC_LVT_LINT0 0x350
  12. #define LAPIC_LVT_LINT1 0x360
  13. #define LAPIC_TIMER_INIT 0x380
  14. #define LAPIC_TIMER_CUR 0x390
  15. #define LAPIC_TIMER_DIV 0x3E0
  16. #define IA32_APIC_BASE_MSR 0x1B
  17. static volatile unsigned int *lapic_mmio;
  18. static unsigned int lapic_phys;
  19. static inline unsigned int lapic_read(unsigned int off)
  20. {
  21. return lapic_mmio[off / 4];
  22. }
  23. static inline void lapic_write(unsigned int off, unsigned int value)
  24. {
  25. lapic_mmio[off / 4] = value;
  26. }
  27. static inline unsigned long long rdmsr(unsigned int msr)
  28. {
  29. unsigned int lo, hi;
  30. __asm__ volatile ("rdmsr" : "=a"(lo), "=d"(hi) : "c"(msr));
  31. return ((unsigned long long)hi << 32) | lo;
  32. }
  33. static inline void wrmsr(unsigned int msr, unsigned long long value)
  34. {
  35. unsigned int lo = (unsigned int)value;
  36. unsigned int hi = (unsigned int)(value >> 32);
  37. __asm__ volatile ("wrmsr" : : "c"(msr), "a"(lo), "d"(hi));
  38. }
  39. void lapic_set_base(unsigned int base)
  40. {
  41. lapic_phys = base;
  42. lapic_mmio = (volatile unsigned int *)base;
  43. }
  44. unsigned int lapic_base(void)
  45. {
  46. return lapic_phys;
  47. }
  48. static void lapic_enable(void)
  49. {
  50. unsigned long long msr = rdmsr(IA32_APIC_BASE_MSR);
  51. unsigned int base = (unsigned int)(msr & 0xFFFFF000u);
  52. unsigned int keep = (unsigned int)(msr & 0x100u); /* BSP bit */
  53. if (base != lapic_phys) {
  54. msr = (msr & ~0xFFFFF000ull) | lapic_phys;
  55. wrmsr(IA32_APIC_BASE_MSR, msr);
  56. }
  57. /* Keep the BSP bit, clear x2APIC (we drive the xAPIC MMIO window), and
  58. * set the global enable bit. */
  59. msr = (msr & ~0xF00ull) | keep | 0x800ull;
  60. wrmsr(IA32_APIC_BASE_MSR, msr);
  61. }
  62. static int lapic_wait_icr(void)
  63. {
  64. unsigned int n;
  65. for (n = 0; n < 1000000u; n++) {
  66. if (!(lapic_read(LAPIC_ICR_LO) & 0x1000u))
  67. return 1;
  68. }
  69. return 0;
  70. }
  71. void lapic_eoi(void)
  72. {
  73. if (lapic_mmio)
  74. lapic_write(LAPIC_EOI, 0);
  75. }
  76. unsigned int lapic_id(void)
  77. {
  78. return lapic_mmio ? (lapic_read(LAPIC_ID) >> 24) : 0xFFFFFFFFu;
  79. }
  80. int lapic_init_bsp(void)
  81. {
  82. if (!lapic_mmio)
  83. return 0;
  84. lapic_enable();
  85. lapic_write(LAPIC_TPR, 0);
  86. /* Spurious vector: the handler must not send a PIC EOI. */
  87. lapic_write(LAPIC_SVR, 0x1FF);
  88. /* Keep the 8259 PIC on LINT0 (ExtINT); LINT1 stays NMI. */
  89. lapic_write(LAPIC_LVT_LINT0, 0x700);
  90. lapic_write(LAPIC_LVT_LINT1, 0x400);
  91. lapic_timer_stop();
  92. return 1;
  93. }
  94. int lapic_init_ap(void)
  95. {
  96. if (!lapic_mmio)
  97. return 0;
  98. lapic_enable();
  99. lapic_write(LAPIC_TPR, 0);
  100. lapic_write(LAPIC_SVR, 0x1FF);
  101. lapic_write(LAPIC_LVT_LINT0, 0x10000); /* masked */
  102. lapic_write(LAPIC_LVT_LINT1, 0x10000);
  103. lapic_timer_stop();
  104. return 1;
  105. }
  106. void lapic_send_ipi(unsigned int apic_id, unsigned int vector)
  107. {
  108. if (!lapic_mmio)
  109. return;
  110. lapic_wait_icr();
  111. lapic_write(LAPIC_ICR_HI, (apic_id & 0xFFu) << 24);
  112. lapic_write(LAPIC_ICR_LO, (vector & 0xFFu) | 0x00000000u);
  113. lapic_wait_icr();
  114. }
  115. void lapic_send_init(unsigned int apic_id)
  116. {
  117. if (!lapic_mmio)
  118. return;
  119. lapic_wait_icr();
  120. lapic_write(LAPIC_ICR_HI, (apic_id & 0xFFu) << 24);
  121. /* delivery mode INIT (5), level assert. */
  122. lapic_write(LAPIC_ICR_LO, 0x00004500u);
  123. lapic_wait_icr();
  124. }
  125. void lapic_send_sipi(unsigned int apic_id, unsigned int vector)
  126. {
  127. if (!lapic_mmio)
  128. return;
  129. lapic_wait_icr();
  130. lapic_write(LAPIC_ICR_HI, (apic_id & 0xFFu) << 24);
  131. /* delivery mode startup (6); vector is the real-mode page number. */
  132. lapic_write(LAPIC_ICR_LO, 0x00004600u | (vector & 0xFFu));
  133. lapic_wait_icr();
  134. }
  135. int lapic_timer_start(unsigned int vector)
  136. {
  137. unsigned int t0, count, per_ms;
  138. if (!lapic_mmio)
  139. return 0;
  140. lapic_write(LAPIC_TIMER_DIV, 0x3); /* divide by 16 */
  141. lapic_write(LAPIC_LVT_TIMER, 0x10000); /* masked while calibrating */
  142. lapic_write(LAPIC_TIMER_INIT, 0xFFFFFFFFu);
  143. t0 = get_ticks_ms();
  144. while ((unsigned int)(get_ticks_ms() - t0) < 10)
  145. __asm__ volatile ("pause");
  146. count = lapic_read(LAPIC_TIMER_CUR);
  147. per_ms = (0xFFFFFFFFu - count) / 10u;
  148. if (per_ms == 0)
  149. return 0;
  150. lapic_write(LAPIC_LVT_TIMER, (vector & 0xFFu) | 0x00020000u);
  151. lapic_write(LAPIC_TIMER_INIT, per_ms);
  152. return 1;
  153. }
  154. void lapic_timer_stop(void)
  155. {
  156. if (lapic_mmio)
  157. lapic_write(LAPIC_LVT_TIMER, 0x10000);
  158. }