sys/platform/pc32/i386/mp_machdep.c

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