i386 - Get completely rid of APIC_IO
[dragonfly.git] / sys / platform / pc32 / apic / mpapic.c
1 /*
2  * Copyright (c) 1996, by Steve Passe
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. The name of the developer may NOT be used to endorse or promote products
11  *    derived from this software without specific prior written permission.
12  *
13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23  * SUCH DAMAGE.
24  *
25  * $FreeBSD: src/sys/i386/i386/mpapic.c,v 1.37.2.7 2003/01/25 02:31:47 peter Exp $
26  * $DragonFly: src/sys/platform/pc32/apic/mpapic.c,v 1.22 2008/04/20 13:44:26 swildner Exp $
27  */
28
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/kernel.h>
32 #include <machine/globaldata.h>
33 #include <machine/smp.h>
34 #include <machine/cputypes.h>
35 #include <machine/md_var.h>
36 #include <machine/pmap.h>
37 #include <machine_base/apic/mpapic.h>
38 #include <machine/segments.h>
39 #include <sys/thread2.h>
40
41 #include <machine_base/isa/intr_machdep.h>      /* Xspuriousint() */
42
43 /* XXX */
44 extern pt_entry_t *SMPpt;
45
46 /* EISA Edge/Level trigger control registers */
47 #define ELCR0   0x4d0                   /* eisa irq 0-7 */
48 #define ELCR1   0x4d1                   /* eisa irq 8-15 */
49
50 static void     lapic_timer_calibrate(void);
51 static void     lapic_timer_set_divisor(int);
52 static void     lapic_timer_fixup_handler(void *);
53 static void     lapic_timer_restart_handler(void *);
54
55 void            lapic_timer_process(void);
56 void            lapic_timer_process_frame(struct intrframe *);
57
58 static int      lapic_timer_enable = 1;
59 TUNABLE_INT("hw.lapic_timer_enable", &lapic_timer_enable);
60
61 static void     lapic_timer_intr_reload(struct cputimer_intr *, sysclock_t);
62 static void     lapic_timer_intr_enable(struct cputimer_intr *);
63 static void     lapic_timer_intr_restart(struct cputimer_intr *);
64 static void     lapic_timer_intr_pmfixup(struct cputimer_intr *);
65
66 static struct cputimer_intr lapic_cputimer_intr = {
67         .freq = 0,
68         .reload = lapic_timer_intr_reload,
69         .enable = lapic_timer_intr_enable,
70         .config = cputimer_intr_default_config,
71         .restart = lapic_timer_intr_restart,
72         .pmfixup = lapic_timer_intr_pmfixup,
73         .initclock = cputimer_intr_default_initclock,
74         .next = SLIST_ENTRY_INITIALIZER,
75         .name = "lapic",
76         .type = CPUTIMER_INTR_LAPIC,
77         .prio = CPUTIMER_INTR_PRIO_LAPIC,
78         .caps = CPUTIMER_INTR_CAP_NONE
79 };
80
81 /*
82  * pointers to pmapped apic hardware.
83  */
84
85 volatile ioapic_t       **ioapic;
86
87 static int              lapic_timer_divisor_idx = -1;
88 static const uint32_t   lapic_timer_divisors[] = {
89         APIC_TDCR_2,    APIC_TDCR_4,    APIC_TDCR_8,    APIC_TDCR_16,
90         APIC_TDCR_32,   APIC_TDCR_64,   APIC_TDCR_128,  APIC_TDCR_1
91 };
92 #define APIC_TIMER_NDIVISORS \
93         (int)(sizeof(lapic_timer_divisors) / sizeof(lapic_timer_divisors[0]))
94
95
96 /*
97  * Enable APIC, configure interrupts.
98  */
99 void
100 apic_initialize(boolean_t bsp)
101 {
102         uint32_t timer;
103         u_int   temp;
104
105         /*
106          * setup LVT1 as ExtINT on the BSP.  This is theoretically an
107          * aggregate interrupt input from the 8259.  The INTA cycle
108          * will be routed to the external controller (the 8259) which
109          * is expected to supply the vector.
110          *
111          * Must be setup edge triggered, active high.
112          *
113          * Disable LVT1 on the APs.  It doesn't matter what delivery
114          * mode we use because we leave it masked.
115          */
116         temp = lapic.lvt_lint0;
117         temp &= ~(APIC_LVT_MASKED | APIC_LVT_TRIG_MASK | 
118                   APIC_LVT_POLARITY_MASK | APIC_LVT_DM_MASK);
119         if (mycpu->gd_cpuid == 0)
120                 temp |= APIC_LVT_DM_EXTINT;
121         else
122                 temp |= APIC_LVT_DM_FIXED | APIC_LVT_MASKED;
123         lapic.lvt_lint0 = temp;
124
125         /*
126          * setup LVT2 as NMI, masked till later.  Edge trigger, active high.
127          */
128         temp = lapic.lvt_lint1;
129         temp &= ~(APIC_LVT_MASKED | APIC_LVT_TRIG_MASK | 
130                   APIC_LVT_POLARITY_MASK | APIC_LVT_DM_MASK);
131         temp |= APIC_LVT_MASKED | APIC_LVT_DM_NMI;
132         lapic.lvt_lint1 = temp;
133
134         /*
135          * Mask the apic error interrupt, apic performance counter
136          * interrupt.
137          */
138         lapic.lvt_error = lapic.lvt_error | APIC_LVT_MASKED;
139         lapic.lvt_pcint = lapic.lvt_pcint | APIC_LVT_MASKED;
140
141         /* Set apic timer vector and mask the apic timer interrupt. */
142         timer = lapic.lvt_timer;
143         timer &= ~APIC_LVTT_VECTOR;
144         timer |= XTIMER_OFFSET;
145         timer |= APIC_LVTT_MASKED;
146         lapic.lvt_timer = timer;
147
148         /*
149          * Set the Task Priority Register as needed.   At the moment allow
150          * interrupts on all cpus (the APs will remain CLId until they are
151          * ready to deal).  We could disable all but IPIs by setting
152          * temp |= TPR_IPI_ONLY for cpu != 0.
153          */
154         temp = lapic.tpr;
155         temp &= ~APIC_TPR_PRIO;         /* clear priority field */
156 #ifdef SMP /* APIC-IO */
157 if (!apic_io_enable) {
158 #endif
159         /*
160          * If we are NOT running the IO APICs, the LAPIC will only be used
161          * for IPIs.  Set the TPR to prevent any unintentional interrupts.
162          */
163         temp |= TPR_IPI_ONLY;
164 #ifdef SMP /* APIC-IO */
165 }
166 #endif
167
168         lapic.tpr = temp;
169
170         /* 
171          * enable the local APIC 
172          */
173         temp = lapic.svr;
174         temp |= APIC_SVR_ENABLE;        /* enable the APIC */
175         temp &= ~APIC_SVR_FOCUS_DISABLE; /* enable lopri focus processor */
176
177         /*
178          * Set the spurious interrupt vector.  The low 4 bits of the vector
179          * must be 1111.
180          */
181         if ((XSPURIOUSINT_OFFSET & 0x0F) != 0x0F)
182                 panic("bad XSPURIOUSINT_OFFSET: 0x%08x", XSPURIOUSINT_OFFSET);
183         temp &= ~APIC_SVR_VECTOR;
184         temp |= XSPURIOUSINT_OFFSET;
185
186         lapic.svr = temp;
187
188         /*
189          * Pump out a few EOIs to clean out interrupts that got through
190          * before we were able to set the TPR.
191          */
192         lapic.eoi = 0;
193         lapic.eoi = 0;
194         lapic.eoi = 0;
195
196         if (bsp) {
197                 lapic_timer_calibrate();
198                 if (lapic_timer_enable) {
199                         cputimer_intr_register(&lapic_cputimer_intr);
200                         cputimer_intr_select(&lapic_cputimer_intr, 0);
201                 }
202         } else {
203                 lapic_timer_set_divisor(lapic_timer_divisor_idx);
204         }
205
206         if (bootverbose)
207                 apic_dump("apic_initialize()");
208 }
209
210
211 static void
212 lapic_timer_set_divisor(int divisor_idx)
213 {
214         KKASSERT(divisor_idx >= 0 && divisor_idx < APIC_TIMER_NDIVISORS);
215         lapic.dcr_timer = lapic_timer_divisors[divisor_idx];
216 }
217
218 static void
219 lapic_timer_oneshot(u_int count)
220 {
221         uint32_t value;
222
223         value = lapic.lvt_timer;
224         value &= ~APIC_LVTT_PERIODIC;
225         lapic.lvt_timer = value;
226         lapic.icr_timer = count;
227 }
228
229 static void
230 lapic_timer_oneshot_quick(u_int count)
231 {
232         lapic.icr_timer = count;
233 }
234
235 static void
236 lapic_timer_calibrate(void)
237 {
238         sysclock_t value;
239
240         /* Try to calibrate the local APIC timer. */
241         for (lapic_timer_divisor_idx = 0;
242              lapic_timer_divisor_idx < APIC_TIMER_NDIVISORS;
243              lapic_timer_divisor_idx++) {
244                 lapic_timer_set_divisor(lapic_timer_divisor_idx);
245                 lapic_timer_oneshot(APIC_TIMER_MAX_COUNT);
246                 DELAY(2000000);
247                 value = APIC_TIMER_MAX_COUNT - lapic.ccr_timer;
248                 if (value != APIC_TIMER_MAX_COUNT)
249                         break;
250         }
251         if (lapic_timer_divisor_idx >= APIC_TIMER_NDIVISORS)
252                 panic("lapic: no proper timer divisor?!\n");
253         lapic_cputimer_intr.freq = value / 2;
254
255         kprintf("lapic: divisor index %d, frequency %u Hz\n",
256                 lapic_timer_divisor_idx, lapic_cputimer_intr.freq);
257 }
258
259 static void
260 lapic_timer_process_oncpu(struct globaldata *gd, struct intrframe *frame)
261 {
262         sysclock_t count;
263
264         gd->gd_timer_running = 0;
265
266         count = sys_cputimer->count();
267         if (TAILQ_FIRST(&gd->gd_systimerq) != NULL)
268                 systimer_intr(&count, 0, frame);
269 }
270
271 void
272 lapic_timer_process(void)
273 {
274         lapic_timer_process_oncpu(mycpu, NULL);
275 }
276
277 void
278 lapic_timer_process_frame(struct intrframe *frame)
279 {
280         lapic_timer_process_oncpu(mycpu, frame);
281 }
282
283 static void
284 lapic_timer_intr_reload(struct cputimer_intr *cti, sysclock_t reload)
285 {
286         struct globaldata *gd = mycpu;
287
288         reload = (int64_t)reload * cti->freq / sys_cputimer->freq;
289         if (reload < 2)
290                 reload = 2;
291
292         if (gd->gd_timer_running) {
293                 if (reload < lapic.ccr_timer)
294                         lapic_timer_oneshot_quick(reload);
295         } else {
296                 gd->gd_timer_running = 1;
297                 lapic_timer_oneshot_quick(reload);
298         }
299 }
300
301 static void
302 lapic_timer_intr_enable(struct cputimer_intr *cti __unused)
303 {
304         uint32_t timer;
305
306         timer = lapic.lvt_timer;
307         timer &= ~(APIC_LVTT_MASKED | APIC_LVTT_PERIODIC);
308         lapic.lvt_timer = timer;
309
310         lapic_timer_fixup_handler(NULL);
311 }
312
313 static void
314 lapic_timer_fixup_handler(void *arg)
315 {
316         int *started = arg;
317
318         if (started != NULL)
319                 *started = 0;
320
321         if (cpu_vendor_id == CPU_VENDOR_AMD) {
322                 /*
323                  * Detect the presence of C1E capability mostly on latest
324                  * dual-cores (or future) k8 family.  This feature renders
325                  * the local APIC timer dead, so we disable it by reading
326                  * the Interrupt Pending Message register and clearing both
327                  * C1eOnCmpHalt (bit 28) and SmiOnCmpHalt (bit 27).
328                  * 
329                  * Reference:
330                  *   "BIOS and Kernel Developer's Guide for AMD NPT
331                  *    Family 0Fh Processors"
332                  *   #32559 revision 3.00
333                  */
334                 if ((cpu_id & 0x00000f00) == 0x00000f00 &&
335                     (cpu_id & 0x0fff0000) >= 0x00040000) {
336                         uint64_t msr;
337
338                         msr = rdmsr(0xc0010055);
339                         if (msr & 0x18000000) {
340                                 struct globaldata *gd = mycpu;
341
342                                 kprintf("cpu%d: AMD C1E detected\n",
343                                         gd->gd_cpuid);
344                                 wrmsr(0xc0010055, msr & ~0x18000000ULL);
345
346                                 /*
347                                  * We are kinda stalled;
348                                  * kick start again.
349                                  */
350                                 gd->gd_timer_running = 1;
351                                 lapic_timer_oneshot_quick(2);
352
353                                 if (started != NULL)
354                                         *started = 1;
355                         }
356                 }
357         }
358 }
359
360 static void
361 lapic_timer_restart_handler(void *dummy __unused)
362 {
363         int started;
364
365         lapic_timer_fixup_handler(&started);
366         if (!started) {
367                 struct globaldata *gd = mycpu;
368
369                 gd->gd_timer_running = 1;
370                 lapic_timer_oneshot_quick(2);
371         }
372 }
373
374 /*
375  * This function is called only by ACPI-CA code currently:
376  * - AMD C1E fixup.  AMD C1E only seems to happen after ACPI
377  *   module controls PM.  So once ACPI-CA is attached, we try
378  *   to apply the fixup to prevent LAPIC timer from hanging.
379  */
380 static void
381 lapic_timer_intr_pmfixup(struct cputimer_intr *cti __unused)
382 {
383         lwkt_send_ipiq_mask(smp_active_mask,
384                             lapic_timer_fixup_handler, NULL);
385 }
386
387 static void
388 lapic_timer_intr_restart(struct cputimer_intr *cti __unused)
389 {
390         lwkt_send_ipiq_mask(smp_active_mask, lapic_timer_restart_handler, NULL);
391 }
392
393
394 /*
395  * dump contents of local APIC registers
396  */
397 void
398 apic_dump(char* str)
399 {
400         kprintf("SMP: CPU%d %s:\n", mycpu->gd_cpuid, str);
401         kprintf("     lint0: 0x%08x lint1: 0x%08x TPR: 0x%08x SVR: 0x%08x\n",
402                 lapic.lvt_lint0, lapic.lvt_lint1, lapic.tpr, lapic.svr);
403 }
404
405
406 #ifdef SMP /* APIC-IO */
407
408 /*
409  * IO APIC code,
410  */
411
412 #define IOAPIC_ISA_INTS         16
413 #define REDIRCNT_IOAPIC(A) \
414             ((int)((io_apic_versions[(A)] & IOART_VER_MAXREDIR) >> MAXREDIRSHIFT) + 1)
415
416 static int trigger (int apic, int pin, u_int32_t * flags);
417 static void polarity (int apic, int pin, u_int32_t * flags, int level);
418
419 #define DEFAULT_FLAGS           \
420         ((u_int32_t)            \
421          (IOART_INTMSET |       \
422           IOART_DESTPHY |       \
423           IOART_DELLOPRI))
424
425 #define DEFAULT_ISA_FLAGS       \
426         ((u_int32_t)            \
427          (IOART_INTMSET |       \
428           IOART_TRGREDG |       \
429           IOART_INTAHI |        \
430           IOART_DESTPHY |       \
431           IOART_DELLOPRI))
432
433 void
434 io_apic_set_id(int apic, int id)
435 {
436         u_int32_t ux;
437         
438         ux = io_apic_read(apic, IOAPIC_ID);     /* get current contents */
439         if (((ux & APIC_ID_MASK) >> 24) != id) {
440                 kprintf("Changing APIC ID for IO APIC #%d"
441                        " from %d to %d on chip\n",
442                        apic, ((ux & APIC_ID_MASK) >> 24), id);
443                 ux &= ~APIC_ID_MASK;    /* clear the ID field */
444                 ux |= (id << 24);
445                 io_apic_write(apic, IOAPIC_ID, ux);     /* write new value */
446                 ux = io_apic_read(apic, IOAPIC_ID);     /* re-read && test */
447                 if (((ux & APIC_ID_MASK) >> 24) != id)
448                         panic("can't control IO APIC #%d ID, reg: 0x%08x",
449                               apic, ux);
450         }
451 }
452
453
454 int
455 io_apic_get_id(int apic)
456 {
457   return (io_apic_read(apic, IOAPIC_ID) & APIC_ID_MASK) >> 24;
458 }
459   
460
461
462 /*
463  * Setup the IO APIC.
464  */
465 void
466 io_apic_setup_intpin(int apic, int pin)
467 {
468         int bus, bustype, irq;
469         u_char          select;         /* the select register is 8 bits */
470         u_int32_t       flags;          /* the window register is 32 bits */
471         u_int32_t       target;         /* the window register is 32 bits */
472         u_int32_t       vector;         /* the window register is 32 bits */
473         int             level;
474         int             cpuid;
475         char            envpath[32];
476
477         select = pin * 2 + IOAPIC_REDTBL0;      /* register */
478
479         /*
480          * Always clear an IO APIC pin before [re]programming it.  This is
481          * particularly important if the pin is set up for a level interrupt
482          * as the IOART_REM_IRR bit might be set.   When we reprogram the
483          * vector any EOI from pending ints on this pin could be lost and
484          * IRR might never get reset.
485          *
486          * To fix this problem, clear the vector and make sure it is 
487          * programmed as an edge interrupt.  This should theoretically
488          * clear IRR so we can later, safely program it as a level 
489          * interrupt.
490          */
491         imen_lock();
492
493         flags = io_apic_read(apic, select) & IOART_RESV;
494         flags |= IOART_INTMSET | IOART_TRGREDG | IOART_INTAHI;
495         flags |= IOART_DESTPHY | IOART_DELFIXED;
496
497         target = io_apic_read(apic, select + 1) & IOART_HI_DEST_RESV;
498         target |= 0;    /* fixed mode cpu mask of 0 - don't deliver anywhere */
499
500         vector = 0;
501
502         io_apic_write(apic, select, flags | vector);
503         io_apic_write(apic, select + 1, target);
504
505         imen_unlock();
506
507         /*
508          * We only deal with vectored interrupts here.  ? documentation is
509          * lacking, I'm guessing an interrupt type of 0 is the 'INT' type,
510          * vs ExTINT, etc.
511          *
512          * This test also catches unconfigured pins.
513          */
514         if (apic_int_type(apic, pin) != 0)
515                 return;
516
517         /*
518          * Leave the pin unprogrammed if it does not correspond to
519          * an IRQ.
520          */
521         irq = apic_irq(apic, pin);
522         if (irq < 0)
523                 return;
524         
525         /* determine the bus type for this pin */
526         bus = apic_src_bus_id(apic, pin);
527         if (bus < 0)
528                 return;
529         bustype = apic_bus_type(bus);
530         
531         if ((bustype == ISA) &&
532             (pin < IOAPIC_ISA_INTS) && 
533             (irq == pin) &&
534             (apic_polarity(apic, pin) == 0x1) &&
535             (apic_trigger(apic, pin) == 0x3)) {
536                 /* 
537                  * A broken BIOS might describe some ISA 
538                  * interrupts as active-high level-triggered.
539                  * Use default ISA flags for those interrupts.
540                  */
541                 flags = DEFAULT_ISA_FLAGS;
542         } else {
543                 /* 
544                  * Program polarity and trigger mode according to 
545                  * interrupt entry.
546                  */
547                 flags = DEFAULT_FLAGS;
548                 level = trigger(apic, pin, &flags);
549                 if (level == 1)
550                         int_to_apicintpin[irq].flags |= IOAPIC_IM_FLAG_LEVEL;
551                 polarity(apic, pin, &flags, level);
552         }
553
554         cpuid = 0;
555         ksnprintf(envpath, sizeof(envpath), "hw.irq.%d.dest", irq);
556         kgetenv_int(envpath, &cpuid);
557
558         /* ncpus may not be available yet */
559         if (cpuid > mp_naps)
560                 cpuid = 0;
561
562         if (bootverbose) {
563                 kprintf("IOAPIC #%d intpin %d -> irq %d (CPU%d)\n",
564                        apic, pin, irq, cpuid);
565         }
566
567         /*
568          * Program the appropriate registers.  This routing may be 
569          * overridden when an interrupt handler for a device is
570          * actually added (see register_int(), which calls through
571          * the MACHINTR ABI to set up an interrupt handler/vector).
572          *
573          * The order in which we must program the two registers for
574          * safety is unclear! XXX
575          */
576         imen_lock();
577
578         vector = IDT_OFFSET + irq;                      /* IDT vec */
579         target = io_apic_read(apic, select + 1) & IOART_HI_DEST_RESV;
580         /* Deliver all interrupts to CPU0 (BSP) */
581         target |= (CPU_TO_ID(cpuid) << IOART_HI_DEST_SHIFT) &
582                   IOART_HI_DEST_MASK;
583         flags |= io_apic_read(apic, select) & IOART_RESV;
584         io_apic_write(apic, select, flags | vector);
585         io_apic_write(apic, select + 1, target);
586
587         imen_unlock();
588 }
589
590 int
591 io_apic_setup(int apic)
592 {
593         int             maxpin;
594         int             pin;
595
596         maxpin = REDIRCNT_IOAPIC(apic);         /* pins in APIC */
597         kprintf("Programming %d pins in IOAPIC #%d\n", maxpin, apic);
598         
599         for (pin = 0; pin < maxpin; ++pin) {
600                 io_apic_setup_intpin(apic, pin);
601         }
602         while (pin < 32) {
603                 if (apic_int_type(apic, pin) >= 0) {
604                         kprintf("Warning: IOAPIC #%d pin %d does not exist,"
605                                 " cannot program!\n", apic, pin);
606                 }
607                 ++pin;
608         }
609
610         /* return GOOD status */
611         return 0;
612 }
613 #undef DEFAULT_ISA_FLAGS
614 #undef DEFAULT_FLAGS
615
616
617 #define DEFAULT_EXTINT_FLAGS    \
618         ((u_int32_t)            \
619          (IOART_INTMSET |       \
620           IOART_TRGREDG |       \
621           IOART_INTAHI |        \
622           IOART_DESTPHY |       \
623           IOART_DELLOPRI))
624
625 /*
626  * XXX this function is only used by 8254 setup
627  * Setup the source of External INTerrupts.
628  */
629 int
630 ext_int_setup(int apic, int intr)
631 {
632         u_char  select;         /* the select register is 8 bits */
633         u_int32_t flags;        /* the window register is 32 bits */
634         u_int32_t target;       /* the window register is 32 bits */
635         u_int32_t vector;       /* the window register is 32 bits */
636         int cpuid;
637         char envpath[32];
638
639         if (apic_int_type(apic, intr) != 3)
640                 return -1;
641
642         cpuid = 0;
643         ksnprintf(envpath, sizeof(envpath), "hw.irq.%d.dest", intr);
644         kgetenv_int(envpath, &cpuid);
645
646         /* ncpus may not be available yet */
647         if (cpuid > mp_naps)
648                 cpuid = 0;
649
650         /* Deliver interrupts to CPU0 (BSP) */
651         target = (CPU_TO_ID(cpuid) << IOART_HI_DEST_SHIFT) &
652                  IOART_HI_DEST_MASK;
653         select = IOAPIC_REDTBL0 + (2 * intr);
654         vector = IDT_OFFSET + intr;
655         flags = DEFAULT_EXTINT_FLAGS;
656
657         io_apic_write(apic, select, flags | vector);
658         io_apic_write(apic, select + 1, target);
659
660         return 0;
661 }
662 #undef DEFAULT_EXTINT_FLAGS
663
664
665 /*
666  * Set the trigger level for an IO APIC pin.
667  */
668 static int
669 trigger(int apic, int pin, u_int32_t * flags)
670 {
671         int     id;
672         int     eirq;
673         int     level;
674         static int intcontrol = -1;
675
676         switch (apic_trigger(apic, pin)) {
677
678         case 0x00:
679                 break;
680
681         case 0x01:
682                 *flags &= ~IOART_TRGRLVL;       /* *flags |= IOART_TRGREDG */
683                 return 0;
684
685         case 0x03:
686                 *flags |= IOART_TRGRLVL;
687                 return 1;
688
689         case -1:
690         default:
691                 goto bad;
692         }
693
694         if ((id = apic_src_bus_id(apic, pin)) == -1)
695                 goto bad;
696
697         switch (apic_bus_type(id)) {
698         case ISA:
699                 *flags &= ~IOART_TRGRLVL;       /* *flags |= IOART_TRGREDG; */
700                 return 0;
701
702         case EISA:
703                 eirq = apic_src_bus_irq(apic, pin);
704
705                 if (eirq < 0 || eirq > 15) {
706                         kprintf("EISA IRQ %d?!?!\n", eirq);
707                         goto bad;
708                 }
709
710                 if (intcontrol == -1) {
711                         intcontrol = inb(ELCR1) << 8;
712                         intcontrol |= inb(ELCR0);
713                         kprintf("EISA INTCONTROL = %08x\n", intcontrol);
714                 }
715
716                 /* Use ELCR settings to determine level or edge mode */
717                 level = (intcontrol >> eirq) & 1;
718
719                 /*
720                  * Note that on older Neptune chipset based systems, any
721                  * pci interrupts often show up here and in the ELCR as well
722                  * as level sensitive interrupts attributed to the EISA bus.
723                  */
724
725                 if (level)
726                         *flags |= IOART_TRGRLVL;
727                 else
728                         *flags &= ~IOART_TRGRLVL;
729
730                 return level;
731
732         case PCI:
733                 *flags |= IOART_TRGRLVL;
734                 return 1;
735
736         case -1:
737         default:
738                 goto bad;
739         }
740
741 bad:
742         panic("bad APIC IO INT flags");
743 }
744
745
746 /*
747  * Set the polarity value for an IO APIC pin.
748  */
749 static void
750 polarity(int apic, int pin, u_int32_t * flags, int level)
751 {
752         int     id;
753
754         switch (apic_polarity(apic, pin)) {
755
756         case 0x00:
757                 break;
758
759         case 0x01:
760                 *flags &= ~IOART_INTALO;        /* *flags |= IOART_INTAHI */
761                 return;
762
763         case 0x03:
764                 *flags |= IOART_INTALO;
765                 return;
766
767         case -1:
768         default:
769                 goto bad;
770         }
771
772         if ((id = apic_src_bus_id(apic, pin)) == -1)
773                 goto bad;
774
775         switch (apic_bus_type(id)) {
776         case ISA:
777                 *flags &= ~IOART_INTALO;        /* *flags |= IOART_INTAHI */
778                 return;
779
780         case EISA:
781                 /* polarity converter always gives active high */
782                 *flags &= ~IOART_INTALO;
783                 return;
784
785         case PCI:
786                 *flags |= IOART_INTALO;
787                 return;
788
789         case -1:
790         default:
791                 goto bad;
792         }
793
794 bad:
795         panic("bad APIC IO INT flags");
796 }
797
798
799 /*
800  * Print contents of unmasked IRQs.
801  */
802 void
803 imen_dump(void)
804 {
805         int x;
806
807         kprintf("SMP: enabled INTs: ");
808         for (x = 0; x < APIC_INTMAPSIZE; ++x) {
809                 if ((int_to_apicintpin[x].flags & IOAPIC_IM_FLAG_MASKED) == 0)
810                         kprintf("%d ", x);
811         }
812         kprintf("\n");
813 }
814
815
816 /*
817  * Inter Processor Interrupt functions.
818  */
819
820 #endif  /* SMP APIC-IO */
821
822 /*
823  * Send APIC IPI 'vector' to 'destType' via 'deliveryMode'.
824  *
825  *  destType is 1 of: APIC_DEST_SELF, APIC_DEST_ALLISELF, APIC_DEST_ALLESELF
826  *  vector is any valid SYSTEM INT vector
827  *  delivery_mode is 1 of: APIC_DELMODE_FIXED, APIC_DELMODE_LOWPRIO
828  *
829  * A backlog of requests can create a deadlock between cpus.  To avoid this
830  * we have to be able to accept IPIs at the same time we are trying to send
831  * them.  The critical section prevents us from attempting to send additional
832  * IPIs reentrantly, but also prevents IPIQ processing so we have to call
833  * lwkt_process_ipiq() manually.  It's rather messy and expensive for this
834  * to occur but fortunately it does not happen too often.
835  */
836 int
837 apic_ipi(int dest_type, int vector, int delivery_mode)
838 {
839         u_long  icr_lo;
840
841         crit_enter();
842         if ((lapic.icr_lo & APIC_DELSTAT_MASK) != 0) {
843             unsigned int eflags = read_eflags();
844             cpu_enable_intr();
845             while ((lapic.icr_lo & APIC_DELSTAT_MASK) != 0) {
846                 lwkt_process_ipiq();
847             }
848             write_eflags(eflags);
849         }
850
851         icr_lo = (lapic.icr_lo & APIC_ICRLO_RESV_MASK) | dest_type | 
852                 delivery_mode | vector;
853         lapic.icr_lo = icr_lo;
854         crit_exit();
855         return 0;
856 }
857
858 void
859 single_apic_ipi(int cpu, int vector, int delivery_mode)
860 {
861         u_long  icr_lo;
862         u_long  icr_hi;
863
864         crit_enter();
865         if ((lapic.icr_lo & APIC_DELSTAT_MASK) != 0) {
866             unsigned int eflags = read_eflags();
867             cpu_enable_intr();
868             while ((lapic.icr_lo & APIC_DELSTAT_MASK) != 0) {
869                 lwkt_process_ipiq();
870             }
871             write_eflags(eflags);
872         }
873         icr_hi = lapic.icr_hi & ~APIC_ID_MASK;
874         icr_hi |= (CPU_TO_ID(cpu) << 24);
875         lapic.icr_hi = icr_hi;
876
877         /* build ICR_LOW */
878         icr_lo = (lapic.icr_lo & APIC_ICRLO_RESV_MASK)
879             | APIC_DEST_DESTFLD | delivery_mode | vector;
880
881         /* write APIC ICR */
882         lapic.icr_lo = icr_lo;
883         crit_exit();
884 }
885
886 #if 0   
887
888 /*
889  * Returns 0 if the apic is busy, 1 if we were able to queue the request.
890  *
891  * NOT WORKING YET!  The code as-is may end up not queueing an IPI at all
892  * to the target, and the scheduler does not 'poll' for IPI messages.
893  */
894 int
895 single_apic_ipi_passive(int cpu, int vector, int delivery_mode)
896 {
897         u_long  icr_lo;
898         u_long  icr_hi;
899
900         crit_enter();
901         if ((lapic.icr_lo & APIC_DELSTAT_MASK) != 0) {
902             crit_exit();
903             return(0);
904         }
905         icr_hi = lapic.icr_hi & ~APIC_ID_MASK;
906         icr_hi |= (CPU_TO_ID(cpu) << 24);
907         lapic.icr_hi = icr_hi;
908
909         /* build IRC_LOW */
910         icr_lo = (lapic.icr_lo & APIC_RESV2_MASK)
911             | APIC_DEST_DESTFLD | delivery_mode | vector;
912
913         /* write APIC ICR */
914         lapic.icr_lo = icr_lo;
915         crit_exit();
916         return(1);
917 }
918
919 #endif
920
921 /*
922  * Send APIC IPI 'vector' to 'target's via 'delivery_mode'.
923  *
924  * target is a bitmask of destination cpus.  Vector is any
925  * valid system INT vector.  Delivery mode may be either
926  * APIC_DELMODE_FIXED or APIC_DELMODE_LOWPRIO.
927  */
928 void
929 selected_apic_ipi(u_int target, int vector, int delivery_mode)
930 {
931         crit_enter();
932         while (target) {
933                 int n = bsfl(target);
934                 target &= ~(1 << n);
935                 single_apic_ipi(n, vector, delivery_mode);
936         }
937         crit_exit();
938 }
939
940 /*
941  * Timer code, in development...
942  *  - suggested by rgrimes@gndrsh.aac.dev.com
943  */
944 int
945 get_apic_timer_frequency(void)
946 {
947         return(lapic_cputimer_intr.freq);
948 }
949
950 /*
951  * Load a 'downcount time' in uSeconds.
952  */
953 void
954 set_apic_timer(int us)
955 {
956         u_int count;
957
958         /*
959          * When we reach here, lapic timer's frequency
960          * must have been calculated as well as the
961          * divisor (lapic.dcr_timer is setup during the
962          * divisor calculation).
963          */
964         KKASSERT(lapic_cputimer_intr.freq != 0 &&
965                  lapic_timer_divisor_idx >= 0);
966
967         count = ((us * (int64_t)lapic_cputimer_intr.freq) + 999999) / 1000000;
968         lapic_timer_oneshot(count);
969 }
970
971
972 /*
973  * Read remaining time in timer.
974  */
975 int
976 read_apic_timer(void)
977 {
978 #if 0
979         /** XXX FIXME: we need to return the actual remaining time,
980          *         for now we just return the remaining count.
981          */
982 #else
983         return lapic.ccr_timer;
984 #endif
985 }
986
987
988 /*
989  * Spin-style delay, set delay time in uS, spin till it drains.
990  */
991 void
992 u_sleep(int count)
993 {
994         set_apic_timer(count);
995         while (read_apic_timer())
996                  /* spin */ ;
997 }
998
999 void
1000 lapic_map(vm_offset_t lapic_addr)
1001 {
1002         /* Local apic is mapped on last page */
1003         SMPpt[NPTEPG - 1] = (pt_entry_t)(PG_V | PG_RW | PG_N |
1004             pmap_get_pgeflag() | (lapic_addr & PG_FRAME));
1005
1006         kprintf("lapic: at %p\n", (void *)lapic_addr);
1007 }
1008
1009 static TAILQ_HEAD(, lapic_enumerator) lapic_enumerators =
1010         TAILQ_HEAD_INITIALIZER(lapic_enumerators);
1011
1012 void
1013 lapic_config(void)
1014 {
1015         struct lapic_enumerator *e;
1016         int error;
1017
1018         TAILQ_FOREACH(e, &lapic_enumerators, lapic_link) {
1019                 error = e->lapic_probe(e);
1020                 if (!error)
1021                         break;
1022         }
1023         if (e == NULL)
1024                 panic("can't config lapic\n");
1025
1026         e->lapic_enumerate(e);
1027 }
1028
1029 void
1030 lapic_enumerator_register(struct lapic_enumerator *ne)
1031 {
1032         struct lapic_enumerator *e;
1033
1034         TAILQ_FOREACH(e, &lapic_enumerators, lapic_link) {
1035                 if (e->lapic_prio < ne->lapic_prio) {
1036                         TAILQ_INSERT_BEFORE(e, ne, lapic_link);
1037                         return;
1038                 }
1039         }
1040         TAILQ_INSERT_TAIL(&lapic_enumerators, ne, lapic_link);
1041 }