0f17b7f989c20f5eca8894f9656628ff939772c4
[dragonfly.git] / sys / platform / pc64 / x86_64 / mp_machdep.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/mp_machdep.c,v 1.115.2.15 2003/03/14 21:22:35 jhb Exp $
26  * $DragonFly: src/sys/platform/pc32/i386/mp_machdep.c,v 1.60 2008/06/07 12:03:52 mneumann Exp $
27  */
28
29 #include "opt_cpu.h"
30
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/kernel.h>
34 #include <sys/sysctl.h>
35 #include <sys/malloc.h>
36 #include <sys/memrange.h>
37 #include <sys/cons.h>   /* cngetc() */
38 #include <sys/machintr.h>
39
40 #include <sys/mplock2.h>
41
42 #include <vm/vm.h>
43 #include <vm/vm_param.h>
44 #include <vm/pmap.h>
45 #include <vm/vm_kern.h>
46 #include <vm/vm_extern.h>
47 #include <sys/lock.h>
48 #include <vm/vm_map.h>
49 #include <sys/user.h>
50 #ifdef GPROF 
51 #include <sys/gmon.h>
52 #endif
53
54 #include <machine/smp.h>
55 #include <machine_base/apic/apicreg.h>
56 #include <machine/atomic.h>
57 #include <machine/cpufunc.h>
58 #include <machine_base/apic/mpapic.h>
59 #include <machine/psl.h>
60 #include <machine/segments.h>
61 #include <machine/tss.h>
62 #include <machine/specialreg.h>
63 #include <machine/globaldata.h>
64
65 #include <machine/md_var.h>             /* setidt() */
66 #include <machine_base/icu/icu.h>               /* IPIs */
67 #include <machine_base/isa/intr_machdep.h>      /* IPIs */
68
69 #define FIXUP_EXTRA_APIC_INTS   8       /* additional entries we may create */
70
71 #define WARMBOOT_TARGET         0
72 #define WARMBOOT_OFF            (KERNBASE + 0x0467)
73 #define WARMBOOT_SEG            (KERNBASE + 0x0469)
74
75 #define BIOS_BASE               (0xf0000)
76 #define BIOS_SIZE               (0x10000)
77 #define BIOS_COUNT              (BIOS_SIZE/4)
78
79 #define CMOS_REG                (0x70)
80 #define CMOS_DATA               (0x71)
81 #define BIOS_RESET              (0x0f)
82 #define BIOS_WARM               (0x0a)
83
84 #define PROCENTRY_FLAG_EN       0x01
85 #define PROCENTRY_FLAG_BP       0x02
86 #define IOAPICENTRY_FLAG_EN     0x01
87
88
89 /* MP Floating Pointer Structure */
90 typedef struct MPFPS {
91         char    signature[4];
92         u_int32_t pap;
93         u_char  length;
94         u_char  spec_rev;
95         u_char  checksum;
96         u_char  mpfb1;
97         u_char  mpfb2;
98         u_char  mpfb3;
99         u_char  mpfb4;
100         u_char  mpfb5;
101 }      *mpfps_t;
102
103 /* MP Configuration Table Header */
104 typedef struct MPCTH {
105         char    signature[4];
106         u_short base_table_length;
107         u_char  spec_rev;
108         u_char  checksum;
109         u_char  oem_id[8];
110         u_char  product_id[12];
111         u_int32_t oem_table_pointer;
112         u_short oem_table_size;
113         u_short entry_count;
114         u_int32_t apic_address;
115         u_short extended_table_length;
116         u_char  extended_table_checksum;
117         u_char  reserved;
118 }      *mpcth_t;
119
120
121 typedef struct PROCENTRY {
122         u_char  type;
123         u_char  apic_id;
124         u_char  apic_version;
125         u_char  cpu_flags;
126         u_int32_t cpu_signature;
127         u_int32_t feature_flags;
128         u_int32_t reserved1;
129         u_int32_t reserved2;
130 }      *proc_entry_ptr;
131
132 typedef struct BUSENTRY {
133         u_char  type;
134         u_char  bus_id;
135         char    bus_type[6];
136 }      *bus_entry_ptr;
137
138 typedef struct IOAPICENTRY {
139         u_char  type;
140         u_char  apic_id;
141         u_char  apic_version;
142         u_char  apic_flags;
143         u_int32_t apic_address;
144 }      *io_apic_entry_ptr;
145
146 typedef struct INTENTRY {
147         u_char  type;
148         u_char  int_type;
149         u_short int_flags;
150         u_char  src_bus_id;
151         u_char  src_bus_irq;
152         u_char  dst_apic_id;
153         u_char  dst_apic_int;
154 }      *int_entry_ptr;
155
156 /* descriptions of MP basetable entries */
157 typedef struct BASETABLE_ENTRY {
158         u_char  type;
159         u_char  length;
160         char    name[16];
161 }       basetable_entry;
162
163 struct mptable_pos {
164         mpfps_t         mp_fps;
165         mpcth_t         mp_cth;
166         vm_size_t       mp_cth_mapsz;   
167 };
168
169 /*
170  * this code MUST be enabled here and in mpboot.s.
171  * it follows the very early stages of AP boot by placing values in CMOS ram.
172  * it NORMALLY will never be needed and thus the primitive method for enabling.
173  *
174  */
175 #if defined(CHECK_POINTS)
176 #define CHECK_READ(A)    (outb(CMOS_REG, (A)), inb(CMOS_DATA))
177 #define CHECK_WRITE(A,D) (outb(CMOS_REG, (A)), outb(CMOS_DATA, (D)))
178
179 #define CHECK_INIT(D);                          \
180         CHECK_WRITE(0x34, (D));                 \
181         CHECK_WRITE(0x35, (D));                 \
182         CHECK_WRITE(0x36, (D));                 \
183         CHECK_WRITE(0x37, (D));                 \
184         CHECK_WRITE(0x38, (D));                 \
185         CHECK_WRITE(0x39, (D));
186
187 #define CHECK_PRINT(S);                         \
188         kprintf("%s: %d, %d, %d, %d, %d, %d\n", \
189            (S),                                 \
190            CHECK_READ(0x34),                    \
191            CHECK_READ(0x35),                    \
192            CHECK_READ(0x36),                    \
193            CHECK_READ(0x37),                    \
194            CHECK_READ(0x38),                    \
195            CHECK_READ(0x39));
196
197 #else                           /* CHECK_POINTS */
198
199 #define CHECK_INIT(D)
200 #define CHECK_PRINT(S)
201
202 #endif                          /* CHECK_POINTS */
203
204 /*
205  * Values to send to the POST hardware.
206  */
207 #define MP_BOOTADDRESS_POST     0x10
208 #define MP_PROBE_POST           0x11
209 #define MPTABLE_PASS1_POST      0x12
210
211 #define MP_START_POST           0x13
212 #define MP_ENABLE_POST          0x14
213 #define MPTABLE_PASS2_POST      0x15
214
215 #define START_ALL_APS_POST      0x16
216 #define INSTALL_AP_TRAMP_POST   0x17
217 #define START_AP_POST           0x18
218
219 #define MP_ANNOUNCE_POST        0x19
220
221 static int need_hyperthreading_fixup;
222 static u_int logical_cpus;
223 u_int   logical_cpus_mask;
224
225 static int madt_probe_test;
226 TUNABLE_INT("hw.madt_probe_test", &madt_probe_test);
227
228 /** XXX FIXME: where does this really belong, isa.h/isa.c perhaps? */
229 int     current_postcode;
230
231 /** XXX FIXME: what system files declare these??? */
232 extern struct region_descriptor r_gdt, r_idt;
233
234 int     bsp_apic_ready = 0;     /* flags useability of BSP apic */
235 int     mp_naps;                /* # of Applications processors */
236 int     mp_nbusses;             /* # of busses */
237 #ifdef APIC_IO
238 int     mp_napics;              /* # of IO APICs */
239 #endif
240 vm_offset_t cpu_apic_address;
241 #ifdef APIC_IO
242 vm_offset_t io_apic_address[NAPICID];   /* NAPICID is more than enough */
243 u_int32_t *io_apic_versions;
244 #endif
245 extern  int nkpt;
246
247 u_int32_t cpu_apic_versions[MAXCPU];
248 int64_t tsc0_offset;
249 extern int64_t tsc_offsets[];
250
251 extern u_long ebda_addr;
252
253 #ifdef APIC_IO
254 struct apic_intmapinfo  int_to_apicintpin[APIC_INTMAPSIZE];
255 #endif
256
257 /*
258  * APIC ID logical/physical mapping structures.
259  * We oversize these to simplify boot-time config.
260  */
261 int     cpu_num_to_apic_id[NAPICID];
262 #ifdef APIC_IO
263 int     io_num_to_apic_id[NAPICID];
264 #endif
265 int     apic_id_to_logical[NAPICID];
266
267 /* AP uses this during bootstrap.  Do not staticize.  */
268 char *bootSTK;
269 static int bootAP;
270
271 /*
272  * SMP page table page.  Setup by locore to point to a page table
273  * page from which we allocate per-cpu privatespace areas io_apics,
274  * and so forth.
275  */
276
277 #define IO_MAPPING_START_INDEX  \
278                 (SMP_MAXCPU * sizeof(struct privatespace) / PAGE_SIZE)
279
280 extern pt_entry_t *SMPpt;
281
282 struct pcb stoppcbs[MAXCPU];
283
284 extern inthand_t IDTVEC(fast_syscall), IDTVEC(fast_syscall32);
285
286 /*
287  * Local data and functions.
288  */
289
290 static u_int    boot_address;
291 static u_int    base_memory;
292 static int      mp_finish;
293
294 static void     mp_enable(u_int boot_addr);
295
296 static int      mptable_probe(void);
297 static long     mptable_search_sig(u_int32_t target, int count);
298 static void     mptable_hyperthread_fixup(u_int id_mask);
299 static void     mptable_pass1(struct mptable_pos *);
300 static int      mptable_pass2(struct mptable_pos *);
301 static void     mptable_default(int type);
302 static void     mptable_fix(void);
303 static void     mptable_map(struct mptable_pos *, vm_paddr_t);
304 static void     mptable_unmap(struct mptable_pos *);
305
306 #ifdef APIC_IO
307 static void     setup_apic_irq_mapping(void);
308 static int      apic_int_is_bus_type(int intr, int bus_type);
309 #endif
310 static int      start_all_aps(u_int boot_addr);
311 #if 0
312 static void     install_ap_tramp(u_int boot_addr);
313 #endif
314 static int      start_ap(struct mdglobaldata *gd, u_int boot_addr, int smibest);
315 static int      smitest(void);
316
317 static cpumask_t smp_startup_mask = 1;  /* which cpus have been started */
318 cpumask_t smp_active_mask = 1;  /* which cpus are ready for IPIs etc? */
319 SYSCTL_INT(_machdep, OID_AUTO, smp_active, CTLFLAG_RD, &smp_active_mask, 0, "");
320 static u_int    bootMP_size;
321
322 /*
323  * Calculate usable address in base memory for AP trampoline code.
324  */
325 u_int
326 mp_bootaddress(u_int basemem)
327 {
328         POSTCODE(MP_BOOTADDRESS_POST);
329
330         base_memory = basemem;
331
332         bootMP_size = mptramp_end - mptramp_start;
333         boot_address = trunc_page(basemem * 1024); /* round down to 4k boundary */
334         if (((basemem * 1024) - boot_address) < bootMP_size)
335                 boot_address -= PAGE_SIZE;      /* not enough, lower by 4k */
336         /* 3 levels of page table pages */
337         mptramp_pagetables = boot_address - (PAGE_SIZE * 3);
338
339         return mptramp_pagetables;
340 }
341
342
343 /*
344  * Look for an Intel MP spec table (ie, SMP capable hardware).
345  */
346 static int
347 mptable_probe(void)
348 {
349         long    x;
350         u_int32_t target;
351  
352         /*
353          * Make sure our SMPpt[] page table is big enough to hold all the
354          * mappings we need.
355          */
356         KKASSERT(IO_MAPPING_START_INDEX < NPTEPG - 2);
357
358         POSTCODE(MP_PROBE_POST);
359
360         /* see if EBDA exists */
361         if (ebda_addr != 0) {
362                 /* search first 1K of EBDA */
363                 target = (u_int32_t)ebda_addr;
364                 if ((x = mptable_search_sig(target, 1024 / 4)) > 0)
365                         return x;
366         } else {
367                 /* last 1K of base memory, effective 'top of base' passed in */
368                 target = (u_int32_t)(base_memory - 0x400);
369                 if ((x = mptable_search_sig(target, 1024 / 4)) > 0)
370                         return x;
371         }
372
373         /* search the BIOS */
374         target = (u_int32_t)BIOS_BASE;
375         if ((x = mptable_search_sig(target, BIOS_COUNT)) > 0)
376                 return x;
377
378         /* nothing found */
379         return 0;
380 }
381
382
383 /*
384  * Startup the SMP processors.
385  */
386 void
387 mp_start(void)
388 {
389         POSTCODE(MP_START_POST);
390         mp_enable(boot_address);
391 }
392
393
394 /*
395  * Print various information about the SMP system hardware and setup.
396  */
397 void
398 mp_announce(void)
399 {
400         int     x;
401
402         POSTCODE(MP_ANNOUNCE_POST);
403
404         kprintf("DragonFly/MP: Multiprocessor motherboard\n");
405         kprintf(" cpu0 (BSP): apic id: %2d", CPU_TO_ID(0));
406         kprintf(", version: 0x%08x", cpu_apic_versions[0]);
407         kprintf(", at 0x%08jx\n", (intmax_t)cpu_apic_address);
408         for (x = 1; x <= mp_naps; ++x) {
409                 kprintf(" cpu%d (AP):  apic id: %2d", x, CPU_TO_ID(x));
410                 kprintf(", version: 0x%08x", cpu_apic_versions[x]);
411                 kprintf(", at 0x%08jx\n", (intmax_t)cpu_apic_address);
412         }
413
414 #if defined(APIC_IO)
415         for (x = 0; x < mp_napics; ++x) {
416                 kprintf(" io%d (APIC): apic id: %2d", x, IO_TO_ID(x));
417                 kprintf(", version: 0x%08x", io_apic_versions[x]);
418                 kprintf(", at 0x%08lx\n", io_apic_address[x]);
419         }
420 #else
421         kprintf(" Warning: APIC I/O disabled\n");
422 #endif  /* APIC_IO */
423 }
424
425 /*
426  * AP cpu's call this to sync up protected mode.
427  *
428  * WARNING! %gs is not set up on entry.  This routine sets up %gs.
429  */
430 void
431 init_secondary(void)
432 {
433         int     gsel_tss;
434         int     x, myid = bootAP;
435         u_int64_t msr, cr0;
436         struct mdglobaldata *md;
437         struct privatespace *ps;
438
439         ps = &CPU_prvspace[myid];
440
441         gdt_segs[GPROC0_SEL].ssd_base =
442                 (long) &ps->mdglobaldata.gd_common_tss;
443         ps->mdglobaldata.mi.gd_prvspace = ps;
444
445         /* We fill the 32-bit segment descriptors */
446         for (x = 0; x < NGDT; x++) {
447                 if (x != GPROC0_SEL && x != (GPROC0_SEL + 1))
448                         ssdtosd(&gdt_segs[x], &gdt[myid * NGDT + x]);
449         }
450         /* And now a 64-bit one */
451         ssdtosyssd(&gdt_segs[GPROC0_SEL],
452             (struct system_segment_descriptor *)&gdt[myid * NGDT + GPROC0_SEL]);
453
454         r_gdt.rd_limit = NGDT * sizeof(gdt[0]) - 1;
455         r_gdt.rd_base = (long) &gdt[myid * NGDT];
456         lgdt(&r_gdt);                   /* does magic intra-segment return */
457
458         /* lgdt() destroys the GSBASE value, so we load GSBASE after lgdt() */
459         wrmsr(MSR_FSBASE, 0);           /* User value */
460         wrmsr(MSR_GSBASE, (u_int64_t)ps);
461         wrmsr(MSR_KGSBASE, 0);          /* XXX User value while we're in the kernel */
462
463         lidt(&r_idt);
464
465 #if 0
466         lldt(_default_ldt);
467         mdcpu->gd_currentldt = _default_ldt;
468 #endif
469
470         gsel_tss = GSEL(GPROC0_SEL, SEL_KPL);
471         gdt[myid * NGDT + GPROC0_SEL].sd_type = SDT_SYSTSS;
472
473         md = mdcpu;     /* loaded through %gs:0 (mdglobaldata.mi.gd_prvspace)*/
474
475         md->gd_common_tss.tss_rsp0 = 0; /* not used until after switch */
476 #if 0 /* JG XXX */
477         md->gd_common_tss.tss_ioopt = (sizeof md->gd_common_tss) << 16;
478 #endif
479         md->gd_tss_gdt = &gdt[myid * NGDT + GPROC0_SEL];
480         md->gd_common_tssd = *md->gd_tss_gdt;
481 #if 0 /* JG XXX */
482         md->gd_common_tss.tss_ist1 = (long)&doublefault_stack[PAGE_SIZE];
483 #endif
484         ltr(gsel_tss);
485
486         /*
487          * Set to a known state:
488          * Set by mpboot.s: CR0_PG, CR0_PE
489          * Set by cpu_setregs: CR0_NE, CR0_MP, CR0_TS, CR0_WP, CR0_AM
490          */
491         cr0 = rcr0();
492         cr0 &= ~(CR0_CD | CR0_NW | CR0_EM);
493         load_cr0(cr0);
494
495         /* Set up the fast syscall stuff */
496         msr = rdmsr(MSR_EFER) | EFER_SCE;
497         wrmsr(MSR_EFER, msr);
498         wrmsr(MSR_LSTAR, (u_int64_t)IDTVEC(fast_syscall));
499         wrmsr(MSR_CSTAR, (u_int64_t)IDTVEC(fast_syscall32));
500         msr = ((u_int64_t)GSEL(GCODE_SEL, SEL_KPL) << 32) |
501               ((u_int64_t)GSEL(GUCODE32_SEL, SEL_UPL) << 48);
502         wrmsr(MSR_STAR, msr);
503         wrmsr(MSR_SF_MASK, PSL_NT|PSL_T|PSL_I|PSL_C|PSL_D);
504
505         pmap_set_opt();         /* PSE/4MB pages, etc */
506 #if JGXXX
507         /* Initialize the PAT MSR. */
508         pmap_init_pat();
509 #endif
510
511         /* set up CPU registers and state */
512         cpu_setregs();
513
514         /* set up SSE/NX registers */
515         initializecpu();
516
517         /* set up FPU state on the AP */
518         npxinit(__INITIAL_NPXCW__);
519
520         /* disable the APIC, just to be SURE */
521         lapic->svr &= ~APIC_SVR_ENABLE;
522
523         /* data returned to BSP */
524         cpu_apic_versions[0] = lapic->version;
525 }
526
527 /*******************************************************************
528  * local functions and data
529  */
530
531 /*
532  * start the SMP system
533  */
534 static void
535 mp_enable(u_int boot_addr)
536 {
537         int     x;
538 #if defined(APIC_IO)
539         int     apic;
540         u_int   ux;
541 #endif  /* APIC_IO */
542         vm_paddr_t mpfps_paddr;
543
544         POSTCODE(MP_ENABLE_POST);
545
546         if (madt_probe_test)
547                 mpfps_paddr = 0;
548         else
549                 mpfps_paddr = mptable_probe();
550
551         if (mpfps_paddr) {
552                 struct mptable_pos mpt;
553
554                 mptable_map(&mpt, mpfps_paddr);
555
556                 /*
557                  * We can safely map physical memory into SMPpt after
558                  * mptable_pass1() completes.
559                  */
560                 mptable_pass1(&mpt);
561
562                 if (cpu_apic_address == 0)
563                         panic("mp_enable: no local apic!\n");
564
565                 /* examine the MP table for needed info */
566                 x = mptable_pass2(&mpt);
567
568                 mptable_unmap(&mpt);
569
570                 /*
571                  * can't process default configs till the
572                  * CPU APIC is pmapped
573                  */
574                 if (x)
575                         mptable_default(x);
576
577                 /* post scan cleanup */
578                 mptable_fix();
579
580                 /*
581                  * lapic not mapped yet (pmap_init is called too late)
582                  */
583                 lapic = pmap_mapdev_uncacheable(cpu_apic_address,
584                                                 sizeof(struct LAPIC));
585         } else {
586                 vm_paddr_t madt_paddr;
587                 int bsp_apic_id;
588
589                 madt_paddr = madt_probe();
590                 if (madt_paddr == 0)
591                         panic("mp_enable: madt_probe failed\n");
592
593                 cpu_apic_address = madt_pass1(madt_paddr);
594                 if (cpu_apic_address == 0)
595                         panic("mp_enable: no local apic (madt)!\n");
596
597                 /*
598                  * lapic not mapped yet (pmap_init is called too late)
599                  *
600                  * XXX: where is the best place to set lapic?
601                  */
602                 lapic = pmap_mapdev_uncacheable(cpu_apic_address,
603                                                 sizeof(struct LAPIC));
604
605                 bsp_apic_id = (lapic->id & 0xff000000) >> 24;
606                 if (madt_pass2(madt_paddr, bsp_apic_id))
607                         panic("mp_enable: madt_pass2 failed\n");
608         }
609
610 #if defined(APIC_IO)
611
612         setup_apic_irq_mapping();
613
614         /* fill the LOGICAL io_apic_versions table */
615         for (apic = 0; apic < mp_napics; ++apic) {
616                 ux = io_apic_read(apic, IOAPIC_VER);
617                 io_apic_versions[apic] = ux;
618                 io_apic_set_id(apic, IO_TO_ID(apic));
619         }
620
621         /* program each IO APIC in the system */
622         for (apic = 0; apic < mp_napics; ++apic)
623                 if (io_apic_setup(apic) < 0)
624                         panic("IO APIC setup failure");
625
626 #endif  /* APIC_IO */
627
628         /*
629          * These are required for SMP operation
630          */
631
632         /* install a 'Spurious INTerrupt' vector */
633         setidt(XSPURIOUSINT_OFFSET, Xspuriousint,
634                SDT_SYSIGT, SEL_KPL, 0);
635
636         /* install an inter-CPU IPI for TLB invalidation */
637         setidt(XINVLTLB_OFFSET, Xinvltlb,
638                SDT_SYSIGT, SEL_KPL, 0);
639
640         /* install an inter-CPU IPI for IPIQ messaging */
641         setidt(XIPIQ_OFFSET, Xipiq,
642                SDT_SYSIGT, SEL_KPL, 0);
643
644         /* install a timer vector */
645         setidt(XTIMER_OFFSET, Xtimer,
646                SDT_SYSIGT, SEL_KPL, 0);
647         
648         /* install an inter-CPU IPI for CPU stop/restart */
649         setidt(XCPUSTOP_OFFSET, Xcpustop,
650                SDT_SYSIGT, SEL_KPL, 0);
651
652         /* start each Application Processor */
653         start_all_aps(boot_addr);
654 }
655
656
657 /*
658  * look for the MP spec signature
659  */
660
661 /* string defined by the Intel MP Spec as identifying the MP table */
662 #define MP_SIG          0x5f504d5f      /* _MP_ */
663 #define NEXT(X)         ((X) += 4)
664 static long
665 mptable_search_sig(u_int32_t target, int count)
666 {
667         vm_size_t map_size;
668         u_int32_t *addr;
669         int x, ret;
670
671         KKASSERT(target != 0);
672
673         map_size = count * sizeof(u_int32_t);
674         addr = pmap_mapdev((vm_paddr_t)target, map_size);
675
676         ret = 0;
677         for (x = 0; x < count; NEXT(x)) {
678                 if (addr[x] == MP_SIG) {
679                         /* make array index a byte index */
680                         ret = target + (x * sizeof(u_int32_t));
681                         break;
682                 }
683         }
684
685         pmap_unmapdev((vm_offset_t)addr, map_size);
686         return ret;
687 }
688
689
690 static basetable_entry basetable_entry_types[] =
691 {
692         {0, 20, "Processor"},
693         {1, 8, "Bus"},
694         {2, 8, "I/O APIC"},
695         {3, 8, "I/O INT"},
696         {4, 8, "Local INT"}
697 };
698
699 typedef struct BUSDATA {
700         u_char  bus_id;
701         enum busTypes bus_type;
702 }       bus_datum;
703
704 typedef struct INTDATA {
705         u_char  int_type;
706         u_short int_flags;
707         u_char  src_bus_id;
708         u_char  src_bus_irq;
709         u_char  dst_apic_id;
710         u_char  dst_apic_int;
711         u_char  int_vector;
712 }       io_int, local_int;
713
714 typedef struct BUSTYPENAME {
715         u_char  type;
716         char    name[7];
717 }       bus_type_name;
718
719 static bus_type_name bus_type_table[] =
720 {
721         {CBUS, "CBUS"},
722         {CBUSII, "CBUSII"},
723         {EISA, "EISA"},
724         {MCA, "MCA"},
725         {UNKNOWN_BUSTYPE, "---"},
726         {ISA, "ISA"},
727         {MCA, "MCA"},
728         {UNKNOWN_BUSTYPE, "---"},
729         {UNKNOWN_BUSTYPE, "---"},
730         {UNKNOWN_BUSTYPE, "---"},
731         {UNKNOWN_BUSTYPE, "---"},
732         {UNKNOWN_BUSTYPE, "---"},
733         {PCI, "PCI"},
734         {UNKNOWN_BUSTYPE, "---"},
735         {UNKNOWN_BUSTYPE, "---"},
736         {UNKNOWN_BUSTYPE, "---"},
737         {UNKNOWN_BUSTYPE, "---"},
738         {XPRESS, "XPRESS"},
739         {UNKNOWN_BUSTYPE, "---"}
740 };
741 /* from MP spec v1.4, table 5-1 */
742 static int default_data[7][5] =
743 {
744 /*   nbus, id0, type0, id1, type1 */
745         {1, 0, ISA, 255, 255},
746         {1, 0, EISA, 255, 255},
747         {1, 0, EISA, 255, 255},
748         {1, 0, MCA, 255, 255},
749         {2, 0, ISA, 1, PCI},
750         {2, 0, EISA, 1, PCI},
751         {2, 0, MCA, 1, PCI}
752 };
753
754
755 /* the bus data */
756 static bus_datum *bus_data;
757
758 #ifdef APIC_IO
759 /* the IO INT data, one entry per possible APIC INTerrupt */
760 static io_int  *io_apic_ints;
761 static int nintrs;
762 #endif
763
764 static int processor_entry      (proc_entry_ptr entry, int cpu);
765 static int bus_entry            (bus_entry_ptr entry, int bus);
766 #ifdef APIC_IO
767 static int io_apic_entry        (io_apic_entry_ptr entry, int apic);
768 static int int_entry            (int_entry_ptr entry, int intr);
769 #endif
770 static int lookup_bus_type      (char *name);
771
772
773 /*
774  * 1st pass on motherboard's Intel MP specification table.
775  *
776  * determines:
777  *      cpu_apic_address (common to all CPUs)
778  *      io_apic_address[N]
779  *      mp_naps
780  *      mp_nbusses
781  *      mp_napics
782  *      nintrs
783  *      need_hyperthreading_fixup
784  *      logical_cpus
785  */
786 static void
787 mptable_pass1(struct mptable_pos *mpt)
788 {
789 #ifdef APIC_IO
790         int     x;
791 #endif
792         mpfps_t fps;
793         mpcth_t cth;
794         int     totalSize;
795         void*   position;
796         int     count;
797         int     type;
798         u_int   id_mask;
799
800         POSTCODE(MPTABLE_PASS1_POST);
801
802         fps = mpt->mp_fps;
803         KKASSERT(fps != NULL);
804
805 #ifdef APIC_IO
806         /* clear various tables */
807         for (x = 0; x < NAPICID; ++x) {
808                 io_apic_address[x] = ~0;        /* IO APIC address table */
809         }
810 #endif
811
812         /* init everything to empty */
813         mp_naps = 0;
814         mp_nbusses = 0;
815 #ifdef APIC_IO
816         mp_napics = 0;
817         nintrs = 0;
818 #endif
819         id_mask = 0;
820
821         /* check for use of 'default' configuration */
822         if (fps->mpfb1 != 0) {
823                 /* use default addresses */
824                 cpu_apic_address = DEFAULT_APIC_BASE;
825 #ifdef APIC_IO
826                 io_apic_address[0] = DEFAULT_IO_APIC_BASE;
827 #endif
828
829                 /* fill in with defaults */
830                 mp_naps = 2;            /* includes BSP */
831                 mp_nbusses = default_data[fps->mpfb1 - 1][0];
832 #if defined(APIC_IO)
833                 mp_napics = 1;
834                 nintrs = 16;
835 #endif  /* APIC_IO */
836         }
837         else {
838                 cth = mpt->mp_cth;
839                 if (cth == NULL)
840                         panic("MP Configuration Table Header MISSING!");
841
842                 cpu_apic_address = (vm_offset_t) cth->apic_address;
843
844                 /* walk the table, recording info of interest */
845                 totalSize = cth->base_table_length - sizeof(struct MPCTH);
846                 position = (u_char *) cth + sizeof(struct MPCTH);
847                 count = cth->entry_count;
848
849                 while (count--) {
850                         switch (type = *(u_char *) position) {
851                         case 0: /* processor_entry */
852                                 if (((proc_entry_ptr)position)->cpu_flags
853                                     & PROCENTRY_FLAG_EN) {
854                                         ++mp_naps;
855                                         id_mask |= 1 <<
856                                             ((proc_entry_ptr)position)->apic_id;
857                                 }
858                                 break;
859                         case 1: /* bus_entry */
860                                 ++mp_nbusses;
861                                 break;
862                         case 2: /* io_apic_entry */
863 #ifdef APIC_IO
864                                 if (((io_apic_entry_ptr)position)->apic_flags
865                                         & IOAPICENTRY_FLAG_EN)
866                                         io_apic_address[mp_napics++] =
867                                             (vm_offset_t)((io_apic_entry_ptr)
868                                                 position)->apic_address;
869 #endif
870                                 break;
871                         case 3: /* int_entry */
872 #ifdef APIC_IO
873                                 ++nintrs;
874 #endif
875                                 break;
876                         case 4: /* int_entry */
877                                 break;
878                         default:
879                                 panic("mpfps Base Table HOSED!");
880                                 /* NOTREACHED */
881                         }
882
883                         totalSize -= basetable_entry_types[type].length;
884                         position = (uint8_t *)position +
885                             basetable_entry_types[type].length;
886                 }
887         }
888
889         /* qualify the numbers */
890         if (mp_naps > MAXCPU) {
891                 kprintf("Warning: only using %d of %d available CPUs!\n",
892                         MAXCPU, mp_naps);
893                 mp_naps = MAXCPU;
894         }
895
896         /* See if we need to fixup HT logical CPUs. */
897         mptable_hyperthread_fixup(id_mask);
898
899         --mp_naps;      /* subtract the BSP */
900 }
901
902
903 /*
904  * 2nd pass on motherboard's Intel MP specification table.
905  *
906  * sets:
907  *      logical_cpus_mask
908  *      ID_TO_IO(N), phy APIC ID to log CPU/IO table
909  *      CPU_TO_ID(N), logical CPU to APIC ID table
910  *      IO_TO_ID(N), logical IO to APIC ID table
911  *      bus_data[N]
912  *      io_apic_ints[N]
913  */
914 static int
915 mptable_pass2(struct mptable_pos *mpt)
916 {
917         struct PROCENTRY proc;
918         int     x;
919         mpfps_t fps;
920         mpcth_t cth;
921         int     totalSize;
922         void*   position;
923         int     count;
924         int     type;
925         int     apic, bus, cpu, intr;
926         int     i;
927
928         POSTCODE(MPTABLE_PASS2_POST);
929
930         fps = mpt->mp_fps;
931         KKASSERT(fps != NULL);
932
933         /* Initialize fake proc entry for use with HT fixup. */
934         bzero(&proc, sizeof(proc));
935         proc.type = 0;
936         proc.cpu_flags = PROCENTRY_FLAG_EN;
937
938 #ifdef APIC_IO
939         MALLOC(io_apic_versions, u_int32_t *, sizeof(u_int32_t) * mp_napics,
940             M_DEVBUF, M_WAITOK);
941         MALLOC(ioapic, volatile ioapic_t **, sizeof(ioapic_t *) * mp_napics,
942             M_DEVBUF, M_WAITOK | M_ZERO);
943         MALLOC(io_apic_ints, io_int *, sizeof(io_int) * (nintrs + FIXUP_EXTRA_APIC_INTS),
944             M_DEVBUF, M_WAITOK);
945 #endif
946         MALLOC(bus_data, bus_datum *, sizeof(bus_datum) * mp_nbusses,
947             M_DEVBUF, M_WAITOK);
948
949 #ifdef APIC_IO
950         for (i = 0; i < mp_napics; i++) {
951                 ioapic[i] = permanent_io_mapping(io_apic_address[i]);
952         }
953 #endif
954
955         /* clear various tables */
956         for (x = 0; x < NAPICID; ++x) {
957                 CPU_TO_ID(x) = -1;      /* logical CPU to APIC ID table */
958 #ifdef APIC_IO
959                 ID_TO_IO(x) = -1;       /* phy APIC ID to log CPU/IO table */
960                 IO_TO_ID(x) = -1;       /* logical IO to APIC ID table */
961 #endif
962         }
963
964         /* clear bus data table */
965         for (x = 0; x < mp_nbusses; ++x)
966                 bus_data[x].bus_id = 0xff;
967
968 #ifdef APIC_IO
969         /* clear IO APIC INT table */
970         for (x = 0; x < (nintrs + 1); ++x) {
971                 io_apic_ints[x].int_type = 0xff;
972                 io_apic_ints[x].int_vector = 0xff;
973         }
974 #endif
975
976         /* record whether PIC or virtual-wire mode */
977         machintr_setvar_simple(MACHINTR_VAR_IMCR_PRESENT, fps->mpfb2 & 0x80);
978
979         /* check for use of 'default' configuration */
980         if (fps->mpfb1 != 0)
981                 return fps->mpfb1;      /* return default configuration type */
982
983         cth = mpt->mp_cth;
984         if (cth == NULL)
985                 panic("MP Configuration Table Header MISSING!");
986
987         /* walk the table, recording info of interest */
988         totalSize = cth->base_table_length - sizeof(struct MPCTH);
989         position = (u_char *) cth + sizeof(struct MPCTH);
990         count = cth->entry_count;
991         apic = bus = intr = 0;
992         cpu = 1;                                /* pre-count the BSP */
993
994         while (count--) {
995                 switch (type = *(u_char *) position) {
996                 case 0:
997                         if (processor_entry(position, cpu))
998                                 ++cpu;
999
1000                         if (need_hyperthreading_fixup) {
1001                                 /*
1002                                  * Create fake mptable processor entries
1003                                  * and feed them to processor_entry() to
1004                                  * enumerate the logical CPUs.
1005                                  */
1006                                 proc.apic_id = ((proc_entry_ptr)position)->apic_id;
1007                                 for (i = 1; i < logical_cpus; i++) {
1008                                         proc.apic_id++;
1009                                         processor_entry(&proc, cpu);
1010                                         logical_cpus_mask |= (1 << cpu);
1011                                         cpu++;
1012                                 }
1013                         }
1014                         break;
1015                 case 1:
1016                         if (bus_entry(position, bus))
1017                                 ++bus;
1018                         break;
1019                 case 2:
1020 #ifdef APIC_IO
1021                         if (io_apic_entry(position, apic))
1022                                 ++apic;
1023 #endif
1024                         break;
1025                 case 3:
1026 #ifdef APIC_IO
1027                         if (int_entry(position, intr))
1028                                 ++intr;
1029 #endif
1030                         break;
1031                 case 4:
1032                         /* int_entry(position); */
1033                         break;
1034                 default:
1035                         panic("mpfps Base Table HOSED!");
1036                         /* NOTREACHED */
1037                 }
1038
1039                 totalSize -= basetable_entry_types[type].length;
1040                 position = (uint8_t *)position + basetable_entry_types[type].length;
1041         }
1042
1043         if (CPU_TO_ID(0) < 0)
1044                 panic("NO BSP found!");
1045
1046         /* report fact that its NOT a default configuration */
1047         return 0;
1048 }
1049
1050
1051 /*
1052  * Check if we should perform a hyperthreading "fix-up" to
1053  * enumerate any logical CPU's that aren't already listed
1054  * in the table.
1055  *
1056  * XXX: We assume that all of the physical CPUs in the
1057  * system have the same number of logical CPUs.
1058  *
1059  * XXX: We assume that APIC ID's are allocated such that
1060  * the APIC ID's for a physical processor are aligned
1061  * with the number of logical CPU's in the processor.
1062  */
1063 static void
1064 mptable_hyperthread_fixup(u_int id_mask)
1065 {
1066         u_int i, id;
1067
1068         /* Nothing to do if there is no HTT support. */
1069         if ((cpu_feature & CPUID_HTT) == 0)
1070                 return;
1071         logical_cpus = (cpu_procinfo & CPUID_HTT_CORES) >> 16;
1072         if (logical_cpus <= 1)
1073                 return;
1074
1075         /*
1076          * For each APIC ID of a CPU that is set in the mask,
1077          * scan the other candidate APIC ID's for this
1078          * physical processor.  If any of those ID's are
1079          * already in the table, then kill the fixup.
1080          */
1081         for (id = 0; id <= MAXCPU; id++) {
1082                 if ((id_mask & 1 << id) == 0)
1083                         continue;
1084                 /* First, make sure we are on a logical_cpus boundary. */
1085                 if (id % logical_cpus != 0)
1086                         return;
1087                 for (i = id + 1; i < id + logical_cpus; i++)
1088                         if ((id_mask & 1 << i) != 0)
1089                                 return;
1090         }
1091
1092         /*
1093          * Ok, the ID's checked out, so enable the fixup.  We have to fixup
1094          * mp_naps right now.
1095          */
1096         need_hyperthreading_fixup = 1;
1097         mp_naps *= logical_cpus;
1098 }
1099
1100 static void
1101 mptable_map(struct mptable_pos *mpt, vm_paddr_t mpfps_paddr)
1102 {
1103         mpfps_t fps = NULL;
1104         mpcth_t cth = NULL;
1105         vm_size_t cth_mapsz = 0;
1106
1107         fps = pmap_mapdev(mpfps_paddr, sizeof(*fps));
1108         if (fps->pap != 0) {
1109                 /*
1110                  * Map configuration table header to get
1111                  * the base table size
1112                  */
1113                 cth = pmap_mapdev(fps->pap, sizeof(*cth));
1114                 cth_mapsz = cth->base_table_length;
1115                 pmap_unmapdev((vm_offset_t)cth, sizeof(*cth));
1116
1117                 /*
1118                  * Map the base table
1119                  */
1120                 cth = pmap_mapdev(fps->pap, cth_mapsz);
1121         }
1122
1123         mpt->mp_fps = fps;
1124         mpt->mp_cth = cth;
1125         mpt->mp_cth_mapsz = cth_mapsz;
1126 }
1127
1128 static void
1129 mptable_unmap(struct mptable_pos *mpt)
1130 {
1131         if (mpt->mp_cth != NULL) {
1132                 pmap_unmapdev((vm_offset_t)mpt->mp_cth, mpt->mp_cth_mapsz);
1133                 mpt->mp_cth = NULL;
1134                 mpt->mp_cth_mapsz = 0;
1135         }
1136         if (mpt->mp_fps != NULL) {
1137                 pmap_unmapdev((vm_offset_t)mpt->mp_fps, sizeof(*mpt->mp_fps));
1138                 mpt->mp_fps = NULL;
1139         }
1140 }
1141
1142 #ifdef APIC_IO
1143
1144 void
1145 assign_apic_irq(int apic, int intpin, int irq)
1146 {
1147         int x;
1148         
1149         if (int_to_apicintpin[irq].ioapic != -1)
1150                 panic("assign_apic_irq: inconsistent table");
1151         
1152         int_to_apicintpin[irq].ioapic = apic;
1153         int_to_apicintpin[irq].int_pin = intpin;
1154         int_to_apicintpin[irq].apic_address = ioapic[apic];
1155         int_to_apicintpin[irq].redirindex = IOAPIC_REDTBL + 2 * intpin;
1156         
1157         for (x = 0; x < nintrs; x++) {
1158                 if ((io_apic_ints[x].int_type == 0 || 
1159                      io_apic_ints[x].int_type == 3) &&
1160                     io_apic_ints[x].int_vector == 0xff &&
1161                     io_apic_ints[x].dst_apic_id == IO_TO_ID(apic) &&
1162                     io_apic_ints[x].dst_apic_int == intpin)
1163                         io_apic_ints[x].int_vector = irq;
1164         }
1165 }
1166
1167 void
1168 revoke_apic_irq(int irq)
1169 {
1170         int x;
1171         int oldapic;
1172         int oldintpin;
1173         
1174         if (int_to_apicintpin[irq].ioapic == -1)
1175                 panic("revoke_apic_irq: inconsistent table");
1176         
1177         oldapic = int_to_apicintpin[irq].ioapic;
1178         oldintpin = int_to_apicintpin[irq].int_pin;
1179
1180         int_to_apicintpin[irq].ioapic = -1;
1181         int_to_apicintpin[irq].int_pin = 0;
1182         int_to_apicintpin[irq].apic_address = NULL;
1183         int_to_apicintpin[irq].redirindex = 0;
1184         
1185         for (x = 0; x < nintrs; x++) {
1186                 if ((io_apic_ints[x].int_type == 0 || 
1187                      io_apic_ints[x].int_type == 3) &&
1188                     io_apic_ints[x].int_vector != 0xff &&
1189                     io_apic_ints[x].dst_apic_id == IO_TO_ID(oldapic) &&
1190                     io_apic_ints[x].dst_apic_int == oldintpin)
1191                         io_apic_ints[x].int_vector = 0xff;
1192         }
1193 }
1194
1195 /*
1196  * Allocate an IRQ 
1197  */
1198 static void
1199 allocate_apic_irq(int intr)
1200 {
1201         int apic;
1202         int intpin;
1203         int irq;
1204         
1205         if (io_apic_ints[intr].int_vector != 0xff)
1206                 return;         /* Interrupt handler already assigned */
1207         
1208         if (io_apic_ints[intr].int_type != 0 &&
1209             (io_apic_ints[intr].int_type != 3 ||
1210              (io_apic_ints[intr].dst_apic_id == IO_TO_ID(0) &&
1211               io_apic_ints[intr].dst_apic_int == 0)))
1212                 return;         /* Not INT or ExtInt on != (0, 0) */
1213         
1214         irq = 0;
1215         while (irq < APIC_INTMAPSIZE &&
1216                int_to_apicintpin[irq].ioapic != -1)
1217                 irq++;
1218         
1219         if (irq >= APIC_INTMAPSIZE)
1220                 return;         /* No free interrupt handlers */
1221         
1222         apic = ID_TO_IO(io_apic_ints[intr].dst_apic_id);
1223         intpin = io_apic_ints[intr].dst_apic_int;
1224         
1225         assign_apic_irq(apic, intpin, irq);
1226 }
1227
1228
1229 static void
1230 swap_apic_id(int apic, int oldid, int newid)
1231 {
1232         int x;
1233         int oapic;
1234         
1235
1236         if (oldid == newid)
1237                 return;                 /* Nothing to do */
1238         
1239         kprintf("Changing APIC ID for IO APIC #%d from %d to %d in MP table\n",
1240                apic, oldid, newid);
1241         
1242         /* Swap physical APIC IDs in interrupt entries */
1243         for (x = 0; x < nintrs; x++) {
1244                 if (io_apic_ints[x].dst_apic_id == oldid)
1245                         io_apic_ints[x].dst_apic_id = newid;
1246                 else if (io_apic_ints[x].dst_apic_id == newid)
1247                         io_apic_ints[x].dst_apic_id = oldid;
1248         }
1249         
1250         /* Swap physical APIC IDs in IO_TO_ID mappings */
1251         for (oapic = 0; oapic < mp_napics; oapic++)
1252                 if (IO_TO_ID(oapic) == newid)
1253                         break;
1254         
1255         if (oapic < mp_napics) {
1256                 kprintf("Changing APIC ID for IO APIC #%d from "
1257                        "%d to %d in MP table\n",
1258                        oapic, newid, oldid);
1259                 IO_TO_ID(oapic) = oldid;
1260         }
1261         IO_TO_ID(apic) = newid;
1262 }
1263
1264
1265 static void
1266 fix_id_to_io_mapping(void)
1267 {
1268         int x;
1269
1270         for (x = 0; x < NAPICID; x++)
1271                 ID_TO_IO(x) = -1;
1272         
1273         for (x = 0; x <= mp_naps; x++)
1274                 if (CPU_TO_ID(x) < NAPICID)
1275                         ID_TO_IO(CPU_TO_ID(x)) = x;
1276         
1277         for (x = 0; x < mp_napics; x++)
1278                 if (IO_TO_ID(x) < NAPICID)
1279                         ID_TO_IO(IO_TO_ID(x)) = x;
1280 }
1281
1282
1283 static int
1284 first_free_apic_id(void)
1285 {
1286         int freeid, x;
1287         
1288         for (freeid = 0; freeid < NAPICID; freeid++) {
1289                 for (x = 0; x <= mp_naps; x++)
1290                         if (CPU_TO_ID(x) == freeid)
1291                                 break;
1292                 if (x <= mp_naps)
1293                         continue;
1294                 for (x = 0; x < mp_napics; x++)
1295                         if (IO_TO_ID(x) == freeid)
1296                                 break;
1297                 if (x < mp_napics)
1298                         continue;
1299                 return freeid;
1300         }
1301         return freeid;
1302 }
1303
1304
1305 static int
1306 io_apic_id_acceptable(int apic, int id)
1307 {
1308         int cpu;                /* Logical CPU number */
1309         int oapic;              /* Logical IO APIC number for other IO APIC */
1310
1311         if (id >= NAPICID)
1312                 return 0;       /* Out of range */
1313         
1314         for (cpu = 0; cpu <= mp_naps; cpu++)
1315                 if (CPU_TO_ID(cpu) == id)
1316                         return 0;       /* Conflict with CPU */
1317         
1318         for (oapic = 0; oapic < mp_napics && oapic < apic; oapic++)
1319                 if (IO_TO_ID(oapic) == id)
1320                         return 0;       /* Conflict with other APIC */
1321         
1322         return 1;               /* ID is acceptable for IO APIC */
1323 }
1324
1325 static
1326 io_int *
1327 io_apic_find_int_entry(int apic, int pin)
1328 {
1329         int     x;
1330
1331         /* search each of the possible INTerrupt sources */
1332         for (x = 0; x < nintrs; ++x) {
1333                 if ((apic == ID_TO_IO(io_apic_ints[x].dst_apic_id)) &&
1334                     (pin == io_apic_ints[x].dst_apic_int))
1335                         return (&io_apic_ints[x]);
1336         }
1337         return NULL;
1338 }
1339
1340 #endif
1341
1342 /*
1343  * parse an Intel MP specification table
1344  */
1345 static void
1346 mptable_fix(void)
1347 {
1348         int     x;
1349 #ifdef APIC_IO
1350         int     id;
1351         int     apic;           /* IO APIC unit number */
1352         int     freeid;         /* Free physical APIC ID */
1353         int     physid;         /* Current physical IO APIC ID */
1354         io_int *io14;
1355 #endif
1356         int     bus_0 = 0;      /* Stop GCC warning */
1357         int     bus_pci = 0;    /* Stop GCC warning */
1358         int     num_pci_bus;
1359
1360         /*
1361          * Fix mis-numbering of the PCI bus and its INT entries if the BIOS
1362          * did it wrong.  The MP spec says that when more than 1 PCI bus
1363          * exists the BIOS must begin with bus entries for the PCI bus and use
1364          * actual PCI bus numbering.  This implies that when only 1 PCI bus
1365          * exists the BIOS can choose to ignore this ordering, and indeed many
1366          * MP motherboards do ignore it.  This causes a problem when the PCI
1367          * sub-system makes requests of the MP sub-system based on PCI bus
1368          * numbers.     So here we look for the situation and renumber the
1369          * busses and associated INTs in an effort to "make it right".
1370          */
1371
1372         /* find bus 0, PCI bus, count the number of PCI busses */
1373         for (num_pci_bus = 0, x = 0; x < mp_nbusses; ++x) {
1374                 if (bus_data[x].bus_id == 0) {
1375                         bus_0 = x;
1376                 }
1377                 if (bus_data[x].bus_type == PCI) {
1378                         ++num_pci_bus;
1379                         bus_pci = x;
1380                 }
1381         }
1382         /*
1383          * bus_0 == slot of bus with ID of 0
1384          * bus_pci == slot of last PCI bus encountered
1385          */
1386
1387         /* check the 1 PCI bus case for sanity */
1388         /* if it is number 0 all is well */
1389         if (num_pci_bus == 1 &&
1390             bus_data[bus_pci].bus_id != 0) {
1391                 
1392                 /* mis-numbered, swap with whichever bus uses slot 0 */
1393
1394                 /* swap the bus entry types */
1395                 bus_data[bus_pci].bus_type = bus_data[bus_0].bus_type;
1396                 bus_data[bus_0].bus_type = PCI;
1397
1398 #ifdef APIC_IO
1399                 /* swap each relavant INTerrupt entry */
1400                 id = bus_data[bus_pci].bus_id;
1401                 for (x = 0; x < nintrs; ++x) {
1402                         if (io_apic_ints[x].src_bus_id == id) {
1403                                 io_apic_ints[x].src_bus_id = 0;
1404                         }
1405                         else if (io_apic_ints[x].src_bus_id == 0) {
1406                                 io_apic_ints[x].src_bus_id = id;
1407                         }
1408                 }
1409 #endif
1410         }
1411
1412 #ifdef APIC_IO
1413         /* Assign IO APIC IDs.
1414          * 
1415          * First try the existing ID. If a conflict is detected, try
1416          * the ID in the MP table.  If a conflict is still detected, find
1417          * a free id.
1418          *
1419          * We cannot use the ID_TO_IO table before all conflicts has been
1420          * resolved and the table has been corrected.
1421          */
1422         for (apic = 0; apic < mp_napics; ++apic) { /* For all IO APICs */
1423                 
1424                 /* First try to use the value set by the BIOS */
1425                 physid = io_apic_get_id(apic);
1426                 if (io_apic_id_acceptable(apic, physid)) {
1427                         if (IO_TO_ID(apic) != physid)
1428                                 swap_apic_id(apic, IO_TO_ID(apic), physid);
1429                         continue;
1430                 }
1431
1432                 /* Then check if the value in the MP table is acceptable */
1433                 if (io_apic_id_acceptable(apic, IO_TO_ID(apic)))
1434                         continue;
1435
1436                 /* Last resort, find a free APIC ID and use it */
1437                 freeid = first_free_apic_id();
1438                 if (freeid >= NAPICID)
1439                         panic("No free physical APIC IDs found");
1440                 
1441                 if (io_apic_id_acceptable(apic, freeid)) {
1442                         swap_apic_id(apic, IO_TO_ID(apic), freeid);
1443                         continue;
1444                 }
1445                 panic("Free physical APIC ID not usable");
1446         }
1447         fix_id_to_io_mapping();
1448 #endif
1449
1450 #ifdef APIC_IO
1451         /* detect and fix broken Compaq MP table */
1452         if (apic_int_type(0, 0) == -1) {
1453                 kprintf("APIC_IO: MP table broken: 8259->APIC entry missing!\n");
1454                 io_apic_ints[nintrs].int_type = 3;      /* ExtInt */
1455                 io_apic_ints[nintrs].int_vector = 0xff; /* Unassigned */
1456                 /* XXX fixme, set src bus id etc, but it doesn't seem to hurt */
1457                 io_apic_ints[nintrs].dst_apic_id = IO_TO_ID(0);
1458                 io_apic_ints[nintrs].dst_apic_int = 0;  /* Pin 0 */
1459                 nintrs++;
1460         } else if (apic_int_type(0, 0) == 0) {
1461                 kprintf("APIC_IO: MP table broken: ExtINT entry corrupt!\n");
1462                 for (x = 0; x < nintrs; ++x)
1463                         if ((0 == ID_TO_IO(io_apic_ints[x].dst_apic_id)) &&
1464                             (0 == io_apic_ints[x].dst_apic_int)) {
1465                                 io_apic_ints[x].int_type = 3;
1466                                 io_apic_ints[x].int_vector = 0xff;
1467                                 break;
1468                         }
1469         }
1470
1471         /*
1472          * Fix missing IRQ 15 when IRQ 14 is an ISA interrupt.  IDE
1473          * controllers universally come in pairs.  If IRQ 14 is specified
1474          * as an ISA interrupt, then IRQ 15 had better be too.
1475          *
1476          * [ Shuttle XPC / AMD Athlon X2 ]
1477          *      The MPTable is missing an entry for IRQ 15.  Note that the
1478          *      ACPI table has an entry for both 14 and 15.
1479          */
1480         if (apic_int_type(0, 14) == 0 && apic_int_type(0, 15) == -1) {
1481                 kprintf("APIC_IO: MP table broken: IRQ 15 not ISA when IRQ 14 is!\n");
1482                 io14 = io_apic_find_int_entry(0, 14);
1483                 io_apic_ints[nintrs] = *io14;
1484                 io_apic_ints[nintrs].src_bus_irq = 15;
1485                 io_apic_ints[nintrs].dst_apic_int = 15;
1486                 nintrs++;
1487         }
1488 #endif
1489 }
1490
1491 #ifdef APIC_IO
1492
1493 /* Assign low level interrupt handlers */
1494 static void
1495 setup_apic_irq_mapping(void)
1496 {
1497         int     x;
1498         int     int_vector;
1499
1500         /* Clear array */
1501         for (x = 0; x < APIC_INTMAPSIZE; x++) {
1502                 int_to_apicintpin[x].ioapic = -1;
1503                 int_to_apicintpin[x].int_pin = 0;
1504                 int_to_apicintpin[x].apic_address = NULL;
1505                 int_to_apicintpin[x].redirindex = 0;
1506         }
1507
1508         /* First assign ISA/EISA interrupts */
1509         for (x = 0; x < nintrs; x++) {
1510                 int_vector = io_apic_ints[x].src_bus_irq;
1511                 if (int_vector < APIC_INTMAPSIZE &&
1512                     io_apic_ints[x].int_vector == 0xff && 
1513                     int_to_apicintpin[int_vector].ioapic == -1 &&
1514                     (apic_int_is_bus_type(x, ISA) ||
1515                      apic_int_is_bus_type(x, EISA)) &&
1516                     io_apic_ints[x].int_type == 0) {
1517                         assign_apic_irq(ID_TO_IO(io_apic_ints[x].dst_apic_id), 
1518                                         io_apic_ints[x].dst_apic_int,
1519                                         int_vector);
1520                 }
1521         }
1522
1523         /* Assign ExtInt entry if no ISA/EISA interrupt 0 entry */
1524         for (x = 0; x < nintrs; x++) {
1525                 if (io_apic_ints[x].dst_apic_int == 0 &&
1526                     io_apic_ints[x].dst_apic_id == IO_TO_ID(0) &&
1527                     io_apic_ints[x].int_vector == 0xff && 
1528                     int_to_apicintpin[0].ioapic == -1 &&
1529                     io_apic_ints[x].int_type == 3) {
1530                         assign_apic_irq(0, 0, 0);
1531                         break;
1532                 }
1533         }
1534
1535         /* Assign PCI interrupts */
1536         for (x = 0; x < nintrs; ++x) {
1537                 if (io_apic_ints[x].int_type == 0 &&
1538                     io_apic_ints[x].int_vector == 0xff && 
1539                     apic_int_is_bus_type(x, PCI))
1540                         allocate_apic_irq(x);
1541         }
1542 }
1543
1544 #endif
1545
1546 void
1547 mp_set_cpuids(int cpu_id, int apic_id)
1548 {
1549         CPU_TO_ID(cpu_id) = apic_id;
1550         ID_TO_CPU(apic_id) = cpu_id;
1551 }
1552
1553 static int
1554 processor_entry(proc_entry_ptr entry, int cpu)
1555 {
1556         KKASSERT(cpu > 0);
1557
1558         /* check for usability */
1559         if (!(entry->cpu_flags & PROCENTRY_FLAG_EN))
1560                 return 0;
1561
1562         if(entry->apic_id >= NAPICID)
1563                 panic("CPU APIC ID out of range (0..%d)", NAPICID - 1);
1564         /* check for BSP flag */
1565         if (entry->cpu_flags & PROCENTRY_FLAG_BP) {
1566                 mp_set_cpuids(0, entry->apic_id);
1567                 return 0;       /* its already been counted */
1568         }
1569
1570         /* add another AP to list, if less than max number of CPUs */
1571         else if (cpu < MAXCPU) {
1572                 mp_set_cpuids(cpu, entry->apic_id);
1573                 return 1;
1574         }
1575
1576         return 0;
1577 }
1578
1579
1580 static int
1581 bus_entry(bus_entry_ptr entry, int bus)
1582 {
1583         int     x;
1584         char    c, name[8];
1585
1586         /* encode the name into an index */
1587         for (x = 0; x < 6; ++x) {
1588                 if ((c = entry->bus_type[x]) == ' ')
1589                         break;
1590                 name[x] = c;
1591         }
1592         name[x] = '\0';
1593
1594         if ((x = lookup_bus_type(name)) == UNKNOWN_BUSTYPE)
1595                 panic("unknown bus type: '%s'", name);
1596
1597         bus_data[bus].bus_id = entry->bus_id;
1598         bus_data[bus].bus_type = x;
1599
1600         return 1;
1601 }
1602
1603 #ifdef APIC_IO
1604
1605 static int
1606 io_apic_entry(io_apic_entry_ptr entry, int apic)
1607 {
1608         if (!(entry->apic_flags & IOAPICENTRY_FLAG_EN))
1609                 return 0;
1610
1611         IO_TO_ID(apic) = entry->apic_id;
1612         if (entry->apic_id < NAPICID)
1613                 ID_TO_IO(entry->apic_id) = apic;
1614
1615         return 1;
1616 }
1617
1618 #endif
1619
1620 static int
1621 lookup_bus_type(char *name)
1622 {
1623         int     x;
1624
1625         for (x = 0; x < MAX_BUSTYPE; ++x)
1626                 if (strcmp(bus_type_table[x].name, name) == 0)
1627                         return bus_type_table[x].type;
1628
1629         return UNKNOWN_BUSTYPE;
1630 }
1631
1632 #ifdef APIC_IO
1633
1634 static int
1635 int_entry(int_entry_ptr entry, int intr)
1636 {
1637         int apic;
1638
1639         io_apic_ints[intr].int_type = entry->int_type;
1640         io_apic_ints[intr].int_flags = entry->int_flags;
1641         io_apic_ints[intr].src_bus_id = entry->src_bus_id;
1642         io_apic_ints[intr].src_bus_irq = entry->src_bus_irq;
1643         if (entry->dst_apic_id == 255) {
1644                 /* This signal goes to all IO APICS.  Select an IO APIC
1645                    with sufficient number of interrupt pins */
1646                 for (apic = 0; apic < mp_napics; apic++)
1647                         if (((io_apic_read(apic, IOAPIC_VER) & 
1648                               IOART_VER_MAXREDIR) >> MAXREDIRSHIFT) >= 
1649                             entry->dst_apic_int)
1650                                 break;
1651                 if (apic < mp_napics)
1652                         io_apic_ints[intr].dst_apic_id = IO_TO_ID(apic);
1653                 else
1654                         io_apic_ints[intr].dst_apic_id = entry->dst_apic_id;
1655         } else
1656                 io_apic_ints[intr].dst_apic_id = entry->dst_apic_id;
1657         io_apic_ints[intr].dst_apic_int = entry->dst_apic_int;
1658
1659         return 1;
1660 }
1661
1662 static int
1663 apic_int_is_bus_type(int intr, int bus_type)
1664 {
1665         int     bus;
1666
1667         for (bus = 0; bus < mp_nbusses; ++bus)
1668                 if ((bus_data[bus].bus_id == io_apic_ints[intr].src_bus_id)
1669                     && ((int) bus_data[bus].bus_type == bus_type))
1670                         return 1;
1671
1672         return 0;
1673 }
1674
1675 /*
1676  * Given a traditional ISA INT mask, return an APIC mask.
1677  */
1678 u_int
1679 isa_apic_mask(u_int isa_mask)
1680 {
1681         int isa_irq;
1682         int apic_pin;
1683
1684 #if defined(SKIP_IRQ15_REDIRECT)
1685         if (isa_mask == (1 << 15)) {
1686                 kprintf("skipping ISA IRQ15 redirect\n");
1687                 return isa_mask;
1688         }
1689 #endif  /* SKIP_IRQ15_REDIRECT */
1690
1691         isa_irq = ffs(isa_mask);                /* find its bit position */
1692         if (isa_irq == 0)                       /* doesn't exist */
1693                 return 0;
1694         --isa_irq;                              /* make it zero based */
1695
1696         apic_pin = isa_apic_irq(isa_irq);       /* look for APIC connection */
1697         if (apic_pin == -1)
1698                 return 0;
1699
1700         return (1 << apic_pin);                 /* convert pin# to a mask */
1701 }
1702
1703 /*
1704  * Determine which APIC pin an ISA/EISA INT is attached to.
1705  */
1706 #define INTTYPE(I)      (io_apic_ints[(I)].int_type)
1707 #define INTPIN(I)       (io_apic_ints[(I)].dst_apic_int)
1708 #define INTIRQ(I)       (io_apic_ints[(I)].int_vector)
1709 #define INTAPIC(I)      (ID_TO_IO(io_apic_ints[(I)].dst_apic_id))
1710
1711 #define SRCBUSIRQ(I)    (io_apic_ints[(I)].src_bus_irq)
1712 int
1713 isa_apic_irq(int isa_irq)
1714 {
1715         int     intr;
1716
1717         for (intr = 0; intr < nintrs; ++intr) {         /* check each record */
1718                 if (INTTYPE(intr) == 0) {               /* standard INT */
1719                         if (SRCBUSIRQ(intr) == isa_irq) {
1720                                 if (apic_int_is_bus_type(intr, ISA) ||
1721                                     apic_int_is_bus_type(intr, EISA)) {
1722                                         if (INTIRQ(intr) == 0xff)
1723                                                 return -1; /* unassigned */
1724                                         return INTIRQ(intr);    /* found */
1725                                 }
1726                         }
1727                 }
1728         }
1729         return -1;                                      /* NOT found */
1730 }
1731
1732
1733 /*
1734  * Determine which APIC pin a PCI INT is attached to.
1735  */
1736 #define SRCBUSID(I)     (io_apic_ints[(I)].src_bus_id)
1737 #define SRCBUSDEVICE(I) ((io_apic_ints[(I)].src_bus_irq >> 2) & 0x1f)
1738 #define SRCBUSLINE(I)   (io_apic_ints[(I)].src_bus_irq & 0x03)
1739 int
1740 pci_apic_irq(int pciBus, int pciDevice, int pciInt)
1741 {
1742         int     intr;
1743
1744         --pciInt;                                       /* zero based */
1745
1746         for (intr = 0; intr < nintrs; ++intr) {         /* check each record */
1747                 if ((INTTYPE(intr) == 0)                /* standard INT */
1748                     && (SRCBUSID(intr) == pciBus)
1749                     && (SRCBUSDEVICE(intr) == pciDevice)
1750                     && (SRCBUSLINE(intr) == pciInt)) {  /* a candidate IRQ */
1751                         if (apic_int_is_bus_type(intr, PCI)) {
1752                                 if (INTIRQ(intr) == 0xff) {
1753                                         kprintf("IOAPIC: pci_apic_irq() "
1754                                                 "failed\n");
1755                                         return -1;      /* unassigned */
1756                                 }
1757                                 return INTIRQ(intr);    /* exact match */
1758                         }
1759                 }
1760         }
1761
1762         return -1;                                      /* NOT found */
1763 }
1764
1765 int
1766 next_apic_irq(int irq) 
1767 {
1768         int intr, ointr;
1769         int bus, bustype;
1770
1771         bus = 0;
1772         bustype = 0;
1773         for (intr = 0; intr < nintrs; intr++) {
1774                 if (INTIRQ(intr) != irq || INTTYPE(intr) != 0)
1775                         continue;
1776                 bus = SRCBUSID(intr);
1777                 bustype = apic_bus_type(bus);
1778                 if (bustype != ISA &&
1779                     bustype != EISA &&
1780                     bustype != PCI)
1781                         continue;
1782                 break;
1783         }
1784         if (intr >= nintrs) {
1785                 return -1;
1786         }
1787         for (ointr = intr + 1; ointr < nintrs; ointr++) {
1788                 if (INTTYPE(ointr) != 0)
1789                         continue;
1790                 if (bus != SRCBUSID(ointr))
1791                         continue;
1792                 if (bustype == PCI) {
1793                         if (SRCBUSDEVICE(intr) != SRCBUSDEVICE(ointr))
1794                                 continue;
1795                         if (SRCBUSLINE(intr) != SRCBUSLINE(ointr))
1796                                 continue;
1797                 }
1798                 if (bustype == ISA || bustype == EISA) {
1799                         if (SRCBUSIRQ(intr) != SRCBUSIRQ(ointr))
1800                                 continue;
1801                 }
1802                 if (INTPIN(intr) == INTPIN(ointr))
1803                         continue;
1804                 break;
1805         }
1806         if (ointr >= nintrs) {
1807                 return -1;
1808         }
1809         return INTIRQ(ointr);
1810 }
1811 #undef SRCBUSLINE
1812 #undef SRCBUSDEVICE
1813 #undef SRCBUSID
1814 #undef SRCBUSIRQ
1815
1816 #undef INTPIN
1817 #undef INTIRQ
1818 #undef INTAPIC
1819 #undef INTTYPE
1820
1821 #endif
1822
1823 /*
1824  * Reprogram the MB chipset to NOT redirect an ISA INTerrupt.
1825  *
1826  * XXX FIXME:
1827  *  Exactly what this means is unclear at this point.  It is a solution
1828  *  for motherboards that redirect the MBIRQ0 pin.  Generically a motherboard
1829  *  could route any of the ISA INTs to upper (>15) IRQ values.  But most would
1830  *  NOT be redirected via MBIRQ0, thus "undirect()ing" them would NOT be an
1831  *  option.
1832  */
1833 int
1834 undirect_isa_irq(int rirq)
1835 {
1836 #if defined(READY)
1837         if (bootverbose)
1838             kprintf("Freeing redirected ISA irq %d.\n", rirq);
1839         /** FIXME: tickle the MB redirector chip */
1840         return /* XXX */;
1841 #else
1842         if (bootverbose)
1843             kprintf("Freeing (NOT implemented) redirected ISA irq %d.\n", rirq);
1844         return 0;
1845 #endif  /* READY */
1846 }
1847
1848
1849 /*
1850  * Reprogram the MB chipset to NOT redirect a PCI INTerrupt
1851  */
1852 int
1853 undirect_pci_irq(int rirq)
1854 {
1855 #if defined(READY)
1856         if (bootverbose)
1857                 kprintf("Freeing redirected PCI irq %d.\n", rirq);
1858
1859         /** FIXME: tickle the MB redirector chip */
1860         return /* XXX */;
1861 #else
1862         if (bootverbose)
1863                 kprintf("Freeing (NOT implemented) redirected PCI irq %d.\n",
1864                        rirq);
1865         return 0;
1866 #endif  /* READY */
1867 }
1868
1869
1870 /*
1871  * given a bus ID, return:
1872  *  the bus type if found
1873  *  -1 if NOT found
1874  */
1875 int
1876 apic_bus_type(int id)
1877 {
1878         int     x;
1879
1880         for (x = 0; x < mp_nbusses; ++x)
1881                 if (bus_data[x].bus_id == id)
1882                         return bus_data[x].bus_type;
1883
1884         return -1;
1885 }
1886
1887 #ifdef APIC_IO
1888
1889 /*
1890  * given a LOGICAL APIC# and pin#, return:
1891  *  the associated src bus ID if found
1892  *  -1 if NOT found
1893  */
1894 int
1895 apic_src_bus_id(int apic, int pin)
1896 {
1897         int     x;
1898
1899         /* search each of the possible INTerrupt sources */
1900         for (x = 0; x < nintrs; ++x)
1901                 if ((apic == ID_TO_IO(io_apic_ints[x].dst_apic_id)) &&
1902                     (pin == io_apic_ints[x].dst_apic_int))
1903                         return (io_apic_ints[x].src_bus_id);
1904
1905         return -1;              /* NOT found */
1906 }
1907
1908 /*
1909  * given a LOGICAL APIC# and pin#, return:
1910  *  the associated src bus IRQ if found
1911  *  -1 if NOT found
1912  */
1913 int
1914 apic_src_bus_irq(int apic, int pin)
1915 {
1916         int     x;
1917
1918         for (x = 0; x < nintrs; x++)
1919                 if ((apic == ID_TO_IO(io_apic_ints[x].dst_apic_id)) &&
1920                     (pin == io_apic_ints[x].dst_apic_int))
1921                         return (io_apic_ints[x].src_bus_irq);
1922
1923         return -1;              /* NOT found */
1924 }
1925
1926
1927 /*
1928  * given a LOGICAL APIC# and pin#, return:
1929  *  the associated INTerrupt type if found
1930  *  -1 if NOT found
1931  */
1932 int
1933 apic_int_type(int apic, int pin)
1934 {
1935         int     x;
1936
1937         /* search each of the possible INTerrupt sources */
1938         for (x = 0; x < nintrs; ++x) {
1939                 if ((apic == ID_TO_IO(io_apic_ints[x].dst_apic_id)) &&
1940                     (pin == io_apic_ints[x].dst_apic_int))
1941                         return (io_apic_ints[x].int_type);
1942         }
1943         return -1;              /* NOT found */
1944 }
1945
1946 /*
1947  * Return the IRQ associated with an APIC pin
1948  */
1949 int 
1950 apic_irq(int apic, int pin)
1951 {
1952         int x;
1953         int res;
1954
1955         for (x = 0; x < nintrs; ++x) {
1956                 if ((apic == ID_TO_IO(io_apic_ints[x].dst_apic_id)) &&
1957                     (pin == io_apic_ints[x].dst_apic_int)) {
1958                         res = io_apic_ints[x].int_vector;
1959                         if (res == 0xff)
1960                                 return -1;
1961                         if (apic != int_to_apicintpin[res].ioapic)
1962                                 panic("apic_irq: inconsistent table %d/%d", apic, int_to_apicintpin[res].ioapic);
1963                         if (pin != int_to_apicintpin[res].int_pin)
1964                                 panic("apic_irq inconsistent table (2)");
1965                         return res;
1966                 }
1967         }
1968         return -1;
1969 }
1970
1971
1972 /*
1973  * given a LOGICAL APIC# and pin#, return:
1974  *  the associated trigger mode if found
1975  *  -1 if NOT found
1976  */
1977 int
1978 apic_trigger(int apic, int pin)
1979 {
1980         int     x;
1981
1982         /* search each of the possible INTerrupt sources */
1983         for (x = 0; x < nintrs; ++x)
1984                 if ((apic == ID_TO_IO(io_apic_ints[x].dst_apic_id)) &&
1985                     (pin == io_apic_ints[x].dst_apic_int))
1986                         return ((io_apic_ints[x].int_flags >> 2) & 0x03);
1987
1988         return -1;              /* NOT found */
1989 }
1990
1991
1992 /*
1993  * given a LOGICAL APIC# and pin#, return:
1994  *  the associated 'active' level if found
1995  *  -1 if NOT found
1996  */
1997 int
1998 apic_polarity(int apic, int pin)
1999 {
2000         int     x;
2001
2002         /* search each of the possible INTerrupt sources */
2003         for (x = 0; x < nintrs; ++x)
2004                 if ((apic == ID_TO_IO(io_apic_ints[x].dst_apic_id)) &&
2005                     (pin == io_apic_ints[x].dst_apic_int))
2006                         return (io_apic_ints[x].int_flags & 0x03);
2007
2008         return -1;              /* NOT found */
2009 }
2010
2011 #endif
2012
2013 /*
2014  * set data according to MP defaults
2015  * FIXME: probably not complete yet...
2016  */
2017 static void
2018 mptable_default(int type)
2019 {
2020         int     ap_cpu_id, boot_cpu_id;
2021 #if defined(APIC_IO)
2022         int     io_apic_id;
2023         int     pin;
2024 #endif  /* APIC_IO */
2025
2026 #if 0
2027         kprintf("  MP default config type: %d\n", type);
2028         switch (type) {
2029         case 1:
2030                 kprintf("   bus: ISA, APIC: 82489DX\n");
2031                 break;
2032         case 2:
2033                 kprintf("   bus: EISA, APIC: 82489DX\n");
2034                 break;
2035         case 3:
2036                 kprintf("   bus: EISA, APIC: 82489DX\n");
2037                 break;
2038         case 4:
2039                 kprintf("   bus: MCA, APIC: 82489DX\n");
2040                 break;
2041         case 5:
2042                 kprintf("   bus: ISA+PCI, APIC: Integrated\n");
2043                 break;
2044         case 6:
2045                 kprintf("   bus: EISA+PCI, APIC: Integrated\n");
2046                 break;
2047         case 7:
2048                 kprintf("   bus: MCA+PCI, APIC: Integrated\n");
2049                 break;
2050         default:
2051                 kprintf("   future type\n");
2052                 break;
2053                 /* NOTREACHED */
2054         }
2055 #endif  /* 0 */
2056
2057         boot_cpu_id = (lapic->id & APIC_ID_MASK) >> 24;
2058         ap_cpu_id = (boot_cpu_id == 0) ? 1 : 0;
2059
2060         /* BSP */
2061         CPU_TO_ID(0) = boot_cpu_id;
2062         ID_TO_CPU(boot_cpu_id) = 0;
2063
2064         /* one and only AP */
2065         CPU_TO_ID(1) = ap_cpu_id;
2066         ID_TO_CPU(ap_cpu_id) = 1;
2067
2068 #if defined(APIC_IO)
2069         /* one and only IO APIC */
2070         io_apic_id = (io_apic_read(0, IOAPIC_ID) & APIC_ID_MASK) >> 24;
2071
2072         /*
2073          * sanity check, refer to MP spec section 3.6.6, last paragraph
2074          * necessary as some hardware isn't properly setting up the IO APIC
2075          */
2076 #if defined(REALLY_ANAL_IOAPICID_VALUE)
2077         if (io_apic_id != 2) {
2078 #else
2079         if ((io_apic_id == 0) || (io_apic_id == 1) || (io_apic_id == 15)) {
2080 #endif  /* REALLY_ANAL_IOAPICID_VALUE */
2081                 io_apic_set_id(0, 2);
2082                 io_apic_id = 2;
2083         }
2084         IO_TO_ID(0) = io_apic_id;
2085         ID_TO_IO(io_apic_id) = 0;
2086 #endif  /* APIC_IO */
2087
2088         /* fill out bus entries */
2089         switch (type) {
2090         case 1:
2091         case 2:
2092         case 3:
2093         case 4:
2094         case 5:
2095         case 6:
2096         case 7:
2097                 bus_data[0].bus_id = default_data[type - 1][1];
2098                 bus_data[0].bus_type = default_data[type - 1][2];
2099                 bus_data[1].bus_id = default_data[type - 1][3];
2100                 bus_data[1].bus_type = default_data[type - 1][4];
2101                 break;
2102
2103         /* case 4: case 7:                 MCA NOT supported */
2104         default:                /* illegal/reserved */
2105                 panic("BAD default MP config: %d", type);
2106                 /* NOTREACHED */
2107         }
2108
2109 #if defined(APIC_IO)
2110         /* general cases from MP v1.4, table 5-2 */
2111         for (pin = 0; pin < 16; ++pin) {
2112                 io_apic_ints[pin].int_type = 0;
2113                 io_apic_ints[pin].int_flags = 0x05;     /* edge/active-hi */
2114                 io_apic_ints[pin].src_bus_id = 0;
2115                 io_apic_ints[pin].src_bus_irq = pin;    /* IRQ2 caught below */
2116                 io_apic_ints[pin].dst_apic_id = io_apic_id;
2117                 io_apic_ints[pin].dst_apic_int = pin;   /* 1-to-1 */
2118         }
2119
2120         /* special cases from MP v1.4, table 5-2 */
2121         if (type == 2) {
2122                 io_apic_ints[2].int_type = 0xff;        /* N/C */
2123                 io_apic_ints[13].int_type = 0xff;       /* N/C */
2124 #if !defined(APIC_MIXED_MODE)
2125                 /** FIXME: ??? */
2126                 panic("sorry, can't support type 2 default yet");
2127 #endif  /* APIC_MIXED_MODE */
2128         }
2129         else
2130                 io_apic_ints[2].src_bus_irq = 0;        /* ISA IRQ0 is on APIC INT 2 */
2131
2132         if (type == 7)
2133                 io_apic_ints[0].int_type = 0xff;        /* N/C */
2134         else
2135                 io_apic_ints[0].int_type = 3;   /* vectored 8259 */
2136 #endif  /* APIC_IO */
2137 }
2138
2139 /*
2140  * Map a physical memory address representing I/O into KVA.  The I/O
2141  * block is assumed not to cross a page boundary.
2142  */
2143 void *
2144 permanent_io_mapping(vm_paddr_t pa)
2145 {
2146         KKASSERT(pa < 0x100000000LL);
2147
2148         return pmap_mapdev_uncacheable(pa, PAGE_SIZE);
2149 }
2150
2151 /*
2152  * start each AP in our list
2153  */
2154 static int
2155 start_all_aps(u_int boot_addr)
2156 {
2157         vm_offset_t va = boot_address + KERNBASE;
2158         u_int64_t *pt4, *pt3, *pt2;
2159         int     x, i, pg;
2160         int     shift;
2161         int     smicount;
2162         int     smibest;
2163         int     smilast;
2164         u_char  mpbiosreason;
2165         u_long  mpbioswarmvec;
2166         struct mdglobaldata *gd;
2167         struct privatespace *ps;
2168
2169         POSTCODE(START_ALL_APS_POST);
2170
2171         /* Initialize BSP's local APIC */
2172         apic_initialize(TRUE);
2173         bsp_apic_ready = 1;
2174
2175         /* install the AP 1st level boot code */
2176         pmap_kenter(va, boot_address);
2177         cpu_invlpg((void *)va);         /* JG XXX */
2178         bcopy(mptramp_start, (void *)va, bootMP_size);
2179
2180         /* Locate the page tables, they'll be below the trampoline */
2181         pt4 = (u_int64_t *)(uintptr_t)(mptramp_pagetables + KERNBASE);
2182         pt3 = pt4 + (PAGE_SIZE) / sizeof(u_int64_t);
2183         pt2 = pt3 + (PAGE_SIZE) / sizeof(u_int64_t);
2184
2185         /* Create the initial 1GB replicated page tables */
2186         for (i = 0; i < 512; i++) {
2187                 /* Each slot of the level 4 pages points to the same level 3 page */
2188                 pt4[i] = (u_int64_t)(uintptr_t)(mptramp_pagetables + PAGE_SIZE);
2189                 pt4[i] |= PG_V | PG_RW | PG_U;
2190
2191                 /* Each slot of the level 3 pages points to the same level 2 page */
2192                 pt3[i] = (u_int64_t)(uintptr_t)(mptramp_pagetables + (2 * PAGE_SIZE));
2193                 pt3[i] |= PG_V | PG_RW | PG_U;
2194
2195                 /* The level 2 page slots are mapped with 2MB pages for 1GB. */
2196                 pt2[i] = i * (2 * 1024 * 1024);
2197                 pt2[i] |= PG_V | PG_RW | PG_PS | PG_U;
2198         }
2199
2200         /* save the current value of the warm-start vector */
2201         mpbioswarmvec = *((u_int32_t *) WARMBOOT_OFF);
2202         outb(CMOS_REG, BIOS_RESET);
2203         mpbiosreason = inb(CMOS_DATA);
2204
2205         /* setup a vector to our boot code */
2206         *((volatile u_short *) WARMBOOT_OFF) = WARMBOOT_TARGET;
2207         *((volatile u_short *) WARMBOOT_SEG) = (boot_address >> 4);
2208         outb(CMOS_REG, BIOS_RESET);
2209         outb(CMOS_DATA, BIOS_WARM);     /* 'warm-start' */
2210
2211         /*
2212          * If we have a TSC we can figure out the SMI interrupt rate.
2213          * The SMI does not necessarily use a constant rate.  Spend
2214          * up to 250ms trying to figure it out.
2215          */
2216         smibest = 0;
2217         if (cpu_feature & CPUID_TSC) {
2218                 set_apic_timer(275000);
2219                 smilast = read_apic_timer();
2220                 for (x = 0; x < 20 && read_apic_timer(); ++x) {
2221                         smicount = smitest();
2222                         if (smibest == 0 || smilast - smicount < smibest)
2223                                 smibest = smilast - smicount;
2224                         smilast = smicount;
2225                 }
2226                 if (smibest > 250000)
2227                         smibest = 0;
2228                 if (smibest) {
2229                         smibest = smibest * (int64_t)1000000 /
2230                                   get_apic_timer_frequency();
2231                 }
2232         }
2233         if (smibest)
2234                 kprintf("SMI Frequency (worst case): %d Hz (%d us)\n",
2235                         1000000 / smibest, smibest);
2236
2237         /* start each AP */
2238         for (x = 1; x <= mp_naps; ++x) {
2239
2240                 /* This is a bit verbose, it will go away soon.  */
2241
2242                 /* first page of AP's private space */
2243                 pg = x * x86_64_btop(sizeof(struct privatespace));
2244
2245                 /* allocate new private data page(s) */
2246                 gd = (struct mdglobaldata *)kmem_alloc(&kernel_map, 
2247                                 MDGLOBALDATA_BASEALLOC_SIZE);
2248
2249                 gd = &CPU_prvspace[x].mdglobaldata;     /* official location */
2250                 bzero(gd, sizeof(*gd));
2251                 gd->mi.gd_prvspace = ps = &CPU_prvspace[x];
2252
2253                 /* prime data page for it to use */
2254                 mi_gdinit(&gd->mi, x);
2255                 cpu_gdinit(gd, x);
2256                 gd->gd_CMAP1 = &SMPpt[pg + 0];
2257                 gd->gd_CMAP2 = &SMPpt[pg + 1];
2258                 gd->gd_CMAP3 = &SMPpt[pg + 2];
2259                 gd->gd_PMAP1 = &SMPpt[pg + 3];
2260                 gd->gd_CADDR1 = ps->CPAGE1;
2261                 gd->gd_CADDR2 = ps->CPAGE2;
2262                 gd->gd_CADDR3 = ps->CPAGE3;
2263                 gd->gd_PADDR1 = (pt_entry_t *)ps->PPAGE1;
2264                 gd->mi.gd_ipiq = (void *)kmem_alloc(&kernel_map, sizeof(lwkt_ipiq) * (mp_naps + 1));
2265                 bzero(gd->mi.gd_ipiq, sizeof(lwkt_ipiq) * (mp_naps + 1));
2266
2267                 /* setup a vector to our boot code */
2268                 *((volatile u_short *) WARMBOOT_OFF) = WARMBOOT_TARGET;
2269                 *((volatile u_short *) WARMBOOT_SEG) = (boot_addr >> 4);
2270                 outb(CMOS_REG, BIOS_RESET);
2271                 outb(CMOS_DATA, BIOS_WARM);     /* 'warm-start' */
2272
2273                 /*
2274                  * Setup the AP boot stack
2275                  */
2276                 bootSTK = &ps->idlestack[UPAGES*PAGE_SIZE/2];
2277                 bootAP = x;
2278
2279                 /* attempt to start the Application Processor */
2280                 CHECK_INIT(99); /* setup checkpoints */
2281                 if (!start_ap(gd, boot_addr, smibest)) {
2282                         kprintf("AP #%d (PHY# %d) failed!\n", x, CPU_TO_ID(x));
2283                         CHECK_PRINT("trace");   /* show checkpoints */
2284                         /* better panic as the AP may be running loose */
2285                         kprintf("panic y/n? [y] ");
2286                         if (cngetc() != 'n')
2287                                 panic("bye-bye");
2288                 }
2289                 CHECK_PRINT("trace");           /* show checkpoints */
2290
2291                 /* record its version info */
2292                 cpu_apic_versions[x] = cpu_apic_versions[0];
2293         }
2294
2295         /* set ncpus to 1 + highest logical cpu.  Not all may have come up */
2296         ncpus = x;
2297
2298         /* ncpus2 -- ncpus rounded down to the nearest power of 2 */
2299         for (shift = 0; (1 << shift) <= ncpus; ++shift)
2300                 ;
2301         --shift;
2302         ncpus2_shift = shift;
2303         ncpus2 = 1 << shift;
2304         ncpus2_mask = ncpus2 - 1;
2305
2306         /* ncpus_fit -- ncpus rounded up to the nearest power of 2 */
2307         if ((1 << shift) < ncpus)
2308                 ++shift;
2309         ncpus_fit = 1 << shift;
2310         ncpus_fit_mask = ncpus_fit - 1;
2311
2312         /* build our map of 'other' CPUs */
2313         mycpu->gd_other_cpus = smp_startup_mask & ~(1 << mycpu->gd_cpuid);
2314         mycpu->gd_ipiq = (void *)kmem_alloc(&kernel_map, sizeof(lwkt_ipiq) * ncpus);
2315         bzero(mycpu->gd_ipiq, sizeof(lwkt_ipiq) * ncpus);
2316
2317         /* fill in our (BSP) APIC version */
2318         cpu_apic_versions[0] = lapic->version;
2319
2320         /* restore the warmstart vector */
2321         *(u_long *) WARMBOOT_OFF = mpbioswarmvec;
2322         outb(CMOS_REG, BIOS_RESET);
2323         outb(CMOS_DATA, mpbiosreason);
2324
2325         /*
2326          * NOTE!  The idlestack for the BSP was setup by locore.  Finish
2327          * up, clean out the P==V mapping we did earlier.
2328          */
2329         pmap_set_opt();
2330
2331         /* number of APs actually started */
2332         return ncpus - 1;
2333 }
2334
2335
2336 /*
2337  * load the 1st level AP boot code into base memory.
2338  */
2339
2340 /* targets for relocation */
2341 extern void bigJump(void);
2342 extern void bootCodeSeg(void);
2343 extern void bootDataSeg(void);
2344 extern void MPentry(void);
2345 extern u_int MP_GDT;
2346 extern u_int mp_gdtbase;
2347
2348 #if 0
2349
2350 static void
2351 install_ap_tramp(u_int boot_addr)
2352 {
2353         int     x;
2354         int     size = *(int *) ((u_long) & bootMP_size);
2355         u_char *src = (u_char *) ((u_long) bootMP);
2356         u_char *dst = (u_char *) boot_addr + KERNBASE;
2357         u_int   boot_base = (u_int) bootMP;
2358         u_int8_t *dst8;
2359         u_int16_t *dst16;
2360         u_int32_t *dst32;
2361
2362         POSTCODE(INSTALL_AP_TRAMP_POST);
2363
2364         for (x = 0; x < size; ++x)
2365                 *dst++ = *src++;
2366
2367         /*
2368          * modify addresses in code we just moved to basemem. unfortunately we
2369          * need fairly detailed info about mpboot.s for this to work.  changes
2370          * to mpboot.s might require changes here.
2371          */
2372
2373         /* boot code is located in KERNEL space */
2374         dst = (u_char *) boot_addr + KERNBASE;
2375
2376         /* modify the lgdt arg */
2377         dst32 = (u_int32_t *) (dst + ((u_int) & mp_gdtbase - boot_base));
2378         *dst32 = boot_addr + ((u_int) & MP_GDT - boot_base);
2379
2380         /* modify the ljmp target for MPentry() */
2381         dst32 = (u_int32_t *) (dst + ((u_int) bigJump - boot_base) + 1);
2382         *dst32 = ((u_int) MPentry - KERNBASE);
2383
2384         /* modify the target for boot code segment */
2385         dst16 = (u_int16_t *) (dst + ((u_int) bootCodeSeg - boot_base));
2386         dst8 = (u_int8_t *) (dst16 + 1);
2387         *dst16 = (u_int) boot_addr & 0xffff;
2388         *dst8 = ((u_int) boot_addr >> 16) & 0xff;
2389
2390         /* modify the target for boot data segment */
2391         dst16 = (u_int16_t *) (dst + ((u_int) bootDataSeg - boot_base));
2392         dst8 = (u_int8_t *) (dst16 + 1);
2393         *dst16 = (u_int) boot_addr & 0xffff;
2394         *dst8 = ((u_int) boot_addr >> 16) & 0xff;
2395 }
2396
2397 #endif
2398
2399 /*
2400  * This function starts the AP (application processor) identified
2401  * by the APIC ID 'physicalCpu'.  It does quite a "song and dance"
2402  * to accomplish this.  This is necessary because of the nuances
2403  * of the different hardware we might encounter.  It ain't pretty,
2404  * but it seems to work.
2405  *
2406  * NOTE: eventually an AP gets to ap_init(), which is called just 
2407  * before the AP goes into the LWKT scheduler's idle loop.
2408  */
2409 static int
2410 start_ap(struct mdglobaldata *gd, u_int boot_addr, int smibest)
2411 {
2412         int     physical_cpu;
2413         int     vector;
2414         u_long  icr_lo, icr_hi;
2415
2416         POSTCODE(START_AP_POST);
2417
2418         /* get the PHYSICAL APIC ID# */
2419         physical_cpu = CPU_TO_ID(gd->mi.gd_cpuid);
2420
2421         /* calculate the vector */
2422         vector = (boot_addr >> 12) & 0xff;
2423
2424         /* We don't want anything interfering */
2425         cpu_disable_intr();
2426
2427         /* Make sure the target cpu sees everything */
2428         wbinvd();
2429
2430         /*
2431          * Try to detect when a SMI has occurred, wait up to 200ms.
2432          *
2433          * If a SMI occurs during an AP reset but before we issue
2434          * the STARTUP command, the AP may brick.  To work around
2435          * this problem we hold off doing the AP startup until
2436          * after we have detected the SMI.  Hopefully another SMI
2437          * will not occur before we finish the AP startup.
2438          *
2439          * Retries don't seem to help.  SMIs have a window of opportunity
2440          * and if USB->legacy keyboard emulation is enabled in the BIOS
2441          * the interrupt rate can be quite high.
2442          *
2443          * NOTE: Don't worry about the L1 cache load, it might bloat
2444          *       ldelta a little but ndelta will be so huge when the SMI
2445          *       occurs the detection logic will still work fine.
2446          */
2447         if (smibest) {
2448                 set_apic_timer(200000);
2449                 smitest();
2450         }
2451
2452         /*
2453          * first we do an INIT/RESET IPI this INIT IPI might be run, reseting
2454          * and running the target CPU. OR this INIT IPI might be latched (P5
2455          * bug), CPU waiting for STARTUP IPI. OR this INIT IPI might be
2456          * ignored.
2457          *
2458          * see apic/apicreg.h for icr bit definitions.
2459          *
2460          * TIME CRITICAL CODE, DO NOT DO ANY KPRINTFS IN THE HOT PATH.
2461          */
2462
2463         /*
2464          * Setup the address for the target AP.  We can setup
2465          * icr_hi once and then just trigger operations with
2466          * icr_lo.
2467          */
2468         icr_hi = lapic->icr_hi & ~APIC_ID_MASK;
2469         icr_hi |= (physical_cpu << 24);
2470         icr_lo = lapic->icr_lo & 0xfff00000;
2471         lapic->icr_hi = icr_hi;
2472
2473         /*
2474          * Do an INIT IPI: assert RESET
2475          *
2476          * Use edge triggered mode to assert INIT
2477          */
2478         lapic->icr_lo = icr_lo | 0x00004500;
2479         while (lapic->icr_lo & APIC_DELSTAT_MASK)
2480                  /* spin */ ;
2481
2482         /*
2483          * The spec calls for a 10ms delay but we may have to use a
2484          * MUCH lower delay to avoid bricking an AP due to a fast SMI
2485          * interrupt.  We have other loops here too and dividing by 2
2486          * doesn't seem to be enough even after subtracting 350us,
2487          * so we divide by 4.
2488          *
2489          * Our minimum delay is 150uS, maximum is 10ms.  If no SMI
2490          * interrupt was detected we use the full 10ms.
2491          */
2492         if (smibest == 0)
2493                 u_sleep(10000);
2494         else if (smibest < 150 * 4 + 350)
2495                 u_sleep(150);
2496         else if ((smibest - 350) / 4 < 10000)
2497                 u_sleep((smibest - 350) / 4);
2498         else
2499                 u_sleep(10000);
2500
2501         /*
2502          * Do an INIT IPI: deassert RESET
2503          *
2504          * Use level triggered mode to deassert.  It is unclear
2505          * why we need to do this.
2506          */
2507         lapic->icr_lo = icr_lo | 0x00008500;
2508         while (lapic->icr_lo & APIC_DELSTAT_MASK)
2509                  /* spin */ ;
2510         u_sleep(150);                           /* wait 150us */
2511
2512         /*
2513          * Next we do a STARTUP IPI: the previous INIT IPI might still be
2514          * latched, (P5 bug) this 1st STARTUP would then terminate
2515          * immediately, and the previously started INIT IPI would continue. OR
2516          * the previous INIT IPI has already run. and this STARTUP IPI will
2517          * run. OR the previous INIT IPI was ignored. and this STARTUP IPI
2518          * will run.
2519          */
2520         lapic->icr_lo = icr_lo | 0x00000600 | vector;
2521         while (lapic->icr_lo & APIC_DELSTAT_MASK)
2522                  /* spin */ ;
2523         u_sleep(200);           /* wait ~200uS */
2524
2525         /*
2526          * Finally we do a 2nd STARTUP IPI: this 2nd STARTUP IPI should run IF
2527          * the previous STARTUP IPI was cancelled by a latched INIT IPI. OR
2528          * this STARTUP IPI will be ignored, as only ONE STARTUP IPI is
2529          * recognized after hardware RESET or INIT IPI.
2530          */
2531         lapic->icr_lo = icr_lo | 0x00000600 | vector;
2532         while (lapic->icr_lo & APIC_DELSTAT_MASK)
2533                  /* spin */ ;
2534
2535         /* Resume normal operation */
2536         cpu_enable_intr();
2537
2538         /* wait for it to start, see ap_init() */
2539         set_apic_timer(5000000);/* == 5 seconds */
2540         while (read_apic_timer()) {
2541                 if (smp_startup_mask & (1 << gd->mi.gd_cpuid))
2542                         return 1;       /* return SUCCESS */
2543         }
2544
2545         return 0;               /* return FAILURE */
2546 }
2547
2548 static
2549 int
2550 smitest(void)
2551 {
2552         int64_t ltsc;
2553         int64_t ntsc;
2554         int64_t ldelta;
2555         int64_t ndelta;
2556         int count;
2557
2558         ldelta = 0;
2559         ndelta = 0;
2560         while (read_apic_timer()) {
2561                 ltsc = rdtsc();
2562                 for (count = 0; count < 100; ++count)
2563                         ntsc = rdtsc(); /* force loop to occur */
2564                 if (ldelta) {
2565                         ndelta = ntsc - ltsc;
2566                         if (ldelta > ndelta)
2567                                 ldelta = ndelta;
2568                         if (ndelta > ldelta * 2)
2569                                 break;
2570                 } else {
2571                         ldelta = ntsc - ltsc;
2572                 }
2573         }
2574         return(read_apic_timer());
2575 }
2576
2577 /*
2578  * Lazy flush the TLB on all other CPU's.  DEPRECATED.
2579  *
2580  * If for some reason we were unable to start all cpus we cannot safely
2581  * use broadcast IPIs.
2582  */
2583 void
2584 smp_invltlb(void)
2585 {
2586 #ifdef SMP
2587         if (smp_startup_mask == smp_active_mask) {
2588                 all_but_self_ipi(XINVLTLB_OFFSET);
2589         } else {
2590                 selected_apic_ipi(smp_active_mask, XINVLTLB_OFFSET,
2591                         APIC_DELMODE_FIXED);
2592         }
2593 #endif
2594 }
2595
2596 /*
2597  * When called the executing CPU will send an IPI to all other CPUs
2598  *  requesting that they halt execution.
2599  *
2600  * Usually (but not necessarily) called with 'other_cpus' as its arg.
2601  *
2602  *  - Signals all CPUs in map to stop.
2603  *  - Waits for each to stop.
2604  *
2605  * Returns:
2606  *  -1: error
2607  *   0: NA
2608  *   1: ok
2609  *
2610  * XXX FIXME: this is not MP-safe, needs a lock to prevent multiple CPUs
2611  *            from executing at same time.
2612  */
2613 int
2614 stop_cpus(u_int map)
2615 {
2616         map &= smp_active_mask;
2617
2618         /* send the Xcpustop IPI to all CPUs in map */
2619         selected_apic_ipi(map, XCPUSTOP_OFFSET, APIC_DELMODE_FIXED);
2620         
2621         while ((stopped_cpus & map) != map)
2622                 /* spin */ ;
2623
2624         return 1;
2625 }
2626
2627
2628 /*
2629  * Called by a CPU to restart stopped CPUs. 
2630  *
2631  * Usually (but not necessarily) called with 'stopped_cpus' as its arg.
2632  *
2633  *  - Signals all CPUs in map to restart.
2634  *  - Waits for each to restart.
2635  *
2636  * Returns:
2637  *  -1: error
2638  *   0: NA
2639  *   1: ok
2640  */
2641 int
2642 restart_cpus(u_int map)
2643 {
2644         /* signal other cpus to restart */
2645         started_cpus = map & smp_active_mask;
2646
2647         while ((stopped_cpus & map) != 0) /* wait for each to clear its bit */
2648                 /* spin */ ;
2649
2650         return 1;
2651 }
2652
2653 /*
2654  * This is called once the mpboot code has gotten us properly relocated
2655  * and the MMU turned on, etc.   ap_init() is actually the idle thread,
2656  * and when it returns the scheduler will call the real cpu_idle() main
2657  * loop for the idlethread.  Interrupts are disabled on entry and should
2658  * remain disabled at return.
2659  */
2660 void
2661 ap_init(void)
2662 {
2663         u_int   apic_id;
2664
2665         /*
2666          * Adjust smp_startup_mask to signal the BSP that we have started
2667          * up successfully.  Note that we do not yet hold the BGL.  The BSP
2668          * is waiting for our signal.
2669          *
2670          * We can't set our bit in smp_active_mask yet because we are holding
2671          * interrupts physically disabled and remote cpus could deadlock
2672          * trying to send us an IPI.
2673          */
2674         smp_startup_mask |= 1 << mycpu->gd_cpuid;
2675         cpu_mfence();
2676
2677         /*
2678          * Interlock for finalization.  Wait until mp_finish is non-zero,
2679          * then get the MP lock.
2680          *
2681          * Note: We are in a critical section.
2682          *
2683          * Note: We have to synchronize td_mpcount to our desired MP state
2684          * before calling cpu_try_mplock().
2685          *
2686          * Note: we are the idle thread, we can only spin.
2687          *
2688          * Note: The load fence is memory volatile and prevents the compiler
2689          * from improperly caching mp_finish, and the cpu from improperly
2690          * caching it.
2691          */
2692         while (mp_finish == 0)
2693             cpu_lfence();
2694         ++curthread->td_mpcount;
2695         while (cpu_try_mplock() == 0)
2696             ;
2697
2698         if (cpu_feature & CPUID_TSC) {
2699             /*
2700              * The BSP is constantly updating tsc0_offset, figure out the
2701              * relative difference to synchronize ktrdump.
2702              */
2703             tsc_offsets[mycpu->gd_cpuid] = rdtsc() - tsc0_offset;
2704         }
2705
2706         /* BSP may have changed PTD while we're waiting for the lock */
2707         cpu_invltlb();
2708
2709 #if defined(I586_CPU) && !defined(NO_F00F_HACK)
2710         lidt(&r_idt);
2711 #endif
2712
2713         /* Build our map of 'other' CPUs. */
2714         mycpu->gd_other_cpus = smp_startup_mask & ~(1 << mycpu->gd_cpuid);
2715
2716         kprintf("SMP: AP CPU #%d Launched!\n", mycpu->gd_cpuid);
2717
2718         /* A quick check from sanity claus */
2719         apic_id = (apic_id_to_logical[(lapic->id & 0x0f000000) >> 24]);
2720         if (mycpu->gd_cpuid != apic_id) {
2721                 kprintf("SMP: cpuid = %d\n", mycpu->gd_cpuid);
2722                 kprintf("SMP: apic_id = %d\n", apic_id);
2723 #if JGXXX
2724                 kprintf("PTD[MPPTDI] = %p\n", (void *)PTD[MPPTDI]);
2725 #endif
2726                 panic("cpuid mismatch! boom!!");
2727         }
2728
2729         /* Initialize AP's local APIC for irq's */
2730         apic_initialize(FALSE);
2731
2732         /* Set memory range attributes for this CPU to match the BSP */
2733         mem_range_AP_init();
2734
2735         /*
2736          * Once we go active we must process any IPIQ messages that may
2737          * have been queued, because no actual IPI will occur until we
2738          * set our bit in the smp_active_mask.  If we don't the IPI
2739          * message interlock could be left set which would also prevent
2740          * further IPIs.
2741          *
2742          * The idle loop doesn't expect the BGL to be held and while
2743          * lwkt_switch() normally cleans things up this is a special case
2744          * because we returning almost directly into the idle loop.
2745          *
2746          * The idle thread is never placed on the runq, make sure
2747          * nothing we've done put it there.
2748          */
2749         KKASSERT(curthread->td_mpcount == 1);
2750         smp_active_mask |= 1 << mycpu->gd_cpuid;
2751
2752         /*
2753          * Enable interrupts here.  idle_restore will also do it, but
2754          * doing it here lets us clean up any strays that got posted to
2755          * the CPU during the AP boot while we are still in a critical
2756          * section.
2757          */
2758         __asm __volatile("sti; pause; pause"::);
2759         mdcpu->gd_fpending = 0;
2760
2761         initclocks_pcpu();      /* clock interrupts (via IPIs) */
2762         lwkt_process_ipiq();
2763
2764         /*
2765          * Releasing the mp lock lets the BSP finish up the SMP init
2766          */
2767         rel_mplock();
2768         KKASSERT((curthread->td_flags & TDF_RUNQ) == 0);
2769 }
2770
2771 /*
2772  * Get SMP fully working before we start initializing devices.
2773  */
2774 static
2775 void
2776 ap_finish(void)
2777 {
2778         mp_finish = 1;
2779         if (bootverbose)
2780                 kprintf("Finish MP startup\n");
2781         if (cpu_feature & CPUID_TSC)
2782                 tsc0_offset = rdtsc();
2783         tsc_offsets[0] = 0;
2784         rel_mplock();
2785         while (smp_active_mask != smp_startup_mask) {
2786                 cpu_lfence();
2787                 if (cpu_feature & CPUID_TSC)
2788                         tsc0_offset = rdtsc();
2789         }
2790         while (try_mplock() == 0)
2791                 ;
2792         if (bootverbose)
2793                 kprintf("Active CPU Mask: %08x\n", smp_active_mask);
2794 }
2795
2796 SYSINIT(finishsmp, SI_BOOT2_FINISH_SMP, SI_ORDER_FIRST, ap_finish, NULL)
2797
2798 void
2799 cpu_send_ipiq(int dcpu)
2800 {
2801         if ((1 << dcpu) & smp_active_mask)
2802                 single_apic_ipi(dcpu, XIPIQ_OFFSET, APIC_DELMODE_FIXED);
2803 }
2804
2805 #if 0   /* single_apic_ipi_passive() not working yet */
2806 /*
2807  * Returns 0 on failure, 1 on success
2808  */
2809 int
2810 cpu_send_ipiq_passive(int dcpu)
2811 {
2812         int r = 0;
2813         if ((1 << dcpu) & smp_active_mask) {
2814                 r = single_apic_ipi_passive(dcpu, XIPIQ_OFFSET,
2815                                         APIC_DELMODE_FIXED);
2816         }
2817         return(r);
2818 }
2819 #endif
2820