sys/platform/pc64/x86_64/mp_machdep.c

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