30062938e715d126a5d97ea64c8b4f15cc529de8
[dragonfly.git] / sys / platform / pc32 / i386 / 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 <vm/vm.h>
41 #include <vm/vm_param.h>
42 #include <vm/pmap.h>
43 #include <vm/vm_kern.h>
44 #include <vm/vm_extern.h>
45 #include <sys/lock.h>
46 #include <vm/vm_map.h>
47 #include <sys/user.h>
48 #ifdef GPROF 
49 #include <sys/gmon.h>
50 #endif
51
52 #include <sys/mplock2.h>
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/cputypes.h>
59 #include <machine_base/apic/ioapic_abi.h>
60 #include <machine_base/apic/mpapic.h>
61 #include <machine/psl.h>
62 #include <machine/segments.h>
63 #include <machine/tss.h>
64 #include <machine/specialreg.h>
65 #include <machine/globaldata.h>
66 #include <machine/pmap_inval.h>
67
68 #include <machine/md_var.h>             /* setidt() */
69 #include <machine_base/icu/icu.h>       /* IPIs */
70 #include <machine/intr_machdep.h>       /* IPIs */
71
72 #define FIXUP_EXTRA_APIC_INTS   8       /* additional entries we may create */
73
74 #define WARMBOOT_TARGET         0
75 #define WARMBOOT_OFF            (KERNBASE + 0x0467)
76 #define WARMBOOT_SEG            (KERNBASE + 0x0469)
77
78 #define BIOS_BASE               (0xf0000)
79 #define BIOS_BASE2              (0xe0000)
80 #define BIOS_SIZE               (0x10000)
81 #define BIOS_COUNT              (BIOS_SIZE/4)
82
83 #define CMOS_REG                (0x70)
84 #define CMOS_DATA               (0x71)
85 #define BIOS_RESET              (0x0f)
86 #define BIOS_WARM               (0x0a)
87
88 #define PROCENTRY_FLAG_EN       0x01
89 #define PROCENTRY_FLAG_BP       0x02
90 #define IOAPICENTRY_FLAG_EN     0x01
91
92
93 /* MP Floating Pointer Structure */
94 typedef struct MPFPS {
95         char    signature[4];
96         u_int32_t pap;
97         u_char  length;
98         u_char  spec_rev;
99         u_char  checksum;
100         u_char  mpfb1;
101         u_char  mpfb2;
102         u_char  mpfb3;
103         u_char  mpfb4;
104         u_char  mpfb5;
105 }      *mpfps_t;
106
107 /* MP Configuration Table Header */
108 typedef struct MPCTH {
109         char    signature[4];
110         u_short base_table_length;
111         u_char  spec_rev;
112         u_char  checksum;
113         u_char  oem_id[8];
114         u_char  product_id[12];
115         void   *oem_table_pointer;
116         u_short oem_table_size;
117         u_short entry_count;
118         void   *apic_address;
119         u_short extended_table_length;
120         u_char  extended_table_checksum;
121         u_char  reserved;
122 }      *mpcth_t;
123
124
125 typedef struct PROCENTRY {
126         u_char  type;
127         u_char  apic_id;
128         u_char  apic_version;
129         u_char  cpu_flags;
130         u_long  cpu_signature;
131         u_long  feature_flags;
132         u_long  reserved1;
133         u_long  reserved2;
134 }      *proc_entry_ptr;
135
136 typedef struct BUSENTRY {
137         u_char  type;
138         u_char  bus_id;
139         char    bus_type[6];
140 }      *bus_entry_ptr;
141
142 typedef struct IOAPICENTRY {
143         u_char  type;
144         u_char  apic_id;
145         u_char  apic_version;
146         u_char  apic_flags;
147         void   *apic_address;
148 }      *io_apic_entry_ptr;
149
150 typedef struct INTENTRY {
151         u_char  type;
152         u_char  int_type;
153         u_short int_flags;
154         u_char  src_bus_id;
155         u_char  src_bus_irq;
156         u_char  dst_apic_id;
157         u_char  dst_apic_int;
158 }      *int_entry_ptr;
159
160 /* descriptions of MP basetable entries */
161 typedef struct BASETABLE_ENTRY {
162         u_char  type;
163         u_char  length;
164         char    name[16];
165 }       basetable_entry;
166
167 struct mptable_pos {
168         mpfps_t         mp_fps;
169         mpcth_t         mp_cth;
170         vm_size_t       mp_cth_mapsz;
171 };
172
173 #define MPTABLE_POS_USE_DEFAULT(mpt) \
174         ((mpt)->mp_fps->mpfb1 != 0 || (mpt)->mp_cth == NULL)
175
176 struct mptable_bus {
177         int             mb_id;
178         int             mb_type;        /* MPTABLE_BUS_ */
179         TAILQ_ENTRY(mptable_bus) mb_link;
180 };
181
182 #define MPTABLE_BUS_ISA         0
183 #define MPTABLE_BUS_PCI         1
184
185 struct mptable_bus_info {
186         TAILQ_HEAD(, mptable_bus) mbi_list;
187 };
188
189 struct mptable_pci_int {
190         int             mpci_bus;
191         int             mpci_dev;
192         int             mpci_pin;
193
194         int             mpci_ioapic_idx;
195         int             mpci_ioapic_pin;
196         TAILQ_ENTRY(mptable_pci_int) mpci_link;
197 };
198
199 struct mptable_ioapic {
200         int             mio_idx;
201         int             mio_apic_id;
202         uint32_t        mio_addr;
203         int             mio_gsi_base;
204         int             mio_npin;
205         TAILQ_ENTRY(mptable_ioapic) mio_link;
206 };
207
208 typedef int     (*mptable_iter_func)(void *, const void *, int);
209
210 /*
211  * this code MUST be enabled here and in mpboot.s.
212  * it follows the very early stages of AP boot by placing values in CMOS ram.
213  * it NORMALLY will never be needed and thus the primitive method for enabling.
214  *
215  */
216 #if defined(CHECK_POINTS)
217 #define CHECK_READ(A)    (outb(CMOS_REG, (A)), inb(CMOS_DATA))
218 #define CHECK_WRITE(A,D) (outb(CMOS_REG, (A)), outb(CMOS_DATA, (D)))
219
220 #define CHECK_INIT(D);                          \
221         CHECK_WRITE(0x34, (D));                 \
222         CHECK_WRITE(0x35, (D));                 \
223         CHECK_WRITE(0x36, (D));                 \
224         CHECK_WRITE(0x37, (D));                 \
225         CHECK_WRITE(0x38, (D));                 \
226         CHECK_WRITE(0x39, (D));
227
228 #define CHECK_PRINT(S);                         \
229         kprintf("%s: %d, %d, %d, %d, %d, %d\n", \
230            (S),                                 \
231            CHECK_READ(0x34),                    \
232            CHECK_READ(0x35),                    \
233            CHECK_READ(0x36),                    \
234            CHECK_READ(0x37),                    \
235            CHECK_READ(0x38),                    \
236            CHECK_READ(0x39));
237
238 #else                           /* CHECK_POINTS */
239
240 #define CHECK_INIT(D)
241 #define CHECK_PRINT(S)
242
243 #endif                          /* CHECK_POINTS */
244
245 /*
246  * Values to send to the POST hardware.
247  */
248 #define MP_BOOTADDRESS_POST     0x10
249 #define MP_PROBE_POST           0x11
250 #define MPTABLE_PASS1_POST      0x12
251
252 #define MP_START_POST           0x13
253 #define MP_ENABLE_POST          0x14
254 #define MPTABLE_PASS2_POST      0x15
255
256 #define START_ALL_APS_POST      0x16
257 #define INSTALL_AP_TRAMP_POST   0x17
258 #define START_AP_POST           0x18
259
260 #define MP_ANNOUNCE_POST        0x19
261
262 /** XXX FIXME: where does this really belong, isa.h/isa.c perhaps? */
263 int     current_postcode;
264
265 /** XXX FIXME: what system files declare these??? */
266 extern struct region_descriptor r_gdt, r_idt;
267
268 int     mp_naps;                /* # of Applications processors */
269 extern  int nkpt;
270
271 u_int32_t cpu_apic_versions[MAXCPU];
272 int64_t tsc0_offset;
273 extern int64_t tsc_offsets[];
274
275 extern u_long ebda_addr;
276
277 #ifdef SMP /* APIC-IO */
278 struct apic_intmapinfo  int_to_apicintpin[APIC_INTMAPSIZE];
279 #endif
280
281 /*
282  * APIC ID logical/physical mapping structures.
283  * We oversize these to simplify boot-time config.
284  */
285 int     cpu_num_to_apic_id[NAPICID];
286 int     apic_id_to_logical[NAPICID];
287
288 /* AP uses this during bootstrap.  Do not staticize.  */
289 char *bootSTK;
290 static int bootAP;
291
292 /* Hotwire a 0->4MB V==P mapping */
293 extern pt_entry_t *KPTphys;
294
295 /*
296  * SMP page table page.  Setup by locore to point to a page table
297  * page from which we allocate per-cpu privatespace areas io_apics,
298  * and so forth.
299  */
300
301 #define IO_MAPPING_START_INDEX  \
302                 (SMP_MAXCPU * sizeof(struct privatespace) / PAGE_SIZE)
303
304 extern pt_entry_t *SMPpt;
305 static int SMPpt_alloc_index = IO_MAPPING_START_INDEX;
306
307 struct pcb stoppcbs[MAXCPU];
308
309 static basetable_entry basetable_entry_types[] =
310 {
311         {0, 20, "Processor"},
312         {1, 8, "Bus"},
313         {2, 8, "I/O APIC"},
314         {3, 8, "I/O INT"},
315         {4, 8, "Local INT"}
316 };
317
318 /*
319  * Local data and functions.
320  */
321
322 static u_int    boot_address;
323 static u_int    base_memory;
324 static int      mp_finish;
325 static int      mp_finish_lapic;
326
327 static void     mp_enable(u_int boot_addr);
328
329 static int      mptable_iterate_entries(const mpcth_t,
330                     mptable_iter_func, void *);
331 static int      mptable_search(void);
332 static int      mptable_search_sig(u_int32_t target, int count);
333 static int      mptable_hyperthread_fixup(cpumask_t, int);
334 static int      mptable_map(struct mptable_pos *);
335 static void     mptable_unmap(struct mptable_pos *);
336 static void     mptable_bus_info_alloc(const mpcth_t,
337                     struct mptable_bus_info *);
338 static void     mptable_bus_info_free(struct mptable_bus_info *);
339
340 static int      mptable_lapic_probe(struct lapic_enumerator *);
341 static void     mptable_lapic_enumerate(struct lapic_enumerator *);
342 static void     mptable_lapic_default(void);
343
344 static int      mptable_ioapic_probe(struct ioapic_enumerator *);
345 static void     mptable_ioapic_enumerate(struct ioapic_enumerator *);
346
347 static int      start_all_aps(u_int boot_addr);
348 static void     install_ap_tramp(u_int boot_addr);
349 static int      start_ap(struct mdglobaldata *gd, u_int boot_addr, int smibest);
350 static int      smitest(void);
351
352 static cpumask_t smp_startup_mask = 1;  /* which cpus have been started */
353 static cpumask_t smp_lapic_mask = 1;    /* which cpus have lapic been inited */
354 cpumask_t smp_active_mask = 1;  /* which cpus are ready for IPIs etc? */
355 SYSCTL_INT(_machdep, OID_AUTO, smp_active, CTLFLAG_RD, &smp_active_mask, 0, "");
356
357 int                     imcr_present;
358
359 static vm_paddr_t       mptable_fps_phyaddr;
360 static int              mptable_use_default;
361 static TAILQ_HEAD(mptable_pci_int_list, mptable_pci_int) mptable_pci_int_list =
362         TAILQ_HEAD_INITIALIZER(mptable_pci_int_list);
363 static TAILQ_HEAD(mptable_ioapic_list, mptable_ioapic) mptable_ioapic_list =
364         TAILQ_HEAD_INITIALIZER(mptable_ioapic_list);
365
366 /*
367  * Calculate usable address in base memory for AP trampoline code.
368  */
369 u_int
370 mp_bootaddress(u_int basemem)
371 {
372         POSTCODE(MP_BOOTADDRESS_POST);
373
374         base_memory = basemem;
375
376         boot_address = base_memory & ~0xfff;    /* round down to 4k boundary */
377         if ((base_memory - boot_address) < bootMP_size)
378                 boot_address -= 4096;   /* not enough, lower by 4k */
379
380         return boot_address;
381 }
382
383
384 static void
385 mptable_probe(void)
386 {
387         struct mptable_pos mpt;
388         int error;
389
390         KKASSERT(mptable_fps_phyaddr == 0);
391
392         mptable_fps_phyaddr = mptable_search();
393         if (mptable_fps_phyaddr == 0)
394                 return;
395
396         error = mptable_map(&mpt);
397         if (error) {
398                 mptable_fps_phyaddr = 0;
399                 return;
400         }
401
402         if (MPTABLE_POS_USE_DEFAULT(&mpt)) {
403                 kprintf("MPTABLE: use default configuration\n");
404                 mptable_use_default = 1;
405         }
406         if (mpt.mp_fps->mpfb2 & 0x80)
407                 imcr_present = 1;
408
409         mptable_unmap(&mpt);
410 }
411 SYSINIT(mptable_probe, SI_BOOT2_PRESMP, SI_ORDER_FIRST, mptable_probe, 0);
412
413 /*
414  * Look for an Intel MP spec table (ie, SMP capable hardware).
415  */
416 static int
417 mptable_search(void)
418 {
419         int     x;
420         u_int32_t target;
421  
422         /*
423          * Make sure our SMPpt[] page table is big enough to hold all the
424          * mappings we need.
425          */
426         KKASSERT(IO_MAPPING_START_INDEX < NPTEPG - 2);
427
428         POSTCODE(MP_PROBE_POST);
429
430         /* see if EBDA exists */
431         if (ebda_addr != 0) {
432                 /* search first 1K of EBDA */
433                 target = (u_int32_t)ebda_addr;
434                 if ((x = mptable_search_sig(target, 1024 / 4)) > 0)
435                         return x;
436         } else {
437                 /* last 1K of base memory, effective 'top of base' passed in */
438                 target = (u_int32_t)(base_memory - 0x400);
439                 if ((x = mptable_search_sig(target, 1024 / 4)) > 0)
440                         return x;
441         }
442
443         /* search the BIOS */
444         target = (u_int32_t)BIOS_BASE;
445         if ((x = mptable_search_sig(target, BIOS_COUNT)) > 0)
446                 return x;
447
448         /* search the extended BIOS */
449         target = (u_int32_t)BIOS_BASE2;
450         if ((x = mptable_search_sig(target, BIOS_COUNT)) > 0)
451                 return x;
452
453         /* nothing found */
454         return 0;
455 }
456
457 static int
458 mptable_iterate_entries(const mpcth_t cth, mptable_iter_func func, void *arg)
459 {
460         int count, total_size;
461         const void *position;
462
463         KKASSERT(cth->base_table_length >= sizeof(struct MPCTH));
464         total_size = cth->base_table_length - sizeof(struct MPCTH);
465         position = (const uint8_t *)cth + sizeof(struct MPCTH);
466         count = cth->entry_count;
467
468         while (count--) {
469                 int type, error;
470
471                 KKASSERT(total_size >= 0);
472                 if (total_size == 0) {
473                         kprintf("invalid base MP table, "
474                                 "entry count and length mismatch\n");
475                         return EINVAL;
476                 }
477
478                 type = *(const uint8_t *)position;
479                 switch (type) {
480                 case 0: /* processor_entry */
481                 case 1: /* bus_entry */
482                 case 2: /* io_apic_entry */
483                 case 3: /* int_entry */
484                 case 4: /* int_entry */
485                         break;
486                 default:
487                         kprintf("unknown base MP table entry type %d\n", type);
488                         return EINVAL;
489                 }
490
491                 if (total_size < basetable_entry_types[type].length) {
492                         kprintf("invalid base MP table length, "
493                                 "does not contain all entries\n");
494                         return EINVAL;
495                 }
496                 total_size -= basetable_entry_types[type].length;
497
498                 error = func(arg, position, type);
499                 if (error)
500                         return error;
501
502                 position = (const uint8_t *)position +
503                     basetable_entry_types[type].length;
504         }
505         return 0;
506 }
507
508
509 /*
510  * Startup the SMP processors.
511  */
512 void
513 mp_start(void)
514 {
515         POSTCODE(MP_START_POST);
516         mp_enable(boot_address);
517 }
518
519
520 /*
521  * Print various information about the SMP system hardware and setup.
522  */
523 void
524 mp_announce(void)
525 {
526         int     x;
527
528         POSTCODE(MP_ANNOUNCE_POST);
529
530         kprintf("DragonFly/MP: Multiprocessor motherboard\n");
531         kprintf(" cpu0 (BSP): apic id: %2d", CPU_TO_ID(0));
532         kprintf(", version: 0x%08x\n", cpu_apic_versions[0]);
533         for (x = 1; x <= mp_naps; ++x) {
534                 kprintf(" cpu%d (AP):  apic id: %2d", x, CPU_TO_ID(x));
535                 kprintf(", version: 0x%08x\n", cpu_apic_versions[x]);
536         }
537
538         if (!apic_io_enable)
539                 kprintf(" Warning: APIC I/O disabled\n");
540 }
541
542 /*
543  * AP cpu's call this to sync up protected mode.
544  *
545  * WARNING!  We must ensure that the cpu is sufficiently initialized to
546  * be able to use to the FP for our optimized bzero/bcopy code before
547  * we enter more mainstream C code.
548  *
549  * WARNING! %fs is not set up on entry.  This routine sets up %fs.
550  */
551 void
552 init_secondary(void)
553 {
554         int     gsel_tss;
555         int     x, myid = bootAP;
556         u_int   cr0;
557         struct mdglobaldata *md;
558         struct privatespace *ps;
559
560         ps = &CPU_prvspace[myid];
561
562         gdt_segs[GPRIV_SEL].ssd_base = (int)ps;
563         gdt_segs[GPROC0_SEL].ssd_base =
564                 (int) &ps->mdglobaldata.gd_common_tss;
565         ps->mdglobaldata.mi.gd_prvspace = ps;
566
567         for (x = 0; x < NGDT; x++) {
568                 ssdtosd(&gdt_segs[x], &gdt[myid * NGDT + x].sd);
569         }
570
571         r_gdt.rd_limit = NGDT * sizeof(gdt[0]) - 1;
572         r_gdt.rd_base = (int) &gdt[myid * NGDT];
573         lgdt(&r_gdt);                   /* does magic intra-segment return */
574
575         lidt(&r_idt);
576
577         lldt(_default_ldt);
578         mdcpu->gd_currentldt = _default_ldt;
579
580         gsel_tss = GSEL(GPROC0_SEL, SEL_KPL);
581         gdt[myid * NGDT + GPROC0_SEL].sd.sd_type = SDT_SYS386TSS;
582
583         md = mdcpu;     /* loaded through %fs:0 (mdglobaldata.mi.gd_prvspace)*/
584
585         md->gd_common_tss.tss_esp0 = 0; /* not used until after switch */
586         md->gd_common_tss.tss_ss0 = GSEL(GDATA_SEL, SEL_KPL);
587         md->gd_common_tss.tss_ioopt = (sizeof md->gd_common_tss) << 16;
588         md->gd_tss_gdt = &gdt[myid * NGDT + GPROC0_SEL].sd;
589         md->gd_common_tssd = *md->gd_tss_gdt;
590         ltr(gsel_tss);
591
592         /*
593          * Set to a known state:
594          * Set by mpboot.s: CR0_PG, CR0_PE
595          * Set by cpu_setregs: CR0_NE, CR0_MP, CR0_TS, CR0_WP, CR0_AM
596          */
597         cr0 = rcr0();
598         cr0 &= ~(CR0_CD | CR0_NW | CR0_EM);
599         load_cr0(cr0);
600         pmap_set_opt();         /* PSE/4MB pages, etc */
601
602         /* set up CPU registers and state */
603         cpu_setregs();
604
605         /* set up FPU state on the AP */
606         npxinit(__INITIAL_NPXCW__);
607
608         /* set up SSE registers */
609         enable_sse();
610 }
611
612 /*******************************************************************
613  * local functions and data
614  */
615
616 /*
617  * start the SMP system
618  */
619 static void
620 mp_enable(u_int boot_addr)
621 {
622         POSTCODE(MP_ENABLE_POST);
623
624         lapic_config();
625
626         /* Initialize BSP's local APIC */
627         lapic_init(TRUE);
628
629         /* start each Application Processor */
630         start_all_aps(boot_addr);
631
632         if (apic_io_enable)
633                 ioapic_config();
634
635         /* Finalize PIC */
636         MachIntrABI.finalize();
637 }
638
639
640 /*
641  * look for the MP spec signature
642  */
643
644 /* string defined by the Intel MP Spec as identifying the MP table */
645 #define MP_SIG          0x5f504d5f      /* _MP_ */
646 #define NEXT(X)         ((X) += 4)
647 static int
648 mptable_search_sig(u_int32_t target, int count)
649 {
650         vm_size_t map_size;
651         u_int32_t *addr;
652         int x, ret;
653
654         KKASSERT(target != 0);
655
656         map_size = count * sizeof(u_int32_t);
657         addr = pmap_mapdev((vm_paddr_t)target, map_size);
658
659         ret = 0;
660         for (x = 0; x < count; NEXT(x)) {
661                 if (addr[x] == MP_SIG) {
662                         /* make array index a byte index */
663                         ret = target + (x * sizeof(u_int32_t));
664                         break;
665                 }
666         }
667
668         pmap_unmapdev((vm_offset_t)addr, map_size);
669         return ret;
670 }
671
672
673 typedef struct BUSDATA {
674         u_char  bus_id;
675         enum busTypes bus_type;
676 }       bus_datum;
677
678 typedef struct INTDATA {
679         u_char  int_type;
680         u_short int_flags;
681         u_char  src_bus_id;
682         u_char  src_bus_irq;
683         u_char  dst_apic_id;
684         u_char  dst_apic_int;
685         u_char  int_vector;
686 }       io_int, local_int;
687
688 typedef struct BUSTYPENAME {
689         u_char  type;
690         char    name[7];
691 }       bus_type_name;
692
693 static int processor_entry      (const struct PROCENTRY *entry, int cpu);
694
695 /*
696  * Check if we should perform a hyperthreading "fix-up" to
697  * enumerate any logical CPU's that aren't already listed
698  * in the table.
699  *
700  * XXX: We assume that all of the physical CPUs in the
701  * system have the same number of logical CPUs.
702  *
703  * XXX: We assume that APIC ID's are allocated such that
704  * the APIC ID's for a physical processor are aligned
705  * with the number of logical CPU's in the processor.
706  */
707 static int
708 mptable_hyperthread_fixup(cpumask_t id_mask, int cpu_count)
709 {
710         int i, id, lcpus_max, logical_cpus;
711
712         if ((cpu_feature & CPUID_HTT) == 0)
713                 return 0;
714
715         lcpus_max = (cpu_procinfo & CPUID_HTT_CORES) >> 16;
716         if (lcpus_max <= 1)
717                 return 0;
718
719         if (cpu_vendor_id == CPU_VENDOR_INTEL) {
720                 /*
721                  * INSTRUCTION SET REFERENCE, A-M (#253666)
722                  * Page 3-181, Table 3-20
723                  * "The nearest power-of-2 integer that is not smaller
724                  *  than EBX[23:16] is the number of unique initial APIC
725                  *  IDs reserved for addressing different logical
726                  *  processors in a physical package."
727                  */
728                 for (i = 0; ; ++i) {
729                         if ((1 << i) >= lcpus_max) {
730                                 lcpus_max = 1 << i;
731                                 break;
732                         }
733                 }
734         }
735
736         KKASSERT(cpu_count != 0);
737         if (cpu_count == lcpus_max) {
738                 /* We have nothing to fix */
739                 return 0;
740         } else if (cpu_count == 1) {
741                 /* XXX this may be incorrect */
742                 logical_cpus = lcpus_max;
743         } else {
744                 int cur, prev, dist;
745
746                 /*
747                  * Calculate the distances between two nearest
748                  * APIC IDs.  If all such distances are same,
749                  * then it is the number of missing cpus that
750                  * we are going to fill later.
751                  */
752                 dist = cur = prev = -1;
753                 for (id = 0; id < MAXCPU; ++id) {
754                         if ((id_mask & CPUMASK(id)) == 0)
755                                 continue;
756
757                         cur = id;
758                         if (prev >= 0) {
759                                 int new_dist = cur - prev;
760
761                                 if (dist < 0)
762                                         dist = new_dist;
763
764                                 /*
765                                  * Make sure that all distances
766                                  * between two nearest APIC IDs
767                                  * are same.
768                                  */
769                                 if (dist != new_dist)
770                                         return 0;
771                         }
772                         prev = cur;
773                 }
774                 if (dist == 1)
775                         return 0;
776
777                 /* Must be power of 2 */
778                 if (dist & (dist - 1))
779                         return 0;
780
781                 /* Can't exceed CPU package capacity */
782                 if (dist > lcpus_max)
783                         logical_cpus = lcpus_max;
784                 else
785                         logical_cpus = dist;
786         }
787
788         /*
789          * For each APIC ID of a CPU that is set in the mask,
790          * scan the other candidate APIC ID's for this
791          * physical processor.  If any of those ID's are
792          * already in the table, then kill the fixup.
793          */
794         for (id = 0; id < MAXCPU; id++) {
795                 if ((id_mask & CPUMASK(id)) == 0)
796                         continue;
797                 /* First, make sure we are on a logical_cpus boundary. */
798                 if (id % logical_cpus != 0)
799                         return 0;
800                 for (i = id + 1; i < id + logical_cpus; i++)
801                         if ((id_mask & CPUMASK(i)) != 0)
802                                 return 0;
803         }
804         return logical_cpus;
805 }
806
807 static int
808 mptable_map(struct mptable_pos *mpt)
809 {
810         mpfps_t fps = NULL;
811         mpcth_t cth = NULL;
812         vm_size_t cth_mapsz = 0;
813
814         KKASSERT(mptable_fps_phyaddr != 0);
815
816         bzero(mpt, sizeof(*mpt));
817
818         fps = pmap_mapdev(mptable_fps_phyaddr, sizeof(*fps));
819         if (fps->pap != 0) {
820                 /*
821                  * Map configuration table header to get
822                  * the base table size
823                  */
824                 cth = pmap_mapdev(fps->pap, sizeof(*cth));
825                 cth_mapsz = cth->base_table_length;
826                 pmap_unmapdev((vm_offset_t)cth, sizeof(*cth));
827
828                 if (cth_mapsz < sizeof(*cth)) {
829                         kprintf("invalid base MP table length %d\n",
830                                 (int)cth_mapsz);
831                         pmap_unmapdev((vm_offset_t)fps, sizeof(*fps));
832                         return EINVAL;
833                 }
834
835                 /*
836                  * Map the base table
837                  */
838                 cth = pmap_mapdev(fps->pap, cth_mapsz);
839         }
840
841         mpt->mp_fps = fps;
842         mpt->mp_cth = cth;
843         mpt->mp_cth_mapsz = cth_mapsz;
844
845         return 0;
846 }
847
848 static void
849 mptable_unmap(struct mptable_pos *mpt)
850 {
851         if (mpt->mp_cth != NULL) {
852                 pmap_unmapdev((vm_offset_t)mpt->mp_cth, mpt->mp_cth_mapsz);
853                 mpt->mp_cth = NULL;
854                 mpt->mp_cth_mapsz = 0;
855         }
856         if (mpt->mp_fps != NULL) {
857                 pmap_unmapdev((vm_offset_t)mpt->mp_fps, sizeof(*mpt->mp_fps));
858                 mpt->mp_fps = NULL;
859         }
860 }
861
862 void
863 mp_set_cpuids(int cpu_id, int apic_id)
864 {
865         CPU_TO_ID(cpu_id) = apic_id;
866         ID_TO_CPU(apic_id) = cpu_id;
867 }
868
869 static int
870 processor_entry(const struct PROCENTRY *entry, int cpu)
871 {
872         KKASSERT(cpu > 0);
873
874         /* check for usability */
875         if (!(entry->cpu_flags & PROCENTRY_FLAG_EN))
876                 return 0;
877
878         /* check for BSP flag */
879         if (entry->cpu_flags & PROCENTRY_FLAG_BP) {
880                 mp_set_cpuids(0, entry->apic_id);
881                 return 0;       /* its already been counted */
882         }
883
884         /* add another AP to list, if less than max number of CPUs */
885         else if (cpu < MAXCPU) {
886                 mp_set_cpuids(cpu, entry->apic_id);
887                 return 1;
888         }
889
890         return 0;
891 }
892
893 /*
894  * Map a physical memory address representing I/O into KVA.  The I/O
895  * block is assumed not to cross a page boundary.
896  */
897 void *
898 ioapic_map(vm_paddr_t pa)
899 {
900         vm_offset_t vaddr;
901         int pgeflag;
902         int i;
903
904         KKASSERT(pa < 0x100000000LL);
905
906         pgeflag = 0;    /* not used for SMP yet */
907
908         /*
909          * If the requested physical address has already been incidently
910          * mapped, just use the existing mapping.  Otherwise create a new
911          * mapping.
912          */
913         for (i = IO_MAPPING_START_INDEX; i < SMPpt_alloc_index; ++i) {
914                 if (((vm_offset_t)SMPpt[i] & PG_FRAME) ==
915                     ((vm_offset_t)pa & PG_FRAME)) {
916                         break;
917                 }
918         }
919         if (i == SMPpt_alloc_index) {
920                 if (i == NPTEPG - 2) {
921                         panic("permanent_io_mapping: We ran out of space"
922                               " in SMPpt[]!");
923                 }
924                 SMPpt[i] = (pt_entry_t)(PG_V | PG_RW | PG_N | pgeflag |
925                            ((vm_offset_t)pa & PG_FRAME));
926                 ++SMPpt_alloc_index;
927         }
928         vaddr = (vm_offset_t)CPU_prvspace + (i * PAGE_SIZE) +
929                 ((vm_offset_t)pa & PAGE_MASK);
930         return ((void *)vaddr);
931 }
932
933 /*
934  * start each AP in our list
935  */
936 static int
937 start_all_aps(u_int boot_addr)
938 {
939         int     x, i, pg;
940         int     shift;
941         int     smicount;
942         int     smibest;
943         int     smilast;
944         u_char  mpbiosreason;
945         u_long  mpbioswarmvec;
946         struct mdglobaldata *gd;
947         struct privatespace *ps;
948         char *stack;
949         uintptr_t kptbase;
950
951         POSTCODE(START_ALL_APS_POST);
952
953         /* install the AP 1st level boot code */
954         install_ap_tramp(boot_addr);
955
956
957         /* save the current value of the warm-start vector */
958         mpbioswarmvec = *((u_long *) WARMBOOT_OFF);
959         outb(CMOS_REG, BIOS_RESET);
960         mpbiosreason = inb(CMOS_DATA);
961
962         /* setup a vector to our boot code */
963         *((volatile u_short *) WARMBOOT_OFF) = WARMBOOT_TARGET;
964         *((volatile u_short *) WARMBOOT_SEG) = (boot_addr >> 4);
965         outb(CMOS_REG, BIOS_RESET);
966         outb(CMOS_DATA, BIOS_WARM);     /* 'warm-start' */
967
968         /*
969          * If we have a TSC we can figure out the SMI interrupt rate.
970          * The SMI does not necessarily use a constant rate.  Spend
971          * up to 250ms trying to figure it out.
972          */
973         smibest = 0;
974         if (cpu_feature & CPUID_TSC) {
975                 set_apic_timer(275000);
976                 smilast = read_apic_timer();
977                 for (x = 0; x < 20 && read_apic_timer(); ++x) {
978                         smicount = smitest();
979                         if (smibest == 0 || smilast - smicount < smibest)
980                                 smibest = smilast - smicount;
981                         smilast = smicount;
982                 }
983                 if (smibest > 250000)
984                         smibest = 0;
985                 if (smibest) {
986                         smibest = smibest * (int64_t)1000000 /
987                                   get_apic_timer_frequency();
988                 }
989         }
990         if (smibest)
991                 kprintf("SMI Frequency (worst case): %d Hz (%d us)\n",
992                         1000000 / smibest, smibest);
993
994
995         /* set up temporary P==V mapping for AP boot */
996         /* XXX this is a hack, we should boot the AP on its own stack/PTD */
997         kptbase = (uintptr_t)(void *)KPTphys;
998         for (x = 0; x < NKPT; x++) {
999                 PTD[x] = (pd_entry_t)(PG_V | PG_RW |
1000                     ((kptbase + x * PAGE_SIZE) & PG_FRAME));
1001         }
1002         cpu_invltlb();
1003
1004         /* start each AP */
1005         for (x = 1; x <= mp_naps; ++x) {
1006
1007                 /* This is a bit verbose, it will go away soon.  */
1008
1009                 /* first page of AP's private space */
1010                 pg = x * i386_btop(sizeof(struct privatespace));
1011
1012                 /* allocate new private data page(s) */
1013                 gd = (struct mdglobaldata *)kmem_alloc(&kernel_map, 
1014                                 MDGLOBALDATA_BASEALLOC_SIZE);
1015                 /* wire it into the private page table page */
1016                 for (i = 0; i < MDGLOBALDATA_BASEALLOC_SIZE; i += PAGE_SIZE) {
1017                         SMPpt[pg + i / PAGE_SIZE] = (pt_entry_t)
1018                             (PG_V | PG_RW | vtophys_pte((char *)gd + i));
1019                 }
1020                 pg += MDGLOBALDATA_BASEALLOC_PAGES;
1021
1022                 SMPpt[pg + 0] = 0;              /* *gd_CMAP1 */
1023                 SMPpt[pg + 1] = 0;              /* *gd_CMAP2 */
1024                 SMPpt[pg + 2] = 0;              /* *gd_CMAP3 */
1025                 SMPpt[pg + 3] = 0;              /* *gd_PMAP1 */
1026
1027                 /* allocate and set up an idle stack data page */
1028                 stack = (char *)kmem_alloc(&kernel_map, UPAGES*PAGE_SIZE);
1029                 for (i = 0; i < UPAGES; i++) {
1030                         SMPpt[pg + 4 + i] = (pt_entry_t)
1031                             (PG_V | PG_RW | vtophys_pte(PAGE_SIZE * i + stack));
1032                 }
1033
1034                 gd = &CPU_prvspace[x].mdglobaldata;     /* official location */
1035                 bzero(gd, sizeof(*gd));
1036                 gd->mi.gd_prvspace = ps = &CPU_prvspace[x];
1037
1038                 /* prime data page for it to use */
1039                 mi_gdinit(&gd->mi, x);
1040                 cpu_gdinit(gd, x);
1041                 gd->gd_CMAP1 = &SMPpt[pg + 0];
1042                 gd->gd_CMAP2 = &SMPpt[pg + 1];
1043                 gd->gd_CMAP3 = &SMPpt[pg + 2];
1044                 gd->gd_PMAP1 = &SMPpt[pg + 3];
1045                 gd->gd_CADDR1 = ps->CPAGE1;
1046                 gd->gd_CADDR2 = ps->CPAGE2;
1047                 gd->gd_CADDR3 = ps->CPAGE3;
1048                 gd->gd_PADDR1 = (unsigned *)ps->PPAGE1;
1049
1050                 /*
1051                  * Per-cpu pmap for get_ptbase().
1052                  */
1053                 gd->gd_GDADDR1= (unsigned *)
1054                         kmem_alloc_nofault(&kernel_map, SEG_SIZE, SEG_SIZE);
1055                 gd->gd_GDMAP1 = &PTD[(vm_offset_t)gd->gd_GDADDR1 >> PDRSHIFT];
1056
1057                 gd->mi.gd_ipiq = (void *)kmem_alloc(&kernel_map, sizeof(lwkt_ipiq) * (mp_naps + 1));
1058                 bzero(gd->mi.gd_ipiq, sizeof(lwkt_ipiq) * (mp_naps + 1));
1059
1060                 /*
1061                  * Setup the AP boot stack
1062                  */
1063                 bootSTK = &ps->idlestack[UPAGES*PAGE_SIZE/2];
1064                 bootAP = x;
1065
1066                 /* attempt to start the Application Processor */
1067                 CHECK_INIT(99); /* setup checkpoints */
1068                 if (!start_ap(gd, boot_addr, smibest)) {
1069                         kprintf("AP #%d (PHY# %d) failed!\n", x, CPU_TO_ID(x));
1070                         CHECK_PRINT("trace");   /* show checkpoints */
1071                         /* better panic as the AP may be running loose */
1072                         kprintf("panic y/n? [y] ");
1073                         if (cngetc() != 'n')
1074                                 panic("bye-bye");
1075                 }
1076                 CHECK_PRINT("trace");           /* show checkpoints */
1077
1078                 /* record its version info */
1079                 cpu_apic_versions[x] = cpu_apic_versions[0];
1080         }
1081
1082         /* set ncpus to 1 + highest logical cpu.  Not all may have come up */
1083         ncpus = x;
1084
1085         /* ncpus2 -- ncpus rounded down to the nearest power of 2 */
1086         for (shift = 0; (1 << shift) <= ncpus; ++shift)
1087                 ;
1088         --shift;
1089         ncpus2_shift = shift;
1090         ncpus2 = 1 << shift;
1091         ncpus2_mask = ncpus2 - 1;
1092
1093         /* ncpus_fit -- ncpus rounded up to the nearest power of 2 */
1094         if ((1 << shift) < ncpus)
1095                 ++shift;
1096         ncpus_fit = 1 << shift;
1097         ncpus_fit_mask = ncpus_fit - 1;
1098
1099         /* build our map of 'other' CPUs */
1100         mycpu->gd_other_cpus = smp_startup_mask & ~CPUMASK(mycpu->gd_cpuid);
1101         mycpu->gd_ipiq = (void *)kmem_alloc(&kernel_map, sizeof(lwkt_ipiq) * ncpus);
1102         bzero(mycpu->gd_ipiq, sizeof(lwkt_ipiq) * ncpus);
1103
1104         /* fill in our (BSP) APIC version */
1105         cpu_apic_versions[0] = lapic.version;
1106
1107         /* restore the warmstart vector */
1108         *(u_long *) WARMBOOT_OFF = mpbioswarmvec;
1109         outb(CMOS_REG, BIOS_RESET);
1110         outb(CMOS_DATA, mpbiosreason);
1111
1112         /*
1113          * NOTE!  The idlestack for the BSP was setup by locore.  Finish
1114          * up, clean out the P==V mapping we did earlier.
1115          */
1116         for (x = 0; x < NKPT; x++)
1117                 PTD[x] = 0;
1118         pmap_set_opt();
1119
1120         /*
1121          * Wait all APs to finish initializing LAPIC
1122          */
1123         mp_finish_lapic = 1;
1124         if (bootverbose)
1125                 kprintf("SMP: Waiting APs LAPIC initialization\n");
1126         if (cpu_feature & CPUID_TSC)
1127                 tsc0_offset = rdtsc();
1128         tsc_offsets[0] = 0;
1129         rel_mplock();
1130         while (smp_lapic_mask != smp_startup_mask) {
1131                 cpu_lfence();
1132                 if (cpu_feature & CPUID_TSC)
1133                         tsc0_offset = rdtsc();
1134         }
1135         while (try_mplock() == 0)
1136                 ;
1137
1138         /* number of APs actually started */
1139         return ncpus - 1;
1140 }
1141
1142 /*
1143  * load the 1st level AP boot code into base memory.
1144  */
1145
1146 /* targets for relocation */
1147 extern void bigJump(void);
1148 extern void bootCodeSeg(void);
1149 extern void bootDataSeg(void);
1150 extern void MPentry(void);
1151 extern u_int MP_GDT;
1152 extern u_int mp_gdtbase;
1153
1154 static void
1155 install_ap_tramp(u_int boot_addr)
1156 {
1157         int     x;
1158         int     size = *(int *) ((u_long) & bootMP_size);
1159         u_char *src = (u_char *) ((u_long) bootMP);
1160         u_char *dst = (u_char *) boot_addr + KERNBASE;
1161         u_int   boot_base = (u_int) bootMP;
1162         u_int8_t *dst8;
1163         u_int16_t *dst16;
1164         u_int32_t *dst32;
1165
1166         POSTCODE(INSTALL_AP_TRAMP_POST);
1167
1168         for (x = 0; x < size; ++x)
1169                 *dst++ = *src++;
1170
1171         /*
1172          * modify addresses in code we just moved to basemem. unfortunately we
1173          * need fairly detailed info about mpboot.s for this to work.  changes
1174          * to mpboot.s might require changes here.
1175          */
1176
1177         /* boot code is located in KERNEL space */
1178         dst = (u_char *) boot_addr + KERNBASE;
1179
1180         /* modify the lgdt arg */
1181         dst32 = (u_int32_t *) (dst + ((u_int) & mp_gdtbase - boot_base));
1182         *dst32 = boot_addr + ((u_int) & MP_GDT - boot_base);
1183
1184         /* modify the ljmp target for MPentry() */
1185         dst32 = (u_int32_t *) (dst + ((u_int) bigJump - boot_base) + 1);
1186         *dst32 = ((u_int) MPentry - KERNBASE);
1187
1188         /* modify the target for boot code segment */
1189         dst16 = (u_int16_t *) (dst + ((u_int) bootCodeSeg - boot_base));
1190         dst8 = (u_int8_t *) (dst16 + 1);
1191         *dst16 = (u_int) boot_addr & 0xffff;
1192         *dst8 = ((u_int) boot_addr >> 16) & 0xff;
1193
1194         /* modify the target for boot data segment */
1195         dst16 = (u_int16_t *) (dst + ((u_int) bootDataSeg - boot_base));
1196         dst8 = (u_int8_t *) (dst16 + 1);
1197         *dst16 = (u_int) boot_addr & 0xffff;
1198         *dst8 = ((u_int) boot_addr >> 16) & 0xff;
1199 }
1200
1201
1202 /*
1203  * This function starts the AP (application processor) identified
1204  * by the APIC ID 'physicalCpu'.  It does quite a "song and dance"
1205  * to accomplish this.  This is necessary because of the nuances
1206  * of the different hardware we might encounter.  It ain't pretty,
1207  * but it seems to work.
1208  *
1209  * NOTE: eventually an AP gets to ap_init(), which is called just 
1210  * before the AP goes into the LWKT scheduler's idle loop.
1211  */
1212 static int
1213 start_ap(struct mdglobaldata *gd, u_int boot_addr, int smibest)
1214 {
1215         int     physical_cpu;
1216         int     vector;
1217         u_long  icr_lo, icr_hi;
1218
1219         POSTCODE(START_AP_POST);
1220
1221         /* get the PHYSICAL APIC ID# */
1222         physical_cpu = CPU_TO_ID(gd->mi.gd_cpuid);
1223
1224         /* calculate the vector */
1225         vector = (boot_addr >> 12) & 0xff;
1226
1227         /* We don't want anything interfering */
1228         cpu_disable_intr();
1229
1230         /* Make sure the target cpu sees everything */
1231         wbinvd();
1232
1233         /*
1234          * Try to detect when a SMI has occurred, wait up to 200ms.
1235          *
1236          * If a SMI occurs during an AP reset but before we issue
1237          * the STARTUP command, the AP may brick.  To work around
1238          * this problem we hold off doing the AP startup until
1239          * after we have detected the SMI.  Hopefully another SMI
1240          * will not occur before we finish the AP startup.
1241          *
1242          * Retries don't seem to help.  SMIs have a window of opportunity
1243          * and if USB->legacy keyboard emulation is enabled in the BIOS
1244          * the interrupt rate can be quite high.
1245          *
1246          * NOTE: Don't worry about the L1 cache load, it might bloat
1247          *       ldelta a little but ndelta will be so huge when the SMI
1248          *       occurs the detection logic will still work fine.
1249          */
1250         if (smibest) {
1251                 set_apic_timer(200000);
1252                 smitest();
1253         }
1254
1255         /*
1256          * first we do an INIT/RESET IPI this INIT IPI might be run, reseting
1257          * and running the target CPU. OR this INIT IPI might be latched (P5
1258          * bug), CPU waiting for STARTUP IPI. OR this INIT IPI might be
1259          * ignored.
1260          *
1261          * see apic/apicreg.h for icr bit definitions.
1262          *
1263          * TIME CRITICAL CODE, DO NOT DO ANY KPRINTFS IN THE HOT PATH.
1264          */
1265
1266         /*
1267          * Setup the address for the target AP.  We can setup
1268          * icr_hi once and then just trigger operations with
1269          * icr_lo.
1270          */
1271         icr_hi = lapic.icr_hi & ~APIC_ID_MASK;
1272         icr_hi |= (physical_cpu << 24);
1273         icr_lo = lapic.icr_lo & 0xfff00000;
1274         lapic.icr_hi = icr_hi;
1275
1276         /*
1277          * Do an INIT IPI: assert RESET
1278          *
1279          * Use edge triggered mode to assert INIT
1280          */
1281         lapic.icr_lo = icr_lo | 0x0000c500;
1282         while (lapic.icr_lo & APIC_DELSTAT_MASK)
1283                  /* spin */ ;
1284
1285         /*
1286          * The spec calls for a 10ms delay but we may have to use a
1287          * MUCH lower delay to avoid bricking an AP due to a fast SMI
1288          * interrupt.  We have other loops here too and dividing by 2
1289          * doesn't seem to be enough even after subtracting 350us,
1290          * so we divide by 4.
1291          *
1292          * Our minimum delay is 150uS, maximum is 10ms.  If no SMI
1293          * interrupt was detected we use the full 10ms.
1294          */
1295         if (smibest == 0)
1296                 u_sleep(10000);
1297         else if (smibest < 150 * 4 + 350)
1298                 u_sleep(150);
1299         else if ((smibest - 350) / 4 < 10000)
1300                 u_sleep((smibest - 350) / 4);
1301         else
1302                 u_sleep(10000);
1303
1304         /*
1305          * Do an INIT IPI: deassert RESET
1306          *
1307          * Use level triggered mode to deassert.  It is unclear
1308          * why we need to do this.
1309          */
1310         lapic.icr_lo = icr_lo | 0x00008500;
1311         while (lapic.icr_lo & APIC_DELSTAT_MASK)
1312                  /* spin */ ;
1313         u_sleep(150);                           /* wait 150us */
1314
1315         /*
1316          * Next we do a STARTUP IPI: the previous INIT IPI might still be
1317          * latched, (P5 bug) this 1st STARTUP would then terminate
1318          * immediately, and the previously started INIT IPI would continue. OR
1319          * the previous INIT IPI has already run. and this STARTUP IPI will
1320          * run. OR the previous INIT IPI was ignored. and this STARTUP IPI
1321          * will run.
1322          */
1323         lapic.icr_lo = icr_lo | 0x00000600 | vector;
1324         while (lapic.icr_lo & APIC_DELSTAT_MASK)
1325                  /* spin */ ;
1326         u_sleep(200);           /* wait ~200uS */
1327
1328         /*
1329          * Finally we do a 2nd STARTUP IPI: this 2nd STARTUP IPI should run IF
1330          * the previous STARTUP IPI was cancelled by a latched INIT IPI. OR
1331          * this STARTUP IPI will be ignored, as only ONE STARTUP IPI is
1332          * recognized after hardware RESET or INIT IPI.
1333          */
1334         lapic.icr_lo = icr_lo | 0x00000600 | vector;
1335         while (lapic.icr_lo & APIC_DELSTAT_MASK)
1336                  /* spin */ ;
1337
1338         /* Resume normal operation */
1339         cpu_enable_intr();
1340
1341         /* wait for it to start, see ap_init() */
1342         set_apic_timer(5000000);/* == 5 seconds */
1343         while (read_apic_timer()) {
1344                 if (smp_startup_mask & CPUMASK(gd->mi.gd_cpuid))
1345                         return 1;       /* return SUCCESS */
1346         }
1347
1348         return 0;               /* return FAILURE */
1349 }
1350
1351 static
1352 int
1353 smitest(void)
1354 {
1355         int64_t ltsc;
1356         int64_t ntsc;
1357         int64_t ldelta;
1358         int64_t ndelta;
1359         int count;
1360
1361         ldelta = 0;
1362         ndelta = 0;
1363         while (read_apic_timer()) {
1364                 ltsc = rdtsc();
1365                 for (count = 0; count < 100; ++count)
1366                         ntsc = rdtsc(); /* force loop to occur */
1367                 if (ldelta) {
1368                         ndelta = ntsc - ltsc;
1369                         if (ldelta > ndelta)
1370                                 ldelta = ndelta;
1371                         if (ndelta > ldelta * 2)
1372                                 break;
1373                 } else {
1374                         ldelta = ntsc - ltsc;
1375                 }
1376         }
1377         return(read_apic_timer());
1378 }
1379
1380 /*
1381  * Lazy flush the TLB on all other CPU's.  DEPRECATED.
1382  *
1383  * If for some reason we were unable to start all cpus we cannot safely
1384  * use broadcast IPIs.
1385  */
1386
1387 static cpumask_t smp_invltlb_req;
1388 #define SMP_INVLTLB_DEBUG
1389
1390 void
1391 smp_invltlb(void)
1392 {
1393 #ifdef SMP
1394         struct mdglobaldata *md = mdcpu;
1395 #ifdef SMP_INVLTLB_DEBUG
1396         long count = 0;
1397         long xcount = 0;
1398 #endif
1399
1400         crit_enter_gd(&md->mi);
1401         md->gd_invltlb_ret = 0;
1402         ++md->mi.gd_cnt.v_smpinvltlb;
1403         atomic_set_cpumask(&smp_invltlb_req, md->mi.gd_cpumask);
1404 #ifdef SMP_INVLTLB_DEBUG
1405 again:
1406 #endif
1407         if (smp_startup_mask == smp_active_mask) {
1408                 all_but_self_ipi(XINVLTLB_OFFSET);
1409         } else {
1410                 selected_apic_ipi(smp_active_mask & ~md->mi.gd_cpumask,
1411                                   XINVLTLB_OFFSET, APIC_DELMODE_FIXED);
1412         }
1413
1414 #ifdef SMP_INVLTLB_DEBUG
1415         if (xcount)
1416                 kprintf("smp_invltlb: ipi sent\n");
1417 #endif
1418         while ((md->gd_invltlb_ret & smp_active_mask & ~md->mi.gd_cpumask) !=
1419                (smp_active_mask & ~md->mi.gd_cpumask)) {
1420                 cpu_mfence();
1421                 cpu_pause();
1422 #ifdef SMP_INVLTLB_DEBUG
1423                 /* DEBUGGING */
1424                 if (++count == 400000000) {
1425                         print_backtrace(-1);
1426                         kprintf("smp_invltlb: endless loop %08lx %08lx, "
1427                                 "rflags %016lx retry",
1428                                 (long)md->gd_invltlb_ret,
1429                                 (long)smp_invltlb_req,
1430                                 (long)read_eflags());
1431                         __asm __volatile ("sti");
1432                         ++xcount;
1433                         if (xcount > 2)
1434                                 lwkt_process_ipiq();
1435                         if (xcount > 3) {
1436                                 int bcpu = BSFCPUMASK(~md->gd_invltlb_ret &
1437                                                       ~md->mi.gd_cpumask &
1438                                                       smp_active_mask);
1439                                 globaldata_t xgd;
1440                                 kprintf("bcpu %d\n", bcpu);
1441                                 xgd = globaldata_find(bcpu);
1442                                 kprintf("thread %p %s\n", xgd->gd_curthread, xgd->gd_curthread->td_comm);
1443                         }
1444                         if (xcount > 5)
1445                                 panic("giving up");
1446                         count = 0;
1447                         goto again;
1448                 }
1449 #endif
1450         }
1451         atomic_clear_cpumask(&smp_invltlb_req, md->mi.gd_cpumask);
1452         crit_exit_gd(&md->mi);
1453 #endif
1454 }
1455
1456 #ifdef SMP
1457
1458 /*
1459  * Called from Xinvltlb assembly with interrupts disabled.  We didn't
1460  * bother to bump the critical section count or nested interrupt count
1461  * so only do very low level operations here.
1462  */
1463 void
1464 smp_invltlb_intr(void)
1465 {
1466         struct mdglobaldata *md = mdcpu;
1467         struct mdglobaldata *omd;
1468         cpumask_t mask;
1469         int cpu;
1470
1471         mask = smp_invltlb_req;
1472         cpu_mfence();
1473         cpu_invltlb();
1474         while (mask) {
1475                 cpu = BSFCPUMASK(mask);
1476                 mask &= ~CPUMASK(cpu);
1477                 omd = (struct mdglobaldata *)globaldata_find(cpu);
1478                 atomic_set_cpumask(&omd->gd_invltlb_ret, md->mi.gd_cpumask);
1479         }
1480 }
1481
1482 #endif
1483
1484 /*
1485  * When called the executing CPU will send an IPI to all other CPUs
1486  *  requesting that they halt execution.
1487  *
1488  * Usually (but not necessarily) called with 'other_cpus' as its arg.
1489  *
1490  *  - Signals all CPUs in map to stop.
1491  *  - Waits for each to stop.
1492  *
1493  * Returns:
1494  *  -1: error
1495  *   0: NA
1496  *   1: ok
1497  *
1498  * XXX FIXME: this is not MP-safe, needs a lock to prevent multiple CPUs
1499  *            from executing at same time.
1500  */
1501 int
1502 stop_cpus(cpumask_t map)
1503 {
1504         map &= smp_active_mask;
1505
1506         /* send the Xcpustop IPI to all CPUs in map */
1507         selected_apic_ipi(map, XCPUSTOP_OFFSET, APIC_DELMODE_FIXED);
1508         
1509         while ((stopped_cpus & map) != map)
1510                 /* spin */ ;
1511
1512         return 1;
1513 }
1514
1515
1516 /*
1517  * Called by a CPU to restart stopped CPUs. 
1518  *
1519  * Usually (but not necessarily) called with 'stopped_cpus' as its arg.
1520  *
1521  *  - Signals all CPUs in map to restart.
1522  *  - Waits for each to restart.
1523  *
1524  * Returns:
1525  *  -1: error
1526  *   0: NA
1527  *   1: ok
1528  */
1529 int
1530 restart_cpus(cpumask_t map)
1531 {
1532         /* signal other cpus to restart */
1533         started_cpus = map & smp_active_mask;
1534
1535         while ((stopped_cpus & map) != 0) /* wait for each to clear its bit */
1536                 /* spin */ ;
1537
1538         return 1;
1539 }
1540
1541 /*
1542  * This is called once the mpboot code has gotten us properly relocated
1543  * and the MMU turned on, etc.   ap_init() is actually the idle thread,
1544  * and when it returns the scheduler will call the real cpu_idle() main
1545  * loop for the idlethread.  Interrupts are disabled on entry and should
1546  * remain disabled at return.
1547  */
1548 void
1549 ap_init(void)
1550 {
1551         u_int   apic_id;
1552
1553         /*
1554          * Adjust smp_startup_mask to signal the BSP that we have started
1555          * up successfully.  Note that we do not yet hold the BGL.  The BSP
1556          * is waiting for our signal.
1557          *
1558          * We can't set our bit in smp_active_mask yet because we are holding
1559          * interrupts physically disabled and remote cpus could deadlock
1560          * trying to send us an IPI.
1561          */
1562         smp_startup_mask |= CPUMASK(mycpu->gd_cpuid);
1563         cpu_mfence();
1564
1565         /*
1566          * Interlock for LAPIC initialization.  Wait until mp_finish_lapic is
1567          * non-zero, then get the MP lock.
1568          *
1569          * Note: We are in a critical section.
1570          *
1571          * Note: we are the idle thread, we can only spin.
1572          *
1573          * Note: The load fence is memory volatile and prevents the compiler
1574          * from improperly caching mp_finish_lapic, and the cpu from improperly
1575          * caching it.
1576          */
1577         while (mp_finish_lapic == 0)
1578                 cpu_lfence();
1579         while (try_mplock() == 0)
1580                 ;
1581
1582         if (cpu_feature & CPUID_TSC) {
1583                 /*
1584                  * The BSP is constantly updating tsc0_offset, figure out
1585                  * the relative difference to synchronize ktrdump.
1586                  */
1587                 tsc_offsets[mycpu->gd_cpuid] = rdtsc() - tsc0_offset;
1588         }
1589
1590         /* BSP may have changed PTD while we're waiting for the lock */
1591         cpu_invltlb();
1592
1593 #if defined(I586_CPU) && !defined(NO_F00F_HACK)
1594         lidt(&r_idt);
1595 #endif
1596
1597         /* Build our map of 'other' CPUs. */
1598         mycpu->gd_other_cpus = smp_startup_mask & ~CPUMASK(mycpu->gd_cpuid);
1599
1600         /* A quick check from sanity claus */
1601         apic_id = (apic_id_to_logical[(lapic.id & 0xff000000) >> 24]);
1602         if (mycpu->gd_cpuid != apic_id) {
1603                 kprintf("SMP: cpuid = %d\n", mycpu->gd_cpuid);
1604                 kprintf("SMP: apic_id = %d\n", apic_id);
1605                 kprintf("PTD[MPPTDI] = %p\n", (void *)PTD[MPPTDI]);
1606                 panic("cpuid mismatch! boom!!");
1607         }
1608
1609         /* Initialize AP's local APIC for irq's */
1610         lapic_init(FALSE);
1611
1612         /* LAPIC initialization is done */
1613         smp_lapic_mask |= CPUMASK(mycpu->gd_cpuid);
1614         cpu_mfence();
1615
1616         /* Let BSP move onto the next initialization stage */
1617         rel_mplock();
1618
1619         /*
1620          * Interlock for finalization.  Wait until mp_finish is non-zero,
1621          * then get the MP lock.
1622          *
1623          * Note: We are in a critical section.
1624          *
1625          * Note: we are the idle thread, we can only spin.
1626          *
1627          * Note: The load fence is memory volatile and prevents the compiler
1628          * from improperly caching mp_finish, and the cpu from improperly
1629          * caching it.
1630          */
1631         while (mp_finish == 0)
1632                 cpu_lfence();
1633         while (try_mplock() == 0)
1634                 ;
1635
1636         /* BSP may have changed PTD while we're waiting for the lock */
1637         cpu_invltlb();
1638
1639         /* Set memory range attributes for this CPU to match the BSP */
1640         mem_range_AP_init();
1641
1642         /*
1643          * Once we go active we must process any IPIQ messages that may
1644          * have been queued, because no actual IPI will occur until we
1645          * set our bit in the smp_active_mask.  If we don't the IPI
1646          * message interlock could be left set which would also prevent
1647          * further IPIs.
1648          *
1649          * The idle loop doesn't expect the BGL to be held and while
1650          * lwkt_switch() normally cleans things up this is a special case
1651          * because we returning almost directly into the idle loop.
1652          *
1653          * The idle thread is never placed on the runq, make sure
1654          * nothing we've done put it there.
1655          */
1656         KKASSERT(get_mplock_count(curthread) == 1);
1657         smp_active_mask |= CPUMASK(mycpu->gd_cpuid);
1658
1659         /*
1660          * Enable interrupts here.  idle_restore will also do it, but
1661          * doing it here lets us clean up any strays that got posted to
1662          * the CPU during the AP boot while we are still in a critical
1663          * section.
1664          */
1665         __asm __volatile("sti; pause; pause"::);
1666         bzero(mdcpu->gd_ipending, sizeof(mdcpu->gd_ipending));
1667
1668         initclocks_pcpu();      /* clock interrupts (via IPIs) */
1669         lwkt_process_ipiq();
1670
1671         /*
1672          * Releasing the mp lock lets the BSP finish up the SMP init
1673          */
1674         rel_mplock();
1675         KKASSERT((curthread->td_flags & TDF_RUNQ) == 0);
1676 }
1677
1678 /*
1679  * Get SMP fully working before we start initializing devices.
1680  */
1681 static
1682 void
1683 ap_finish(void)
1684 {
1685         mp_finish = 1;
1686         if (bootverbose)
1687                 kprintf("Finish MP startup\n");
1688         rel_mplock();
1689         while (smp_active_mask != smp_startup_mask)
1690                 cpu_lfence();
1691         while (try_mplock() == 0)
1692                 ;
1693         if (bootverbose)
1694                 kprintf("Active CPU Mask: %08x\n", smp_active_mask);
1695 }
1696
1697 SYSINIT(finishsmp, SI_BOOT2_FINISH_SMP, SI_ORDER_FIRST, ap_finish, NULL)
1698
1699 void
1700 cpu_send_ipiq(int dcpu)
1701 {
1702         if (CPUMASK(dcpu) & smp_active_mask)
1703                 single_apic_ipi(dcpu, XIPIQ_OFFSET, APIC_DELMODE_FIXED);
1704 }
1705
1706 #if 0   /* single_apic_ipi_passive() not working yet */
1707 /*
1708  * Returns 0 on failure, 1 on success
1709  */
1710 int
1711 cpu_send_ipiq_passive(int dcpu)
1712 {
1713         int r = 0;
1714         if (CPUMASK(dcpu) & smp_active_mask) {
1715                 r = single_apic_ipi_passive(dcpu, XIPIQ_OFFSET,
1716                                         APIC_DELMODE_FIXED);
1717         }
1718         return(r);
1719 }
1720 #endif
1721
1722 static int
1723 mptable_bus_info_callback(void *xarg, const void *pos, int type)
1724 {
1725         struct mptable_bus_info *bus_info = xarg;
1726         const struct BUSENTRY *ent;
1727         struct mptable_bus *bus;
1728
1729         if (type != 1)
1730                 return 0;
1731
1732         ent = pos;
1733         TAILQ_FOREACH(bus, &bus_info->mbi_list, mb_link) {
1734                 if (bus->mb_id == ent->bus_id) {
1735                         kprintf("mptable_bus_info_alloc: duplicated bus id "
1736                                 "(%d)\n", bus->mb_id);
1737                         return EINVAL;
1738                 }
1739         }
1740
1741         bus = NULL;
1742         if (strncmp(ent->bus_type, "PCI", 3) == 0) {
1743                 bus = kmalloc(sizeof(*bus), M_TEMP, M_WAITOK | M_ZERO);
1744                 bus->mb_type = MPTABLE_BUS_PCI;
1745         } else if (strncmp(ent->bus_type, "ISA", 3) == 0) {
1746                 bus = kmalloc(sizeof(*bus), M_TEMP, M_WAITOK | M_ZERO);
1747                 bus->mb_type = MPTABLE_BUS_ISA;
1748         }
1749
1750         if (bus != NULL) {
1751                 bus->mb_id = ent->bus_id;
1752                 TAILQ_INSERT_TAIL(&bus_info->mbi_list, bus, mb_link);
1753         }
1754         return 0;
1755 }
1756
1757 static void
1758 mptable_bus_info_alloc(const mpcth_t cth, struct mptable_bus_info *bus_info)
1759 {
1760         int error;
1761
1762         bzero(bus_info, sizeof(*bus_info));
1763         TAILQ_INIT(&bus_info->mbi_list);
1764
1765         error = mptable_iterate_entries(cth, mptable_bus_info_callback, bus_info);
1766         if (error)
1767                 mptable_bus_info_free(bus_info);
1768 }
1769
1770 static void
1771 mptable_bus_info_free(struct mptable_bus_info *bus_info)
1772 {
1773         struct mptable_bus *bus;
1774
1775         while ((bus = TAILQ_FIRST(&bus_info->mbi_list)) != NULL) {
1776                 TAILQ_REMOVE(&bus_info->mbi_list, bus, mb_link);
1777                 kfree(bus, M_TEMP);
1778         }
1779 }
1780
1781 struct mptable_lapic_cbarg1 {
1782         int     cpu_count;
1783         int     ht_fixup;
1784         u_int   ht_apicid_mask;
1785 };
1786
1787 static int
1788 mptable_lapic_pass1_callback(void *xarg, const void *pos, int type)
1789 {
1790         const struct PROCENTRY *ent;
1791         struct mptable_lapic_cbarg1 *arg = xarg;
1792
1793         if (type != 0)
1794                 return 0;
1795         ent = pos;
1796
1797         if ((ent->cpu_flags & PROCENTRY_FLAG_EN) == 0)
1798                 return 0;
1799
1800         arg->cpu_count++;
1801         if (ent->apic_id < 32) {
1802                 arg->ht_apicid_mask |= 1 << ent->apic_id;
1803         } else if (arg->ht_fixup) {
1804                 kprintf("MPTABLE: lapic id > 32, disable HTT fixup\n");
1805                 arg->ht_fixup = 0;
1806         }
1807         return 0;
1808 }
1809
1810 struct mptable_lapic_cbarg2 {
1811         int     cpu;
1812         int     logical_cpus;
1813         int     found_bsp;
1814 };
1815
1816 static int
1817 mptable_lapic_pass2_callback(void *xarg, const void *pos, int type)
1818 {
1819         const struct PROCENTRY *ent;
1820         struct mptable_lapic_cbarg2 *arg = xarg;
1821
1822         if (type != 0)
1823                 return 0;
1824         ent = pos;
1825
1826         if (ent->cpu_flags & PROCENTRY_FLAG_BP) {
1827                 KKASSERT(!arg->found_bsp);
1828                 arg->found_bsp = 1;
1829         }
1830
1831         if (processor_entry(ent, arg->cpu))
1832                 arg->cpu++;
1833
1834         if (arg->logical_cpus) {
1835                 struct PROCENTRY proc;
1836                 int i;
1837
1838                 /*
1839                  * Create fake mptable processor entries
1840                  * and feed them to processor_entry() to
1841                  * enumerate the logical CPUs.
1842                  */
1843                 bzero(&proc, sizeof(proc));
1844                 proc.type = 0;
1845                 proc.cpu_flags = PROCENTRY_FLAG_EN;
1846                 proc.apic_id = ent->apic_id;
1847
1848                 for (i = 1; i < arg->logical_cpus; i++) {
1849                         proc.apic_id++;
1850                         processor_entry(&proc, arg->cpu);
1851                         arg->cpu++;
1852                 }
1853         }
1854         return 0;
1855 }
1856
1857 static void
1858 mptable_lapic_default(void)
1859 {
1860         int ap_apicid, bsp_apicid;
1861
1862         mp_naps = 1; /* exclude BSP */
1863
1864         /* Map local apic before the id field is accessed */
1865         lapic_map(DEFAULT_APIC_BASE);
1866
1867         bsp_apicid = APIC_ID(lapic.id);
1868         ap_apicid = (bsp_apicid == 0) ? 1 : 0;
1869
1870         /* BSP */
1871         mp_set_cpuids(0, bsp_apicid);
1872         /* one and only AP */
1873         mp_set_cpuids(1, ap_apicid);
1874 }
1875
1876 /*
1877  * Configure:
1878  *     mp_naps
1879  *     ID_TO_CPU(N), APIC ID to logical CPU table
1880  *     CPU_TO_ID(N), logical CPU to APIC ID table
1881  */
1882 static void
1883 mptable_lapic_enumerate(struct lapic_enumerator *e)
1884 {
1885         struct mptable_pos mpt;
1886         struct mptable_lapic_cbarg1 arg1;
1887         struct mptable_lapic_cbarg2 arg2;
1888         mpcth_t cth;
1889         int error, logical_cpus = 0;
1890         vm_offset_t lapic_addr;
1891
1892         if (mptable_use_default) {
1893                 mptable_lapic_default();
1894                 return;
1895         }
1896
1897         error = mptable_map(&mpt);
1898         if (error)
1899                 panic("mptable_lapic_enumerate mptable_map failed\n");
1900         KKASSERT(!MPTABLE_POS_USE_DEFAULT(&mpt));
1901
1902         cth = mpt.mp_cth;
1903
1904         /* Save local apic address */
1905         lapic_addr = (vm_offset_t)cth->apic_address;
1906         KKASSERT(lapic_addr != 0);
1907
1908         /*
1909          * Find out how many CPUs do we have
1910          */
1911         bzero(&arg1, sizeof(arg1));
1912         arg1.ht_fixup = 1; /* Apply ht fixup by default */
1913
1914         error = mptable_iterate_entries(cth,
1915                     mptable_lapic_pass1_callback, &arg1);
1916         if (error)
1917                 panic("mptable_iterate_entries(lapic_pass1) failed\n");
1918         KKASSERT(arg1.cpu_count != 0);
1919
1920         /* See if we need to fixup HT logical CPUs. */
1921         if (arg1.ht_fixup) {
1922                 logical_cpus = mptable_hyperthread_fixup(arg1.ht_apicid_mask,
1923                                                          arg1.cpu_count);
1924                 if (logical_cpus != 0)
1925                         arg1.cpu_count *= logical_cpus;
1926         }
1927         mp_naps = arg1.cpu_count;
1928
1929         /* Qualify the numbers again, after possible HT fixup */
1930         if (mp_naps > MAXCPU) {
1931                 kprintf("Warning: only using %d of %d available CPUs!\n",
1932                         MAXCPU, mp_naps);
1933                 mp_naps = MAXCPU;
1934         }
1935
1936         --mp_naps;      /* subtract the BSP */
1937
1938         /*
1939          * Link logical CPU id to local apic id
1940          */
1941         bzero(&arg2, sizeof(arg2));
1942         arg2.cpu = 1;
1943         arg2.logical_cpus = logical_cpus;
1944
1945         error = mptable_iterate_entries(cth,
1946                     mptable_lapic_pass2_callback, &arg2);
1947         if (error)
1948                 panic("mptable_iterate_entries(lapic_pass2) failed\n");
1949         KKASSERT(arg2.found_bsp);
1950
1951         /* Map local apic */
1952         lapic_map(lapic_addr);
1953
1954         mptable_unmap(&mpt);
1955 }
1956
1957 struct mptable_lapic_probe_cbarg {
1958         int     cpu_count;
1959         int     found_bsp;
1960 };
1961
1962 static int
1963 mptable_lapic_probe_callback(void *xarg, const void *pos, int type)
1964 {
1965         const struct PROCENTRY *ent;
1966         struct mptable_lapic_probe_cbarg *arg = xarg;
1967
1968         if (type != 0)
1969                 return 0;
1970         ent = pos;
1971
1972         if ((ent->cpu_flags & PROCENTRY_FLAG_EN) == 0)
1973                 return 0;
1974         arg->cpu_count++;
1975
1976         if (ent->cpu_flags & PROCENTRY_FLAG_BP) {
1977                 if (arg->found_bsp) {
1978                         kprintf("more than one BSP in base MP table\n");
1979                         return EINVAL;
1980                 }
1981                 arg->found_bsp = 1;
1982         }
1983         return 0;
1984 }
1985
1986 static int
1987 mptable_lapic_probe(struct lapic_enumerator *e)
1988 {
1989         struct mptable_pos mpt;
1990         struct mptable_lapic_probe_cbarg arg;
1991         mpcth_t cth;
1992         int error;
1993
1994         if (mptable_fps_phyaddr == 0)
1995                 return ENXIO;
1996
1997         if (mptable_use_default)
1998                 return 0;
1999
2000         error = mptable_map(&mpt);
2001         if (error)
2002                 return error;
2003         KKASSERT(!MPTABLE_POS_USE_DEFAULT(&mpt));
2004
2005         error = EINVAL;
2006         cth = mpt.mp_cth;
2007
2008         if (cth->apic_address == 0)
2009                 goto done;
2010
2011         bzero(&arg, sizeof(arg));
2012         error = mptable_iterate_entries(cth,
2013                     mptable_lapic_probe_callback, &arg);
2014         if (!error) {
2015                 if (arg.cpu_count == 0) {
2016                         kprintf("MP table contains no processor entries\n");
2017                         error = EINVAL;
2018                 } else if (!arg.found_bsp) {
2019                         kprintf("MP table does not contains BSP entry\n");
2020                         error = EINVAL;
2021                 }
2022         }
2023 done:
2024         mptable_unmap(&mpt);
2025         return error;
2026 }
2027
2028 static struct lapic_enumerator  mptable_lapic_enumerator = {
2029         .lapic_prio = LAPIC_ENUM_PRIO_MPTABLE,
2030         .lapic_probe = mptable_lapic_probe,
2031         .lapic_enumerate = mptable_lapic_enumerate
2032 };
2033
2034 static void
2035 mptable_lapic_enum_register(void)
2036 {
2037         lapic_enumerator_register(&mptable_lapic_enumerator);
2038 }
2039 SYSINIT(mptable_lapic, SI_BOOT2_PRESMP, SI_ORDER_ANY,
2040         mptable_lapic_enum_register, 0);
2041
2042 static int
2043 mptable_ioapic_list_callback(void *xarg, const void *pos, int type)
2044 {
2045         const struct IOAPICENTRY *ent;
2046         struct mptable_ioapic *nioapic, *ioapic;
2047
2048         if (type != 2)
2049                 return 0;
2050         ent = pos;
2051
2052         if ((ent->apic_flags & IOAPICENTRY_FLAG_EN) == 0)
2053                 return 0;
2054
2055         if (ent->apic_address == 0) {
2056                 kprintf("mptable_ioapic_create_list: zero IOAPIC addr\n");
2057                 return EINVAL;
2058         }
2059
2060         TAILQ_FOREACH(ioapic, &mptable_ioapic_list, mio_link) {
2061                 if (ioapic->mio_apic_id == ent->apic_id) {
2062                         kprintf("mptable_ioapic_create_list: duplicated "
2063                                 "apic id %d\n", ioapic->mio_apic_id);
2064                         return EINVAL;
2065                 }
2066                 if (ioapic->mio_addr == (uint32_t)ent->apic_address) {
2067                         kprintf("mptable_ioapic_create_list: overlapped "
2068                                 "IOAPIC addr 0x%08x", ioapic->mio_addr);
2069                         return EINVAL;
2070                 }
2071         }
2072
2073         nioapic = kmalloc(sizeof(*nioapic), M_DEVBUF, M_WAITOK | M_ZERO);
2074         nioapic->mio_apic_id = ent->apic_id;
2075         nioapic->mio_addr = (uint32_t)ent->apic_address;
2076
2077         /*
2078          * Create IOAPIC list in ascending order of APIC ID
2079          */
2080         TAILQ_FOREACH_REVERSE(ioapic, &mptable_ioapic_list,
2081             mptable_ioapic_list, mio_link) {
2082                 if (nioapic->mio_apic_id > ioapic->mio_apic_id) {
2083                         TAILQ_INSERT_AFTER(&mptable_ioapic_list,
2084                             ioapic, nioapic, mio_link);
2085                         break;
2086                 }
2087         }
2088         if (ioapic == NULL)
2089                 TAILQ_INSERT_HEAD(&mptable_ioapic_list, nioapic, mio_link);
2090
2091         return 0;
2092 }
2093
2094 static void
2095 mptable_ioapic_create_list(void)
2096 {
2097         struct mptable_ioapic *ioapic;
2098         struct mptable_pos mpt;
2099         int idx, error;
2100
2101         if (mptable_fps_phyaddr == 0)
2102                 return;
2103
2104         if (mptable_use_default) {
2105                 ioapic = kmalloc(sizeof(*ioapic), M_DEVBUF, M_WAITOK | M_ZERO);
2106                 ioapic->mio_idx = 0;
2107                 ioapic->mio_apic_id = 0;        /* NOTE: any value is ok here */
2108                 ioapic->mio_addr = 0xfec00000;  /* XXX magic number */
2109
2110                 TAILQ_INSERT_HEAD(&mptable_ioapic_list, ioapic, mio_link);
2111                 return;
2112         }
2113
2114         error = mptable_map(&mpt);
2115         if (error)
2116                 panic("mptable_ioapic_create_list: mptable_map failed\n");
2117         KKASSERT(!MPTABLE_POS_USE_DEFAULT(&mpt));
2118
2119         error = mptable_iterate_entries(mpt.mp_cth,
2120                     mptable_ioapic_list_callback, NULL);
2121         if (error) {
2122                 while ((ioapic = TAILQ_FIRST(&mptable_ioapic_list)) != NULL) {
2123                         TAILQ_REMOVE(&mptable_ioapic_list, ioapic, mio_link);
2124                         kfree(ioapic, M_DEVBUF);
2125                 }
2126                 goto done;
2127         }
2128
2129         /*
2130          * Assign index number for each IOAPIC
2131          */
2132         idx = 0;
2133         TAILQ_FOREACH(ioapic, &mptable_ioapic_list, mio_link) {
2134                 ioapic->mio_idx = idx;
2135                 ++idx;
2136         }
2137 done:
2138         mptable_unmap(&mpt);
2139 }
2140 SYSINIT(mptable_ioapic_list, SI_BOOT2_PRESMP, SI_ORDER_SECOND,
2141         mptable_ioapic_create_list, 0);
2142
2143 static int
2144 mptable_pci_int_callback(void *xarg, const void *pos, int type)
2145 {
2146         const struct mptable_bus_info *bus_info = xarg;
2147         const struct mptable_ioapic *ioapic;
2148         const struct mptable_bus *bus;
2149         struct mptable_pci_int *pci_int;
2150         const struct INTENTRY *ent;
2151         int pci_pin, pci_dev;
2152
2153         if (type != 3)
2154                 return 0;
2155         ent = pos;
2156
2157         if (ent->int_type != 0)
2158                 return 0;
2159
2160         TAILQ_FOREACH(bus, &bus_info->mbi_list, mb_link) {
2161                 if (bus->mb_type == MPTABLE_BUS_PCI &&
2162                     bus->mb_id == ent->src_bus_id)
2163                         break;
2164         }
2165         if (bus == NULL)
2166                 return 0;
2167
2168         TAILQ_FOREACH(ioapic, &mptable_ioapic_list, mio_link) {
2169                 if (ioapic->mio_apic_id == ent->dst_apic_id)
2170                         break;
2171         }
2172         if (ioapic == NULL) {
2173                 kprintf("MPTABLE: warning PCI int dst apic id %d "
2174                         "does not exist\n", ent->dst_apic_id);
2175                 return 0;
2176         }
2177
2178         pci_pin = ent->src_bus_irq & 0x3;
2179         pci_dev = (ent->src_bus_irq >> 2) & 0x1f;
2180
2181         TAILQ_FOREACH(pci_int, &mptable_pci_int_list, mpci_link) {
2182                 if (pci_int->mpci_bus == ent->src_bus_id &&
2183                     pci_int->mpci_dev == pci_dev &&
2184                     pci_int->mpci_pin == pci_pin) {
2185                         if (pci_int->mpci_ioapic_idx == ioapic->mio_idx &&
2186                             pci_int->mpci_ioapic_pin == ent->dst_apic_int) {
2187                                 kprintf("MPTABLE: warning duplicated "
2188                                         "PCI int entry for "
2189                                         "bus %d, dev %d, pin %d\n",
2190                                         pci_int->mpci_bus,
2191                                         pci_int->mpci_dev,
2192                                         pci_int->mpci_pin);
2193                                 return 0;
2194                         } else {
2195                                 kprintf("mptable_pci_int_register: "
2196                                         "conflict PCI int entry for "
2197                                         "bus %d, dev %d, pin %d, "
2198                                         "IOAPIC %d.%d -> %d.%d\n",
2199                                         pci_int->mpci_bus,
2200                                         pci_int->mpci_dev,
2201                                         pci_int->mpci_pin,
2202                                         pci_int->mpci_ioapic_idx,
2203                                         pci_int->mpci_ioapic_pin,
2204                                         ioapic->mio_idx,
2205                                         ent->dst_apic_int);
2206                                 return EINVAL;
2207                         }
2208                 }
2209         }
2210
2211         pci_int = kmalloc(sizeof(*pci_int), M_DEVBUF, M_WAITOK | M_ZERO);
2212
2213         pci_int->mpci_bus = ent->src_bus_id;
2214         pci_int->mpci_dev = pci_dev;
2215         pci_int->mpci_pin = pci_pin;
2216         pci_int->mpci_ioapic_idx = ioapic->mio_idx;
2217         pci_int->mpci_ioapic_pin = ent->dst_apic_int;
2218
2219         TAILQ_INSERT_TAIL(&mptable_pci_int_list, pci_int, mpci_link);
2220
2221         return 0;
2222 }
2223
2224 static void
2225 mptable_pci_int_register(void)
2226 {
2227         struct mptable_bus_info bus_info;
2228         const struct mptable_bus *bus;
2229         struct mptable_pci_int *pci_int;
2230         struct mptable_pos mpt;
2231         int error, force_pci0, npcibus;
2232         mpcth_t cth;
2233
2234         if (mptable_fps_phyaddr == 0)
2235                 return;
2236
2237         if (mptable_use_default)
2238                 return;
2239
2240         if (TAILQ_EMPTY(&mptable_ioapic_list))
2241                 return;
2242
2243         error = mptable_map(&mpt);
2244         if (error)
2245                 panic("mptable_pci_int_register: mptable_map failed\n");
2246         KKASSERT(!MPTABLE_POS_USE_DEFAULT(&mpt));
2247
2248         cth = mpt.mp_cth;
2249
2250         mptable_bus_info_alloc(cth, &bus_info);
2251         if (TAILQ_EMPTY(&bus_info.mbi_list))
2252                 goto done;
2253
2254         force_pci0 = 0;
2255         npcibus = 0;
2256         TAILQ_FOREACH(bus, &bus_info.mbi_list, mb_link) {
2257                 if (bus->mb_type == MPTABLE_BUS_PCI)
2258                         ++npcibus;
2259         }
2260         if (npcibus == 0) {
2261                 mptable_bus_info_free(&bus_info);
2262                 goto done;
2263         } else if (npcibus == 1) {
2264                 force_pci0 = 1;
2265         }
2266
2267         error = mptable_iterate_entries(cth,
2268                     mptable_pci_int_callback, &bus_info);
2269
2270         mptable_bus_info_free(&bus_info);
2271
2272         if (error) {
2273                 while ((pci_int = TAILQ_FIRST(&mptable_pci_int_list)) != NULL) {
2274                         TAILQ_REMOVE(&mptable_pci_int_list, pci_int, mpci_link);
2275                         kfree(pci_int, M_DEVBUF);
2276                 }
2277                 goto done;
2278         }
2279
2280         if (force_pci0) {
2281                 TAILQ_FOREACH(pci_int, &mptable_pci_int_list, mpci_link)
2282                         pci_int->mpci_bus = 0;
2283         }
2284 done:
2285         mptable_unmap(&mpt);
2286 }
2287 SYSINIT(mptable_pci, SI_BOOT2_PRESMP, SI_ORDER_ANY,
2288         mptable_pci_int_register, 0);
2289
2290 struct mptable_ioapic_probe_cbarg {
2291         const struct mptable_bus_info *bus_info;
2292 };
2293
2294 static int
2295 mptable_ioapic_probe_callback(void *xarg, const void *pos, int type)
2296 {
2297         struct mptable_ioapic_probe_cbarg *arg = xarg;
2298         const struct mptable_ioapic *ioapic;
2299         const struct mptable_bus *bus;
2300         const struct INTENTRY *ent;
2301
2302         if (type != 3)
2303                 return 0;
2304         ent = pos;
2305
2306         if (ent->int_type != 0)
2307                 return 0;
2308
2309         TAILQ_FOREACH(bus, &arg->bus_info->mbi_list, mb_link) {
2310                 if (bus->mb_type == MPTABLE_BUS_ISA &&
2311                     bus->mb_id == ent->src_bus_id)
2312                         break;
2313         }
2314         if (bus == NULL)
2315                 return 0;
2316
2317         TAILQ_FOREACH(ioapic, &mptable_ioapic_list, mio_link) {
2318                 if (ioapic->mio_apic_id == ent->dst_apic_id)
2319                         break;
2320         }
2321         if (ioapic == NULL) {
2322                 kprintf("MPTABLE: warning ISA int dst apic id %d "
2323                         "does not exist\n", ent->dst_apic_id);
2324                 return 0;
2325         }
2326
2327         /* XXX magic number */
2328         if (ent->src_bus_irq >= 16) {
2329                 kprintf("mptable_ioapic_probe: invalid ISA irq (%d)\n",
2330                         ent->src_bus_irq);
2331                 return EINVAL;
2332         }
2333         return 0;
2334 }
2335
2336 static int
2337 mptable_ioapic_probe(struct ioapic_enumerator *e)
2338 {
2339         struct mptable_ioapic_probe_cbarg arg;
2340         struct mptable_bus_info bus_info;
2341         struct mptable_pos mpt;
2342         mpcth_t cth;
2343         int error;
2344
2345         if (mptable_fps_phyaddr == 0)
2346                 return ENXIO;
2347
2348         if (mptable_use_default)
2349                 return 0;
2350
2351         if (TAILQ_EMPTY(&mptable_ioapic_list))
2352                 return ENXIO;
2353
2354         error = mptable_map(&mpt);
2355         if (error)
2356                 panic("mptable_ioapic_probe: mptable_map failed\n");
2357         KKASSERT(!MPTABLE_POS_USE_DEFAULT(&mpt));
2358
2359         cth = mpt.mp_cth;
2360
2361         mptable_bus_info_alloc(cth, &bus_info);
2362
2363         bzero(&arg, sizeof(arg));
2364         arg.bus_info = &bus_info;
2365
2366         error = mptable_iterate_entries(cth,
2367                     mptable_ioapic_probe_callback, &arg);
2368
2369         mptable_bus_info_free(&bus_info);
2370         mptable_unmap(&mpt);
2371
2372         return error;
2373 }
2374
2375 struct mptable_ioapic_int_cbarg {
2376         const struct mptable_bus_info *bus_info;
2377         int     ioapic_nint;
2378 };
2379
2380 static int
2381 mptable_ioapic_int_callback(void *xarg, const void *pos, int type)
2382 {
2383         struct mptable_ioapic_int_cbarg *arg = xarg;
2384         const struct mptable_ioapic *ioapic;
2385         const struct mptable_bus *bus;
2386         const struct INTENTRY *ent;
2387         int gsi;
2388
2389         if (type != 3)
2390                 return 0;
2391
2392         arg->ioapic_nint++;
2393
2394         ent = pos;
2395         if (ent->int_type != 0)
2396                 return 0;
2397
2398         TAILQ_FOREACH(bus, &arg->bus_info->mbi_list, mb_link) {
2399                 if (bus->mb_type == MPTABLE_BUS_ISA &&
2400                     bus->mb_id == ent->src_bus_id)
2401                         break;
2402         }
2403         if (bus == NULL)
2404                 return 0;
2405
2406         TAILQ_FOREACH(ioapic, &mptable_ioapic_list, mio_link) {
2407                 if (ioapic->mio_apic_id == ent->dst_apic_id)
2408                         break;
2409         }
2410         if (ioapic == NULL) {
2411                 kprintf("MPTABLE: warning ISA int dst apic id %d "
2412                         "does not exist\n", ent->dst_apic_id);
2413                 return 0;
2414         }
2415
2416         if (ent->dst_apic_int >= ioapic->mio_npin) {
2417                 panic("mptable_ioapic_enumerate: invalid I/O APIC "
2418                       "pin %d, should be < %d",
2419                       ent->dst_apic_int, ioapic->mio_npin);
2420         }
2421         gsi = ioapic->mio_gsi_base + ent->dst_apic_int;
2422
2423         if (ent->src_bus_irq != gsi) {
2424                 if (bootverbose) {
2425                         kprintf("MPTABLE: INTSRC irq %d -> GSI %d\n",
2426                                 ent->src_bus_irq, gsi);
2427                 }
2428                 ioapic_intsrc(ent->src_bus_irq, gsi,
2429                     INTR_TRIGGER_EDGE, INTR_POLARITY_HIGH);
2430         }
2431         return 0;
2432 }
2433
2434 static void
2435 mptable_ioapic_enumerate(struct ioapic_enumerator *e)
2436 {
2437         struct mptable_bus_info bus_info;
2438         struct mptable_ioapic *ioapic;
2439         struct mptable_pos mpt;
2440         mpcth_t cth;
2441         int error;
2442
2443         KKASSERT(mptable_fps_phyaddr != 0);
2444         KKASSERT(!TAILQ_EMPTY(&mptable_ioapic_list));
2445
2446         TAILQ_FOREACH(ioapic, &mptable_ioapic_list, mio_link) {
2447                 const struct mptable_ioapic *prev_ioapic;
2448                 uint32_t ver;
2449                 void *addr;
2450
2451                 addr = ioapic_map(ioapic->mio_addr);
2452
2453                 ver = ioapic_read(addr, IOAPIC_VER);
2454                 ioapic->mio_npin = ((ver & IOART_VER_MAXREDIR)
2455                                     >> MAXREDIRSHIFT) + 1;
2456
2457                 prev_ioapic = TAILQ_PREV(ioapic,
2458                                 mptable_ioapic_list, mio_link);
2459                 if (prev_ioapic == NULL) {
2460                         ioapic->mio_gsi_base = 0;
2461                 } else {
2462                         ioapic->mio_gsi_base =
2463                                 prev_ioapic->mio_gsi_base +
2464                                 prev_ioapic->mio_npin;
2465                 }
2466                 ioapic_add(addr, ioapic->mio_gsi_base,
2467                     ioapic->mio_npin);
2468
2469                 if (bootverbose) {
2470                         kprintf("MPTABLE: IOAPIC addr 0x%08x, "
2471                                 "apic id %d, idx %d, gsi base %d, npin %d\n",
2472                                 ioapic->mio_addr,
2473                                 ioapic->mio_apic_id,
2474                                 ioapic->mio_idx,
2475                                 ioapic->mio_gsi_base,
2476                                 ioapic->mio_npin);
2477                 }
2478         }
2479
2480         if (mptable_use_default) {
2481                 if (bootverbose)
2482                         kprintf("MPTABLE: INTSRC irq 0 -> GSI 2 (default)\n");
2483                 ioapic_intsrc(0, 2, INTR_TRIGGER_EDGE, INTR_POLARITY_HIGH);
2484                 return;
2485         }
2486
2487         error = mptable_map(&mpt);
2488         if (error)
2489                 panic("mptable_ioapic_probe: mptable_map failed\n");
2490         KKASSERT(!MPTABLE_POS_USE_DEFAULT(&mpt));
2491
2492         cth = mpt.mp_cth;
2493
2494         mptable_bus_info_alloc(cth, &bus_info);
2495
2496         if (TAILQ_EMPTY(&bus_info.mbi_list)) {
2497                 if (bootverbose)
2498                         kprintf("MPTABLE: INTSRC irq 0 -> GSI 2 (no bus)\n");
2499                 ioapic_intsrc(0, 2, INTR_TRIGGER_EDGE, INTR_POLARITY_HIGH);
2500         } else {
2501                 struct mptable_ioapic_int_cbarg arg;
2502
2503                 bzero(&arg, sizeof(arg));
2504                 arg.bus_info = &bus_info;
2505
2506                 error = mptable_iterate_entries(cth,
2507                             mptable_ioapic_int_callback, &arg);
2508                 if (error)
2509                         panic("mptable_ioapic_int failed\n");
2510
2511                 if (arg.ioapic_nint == 0) {
2512                         if (bootverbose) {
2513                                 kprintf("MPTABLE: INTSRC irq 0 -> GSI 2 "
2514                                         "(no int)\n");
2515                         }
2516                         ioapic_intsrc(0, 2, INTR_TRIGGER_EDGE,
2517                             INTR_POLARITY_HIGH);
2518                 }
2519         }
2520
2521         mptable_bus_info_free(&bus_info);
2522
2523         mptable_unmap(&mpt);
2524 }
2525
2526 static struct ioapic_enumerator mptable_ioapic_enumerator = {
2527         .ioapic_prio = IOAPIC_ENUM_PRIO_MPTABLE,
2528         .ioapic_probe = mptable_ioapic_probe,
2529         .ioapic_enumerate = mptable_ioapic_enumerate
2530 };
2531
2532 static void
2533 mptable_ioapic_enum_register(void)
2534 {
2535         ioapic_enumerator_register(&mptable_ioapic_enumerator);
2536 }
2537 SYSINIT(mptable_ioapic, SI_BOOT2_PRESMP, SI_ORDER_ANY,
2538         mptable_ioapic_enum_register, 0);
2539
2540 void
2541 mptable_pci_int_dump(void)
2542 {
2543         const struct mptable_pci_int *pci_int;
2544
2545         TAILQ_FOREACH(pci_int, &mptable_pci_int_list, mpci_link) {
2546                 kprintf("MPTABLE: %d:%d INT%c -> IOAPIC %d.%d\n",
2547                         pci_int->mpci_bus,
2548                         pci_int->mpci_dev,
2549                         pci_int->mpci_pin + 'A',
2550                         pci_int->mpci_ioapic_idx,
2551                         pci_int->mpci_ioapic_pin);
2552         }
2553 }
2554
2555 int
2556 mptable_pci_int_route(int bus, int dev, int pin, int intline)
2557 {
2558         const struct mptable_pci_int *pci_int;
2559         int irq = -1;
2560
2561         KKASSERT(pin >= 1);
2562         --pin;  /* zero based */
2563
2564         TAILQ_FOREACH(pci_int, &mptable_pci_int_list, mpci_link) {
2565                 if (pci_int->mpci_bus == bus &&
2566                     pci_int->mpci_dev == dev &&
2567                     pci_int->mpci_pin == pin)
2568                         break;
2569         }
2570         if (pci_int != NULL) {
2571                 int gsi;
2572
2573                 gsi = ioapic_gsi(pci_int->mpci_ioapic_idx,
2574                         pci_int->mpci_ioapic_pin);
2575                 if (gsi >= 0) {
2576                         irq = ioapic_abi_find_gsi(gsi,
2577                                 INTR_TRIGGER_LEVEL, INTR_POLARITY_LOW);
2578                 }
2579         }
2580
2581         if (irq < 0) {
2582                 if (bootverbose) {
2583                         kprintf("MPTABLE: fixed interrupt routing "
2584                                 "for %d:%d INT%c\n", bus, dev, pin + 'A');
2585                 }
2586
2587                 irq = ioapic_abi_find_irq(intline,
2588                         INTR_TRIGGER_LEVEL, INTR_POLARITY_LOW);
2589         }
2590
2591         if (irq >= 0 && bootverbose) {
2592                 kprintf("MPTABLE: %d:%d INT%c routed to irq %d\n",
2593                         bus, dev, pin + 'A', irq);
2594         }
2595         return irq;
2596 }