root/arch/i386/i386/mpbios.c

DEFINITIONS

1. mp_print
2. mp_match
3. mpbios_map
4. mpbios_unmap
5. mpbios_probe
6. mpbios_cksum
7. mpbios_search
8. mpbios_scan
9. mpbios_invent
10. mpbios_cpu
11. mp_cfg_special_intr
12. mp_cfg_pci_intr
13. mp_cfg_eisa_intr
14. mp_cfg_isa_intr
15. mp_print_special_intr
16. mp_print_pci_intr
17. mp_print_isa_intr
18. mp_print_eisa_intr
19. mpbios_bus
20. mpbios_ioapic
21. mpbios_int

    1 /*      $OpenBSD: mpbios.c,v 1.22 2007/04/24 13:00:59 tom Exp $ */
    2 /*      $NetBSD: mpbios.c,v 1.2 2002/10/01 12:56:57 fvdl Exp $  */
    4 /*-
    5  * Copyright (c) 2000 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by RedBack Networks Inc.
   10  *
   11  * Author: Bill Sommerfeld
   12  *
   13  * Redistribution and use in source and binary forms, with or without
   14  * modification, are permitted provided that the following conditions
   15  * are met:
   16  * 1. Redistributions of source code must retain the above copyright
   17  *    notice, this list of conditions and the following disclaimer.
   18  * 2. Redistributions in binary form must reproduce the above copyright
   19  *    notice, this list of conditions and the following disclaimer in the
   20  *    documentation and/or other materials provided with the distribution.
   21  * 3. All advertising materials mentioning features or use of this software
   22  *    must display the following acknowledgement:
   23  *        This product includes software developed by the NetBSD
   24  *        Foundation, Inc. and its contributors.
   25  * 4. Neither the name of The NetBSD Foundation nor the names of its
   26  *    contributors may be used to endorse or promote products derived
   27  *    from this software without specific prior written permission.
   28  *
   29  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   30  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   31  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   32  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   33  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   34  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   35  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   36  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   37  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   38  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   39  * POSSIBILITY OF SUCH DAMAGE.
   40  */
   42 /*
   43  * Copyright (c) 1999 Stefan Grefen
   44  *
   45  * Redistribution and use in source and binary forms, with or without
   46  * modification, are permitted provided that the following conditions
   47  * are met:
   48  * 1. Redistributions of source code must retain the above copyright
   49  *    notice, this list of conditions and the following disclaimer.
   50  * 2. Redistributions in binary form must reproduce the above copyright
   51  *    notice, this list of conditions and the following disclaimer in the
   52  *    documentation and/or other materials provided with the distribution.
   53  * 3. All advertising materials mentioning features or use of this software
   54  *    must display the following acknowledgement:
   55  *      This product includes software developed by the NetBSD
   56  *      Foundation, Inc. and its contributors.
   57  * 4. Neither the name of The NetBSD Foundation nor the names of its
   58  *    contributors may be used to endorse or promote products derived
   59  *    from this software without specific prior written permission.
   60  *
   61  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
   62  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   63  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   64  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR AND CONTRIBUTORS BE LIABLE
   65  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   66  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   67  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   68  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   69  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   70  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   71  * SUCH DAMAGE.
   72  */
   73 /*
   74  * Derived from FreeBSD's mp_machdep.c
   75  */
   76 /*
   77  * Copyright (c) 1996, by Steve Passe
   78  * All rights reserved.
   79  *
   80  * Redistribution and use in source and binary forms, with or without
   81  * modification, are permitted provided that the following conditions
   82  * are met:
   83  * 1. Redistributions of source code must retain the above copyright
   84  *    notice, this list of conditions and the following disclaimer.
   85  * 2. The name of the developer may NOT be used to endorse or promote products
   86  *    derived from this software without specific prior written permission.
   87  *
   88  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   89  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   90  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   91  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   92  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   93  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   94  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   95  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   96  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   97  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   98  * SUCH DAMAGE.
   99  */
  101 /*
  102  * The Intel MP-stuff is just one way of x86 SMP systems
  103  * so only Intel MP specific stuff is here.
  104  */
  106 #include "mpbios.h"
  108 #include <sys/param.h>
  109 #include <sys/systm.h>
  110 #include <sys/kernel.h>
  111 #include <sys/device.h>
  112 #include <sys/malloc.h>
  114 #include <uvm/uvm_extern.h>
  116 #include <machine/specialreg.h>
  117 #include <machine/cputypes.h>
  118 #include <machine/cpuvar.h>
  119 #include <machine/bus.h>
  120 #include <machine/mpbiosreg.h>
  121 #include <machine/mpbiosvar.h>
  123 #include <machine/i82093reg.h>
  124 #include <machine/i82093var.h>
  125 #include <machine/i82489reg.h>
  126 #include <machine/i82489var.h>
  128 #include <dev/isa/isareg.h>
  129 #include <dev/pci/pcivar.h>
  131 #include <dev/eisa/eisavar.h>   /* for ELCR* def'ns */
  133 #include "pci.h"
  136 static struct mpbios_ioapic default_ioapic = {
  137     2, 0, 1, IOAPICENTRY_FLAG_EN, (caddr_t)IOAPIC_BASE_DEFAULT
  138 };
  140 /* descriptions of MP basetable entries */
  141 struct mpbios_baseentry {
u_int8_t        type;
u_int8_t        length;
u_int16_t       count;
  145         const char      *name;
  146 };
  148 static const char *loc_where[] = {
  149         "extended bios data area",
  150         "last page of base memory",
  151         "bios"
  152 };
  154 struct mp_map
  155 {
vaddr_t         baseva;
  157         int             vsize;
paddr_t         pa;
paddr_t         pg;
  160         int             psize;
  161 };
  163 int     mp_print(void *, const char *);
  164 int     mp_match(struct device *, void *, void *);
  165 int     mpbios_cpu_start(struct cpu_info *);
  166 const void *mpbios_search(struct device *, paddr_t, int,
  167     struct mp_map *);
  168 static __inline int mpbios_cksum(const void *, int);
  170 void    mp_cfg_special_intr(const struct mpbios_int *, u_int32_t *);
  171 void    mp_cfg_pci_intr(const struct mpbios_int *, u_int32_t *);
  172 void    mp_cfg_eisa_intr(const struct mpbios_int *, u_int32_t *);
  173 void    mp_cfg_isa_intr(const struct mpbios_int *, u_int32_t *);
  174 void    mp_print_special_intr (int);
  175 void    mp_print_pci_intr (int);
  176 void    mp_print_eisa_intr (int);
  177 void    mp_print_isa_intr (int);
  179 void    mpbios_cpu(const u_int8_t *, struct device *);
  180 void    mpbios_bus(const u_int8_t *, struct device *);
  181 void    mpbios_ioapic(const u_int8_t *, struct device *);
  182 int     mpbios_int(const u_int8_t *, struct mp_intr_map *);
  184 const void *mpbios_map(paddr_t, int, struct mp_map *);
  185 static __inline void mpbios_unmap(struct mp_map *);
  187 /*
  188  * globals to help us bounce our way through parsing the config table.
  189  */
  191 static struct mp_map mp_cfg_table_map;
  192 static struct mp_map mp_fp_map;
  193 const struct mpbios_cth *mp_cth;
  194 const struct mpbios_fps *mp_fps;
  196 #ifdef MPVERBOSE
  197 int mp_verbose = 1;
  198 #else
  199 int mp_verbose = 0;
  200 #endif
  202 int
mp_print(void *aux, const char *pnp)
  204 {
  205         struct cpu_attach_args * caa = (struct cpu_attach_args *) aux;
  206         if (pnp)
printf("%s at %s:", caa->caa_name, pnp);
  208         return (UNCONF);
  209 }
  211 int
mp_match(struct device *parent, void *cfv, void *aux)
  213 {
  214         struct cfdata *cf = (struct cfdata *)cfv;
  215         struct cpu_attach_args * caa = (struct cpu_attach_args *) aux;
  216         if (strcmp(caa->caa_name, cf->cf_driver->cd_name))
  217                 return 0;
  219         return ((*cf->cf_attach->ca_match)(parent, cf, aux));
  220 }
  222 /*
  223  * Map a chunk of memory read-only and return an appropriately
  224  * const'ed pointer.
  225  */
  226 const void *
mpbios_map(paddr_t pa, int len, struct mp_map *handle)
  228 {
paddr_t pgpa = trunc_page(pa);
paddr_t endpa = round_page(pa + len);
vaddr_t va = uvm_km_valloc(kernel_map, endpa - pgpa);
vaddr_t retva = va + (pa & PGOFSET);
handle->pa = pa;
handle->pg = pgpa;
handle->psize = len;
handle->baseva = va;
handle->vsize = endpa-pgpa;
  240         do {
  241 #if 1
pmap_kenter_pa(va, pgpa, VM_PROT_READ);
  243 #else
pmap_enter(pmap_kernel(), va, pgpa, VM_PROT_READ, TRUE,
VM_PROT_READ);
  246 #endif
va += NBPG;
pgpa += NBPG;
  249         } while (pgpa < endpa);
  251         return ((const void *)retva);
  252 }
  254 static __inline void
mpbios_unmap(struct mp_map *handle)
  256 {
  257 #if 1
pmap_kremove(handle->baseva, handle->vsize);
  259 #else
pmap_extract(pmap_kernel(), handle->baseva, NULL);
  261 #endif
uvm_km_free(kernel_map, handle->baseva, handle->vsize);
  263 }
  265 /*
  266  * Look for an Intel MP spec table, indicating SMP capable hardware.
  267  */
  268 int
mpbios_probe(struct device *self)
  270 {
paddr_t         ebda, memtop;
paddr_t         cthpa;
  274         int             cthlen;
  275         const u_int8_t  *mpbios_page;
  276         int             scan_loc;
  278         struct          mp_map t;
  280         /*
  281          * Skip probe if someone else (e.g. acpi) already provided the
  282          * necessary details.
  283          */
  284         if (mp_busses)
  285                 return (0);
  287         /* see if EBDA exists */
mpbios_page = mpbios_map(0, NBPG, &t);
  291         /* XXX Ugly magic constants below. */
ebda = *(const u_int16_t *)(&mpbios_page[0x40e]);
ebda <<= 4;
memtop = *(const u_int16_t *)(&mpbios_page[0x413]);
memtop <<= 10;
mpbios_page = NULL;
mpbios_unmap(&t);
scan_loc = 0;
  303         if (ebda && ebda < IOM_BEGIN ) {
mp_fps = mpbios_search(self, ebda, 1024, &mp_fp_map);
  305                 if (mp_fps != NULL)
  306                         goto found;
  307         }
scan_loc = 1;
  311         if (memtop && memtop <= IOM_BEGIN ) {
mp_fps = mpbios_search(self, memtop - 1024, 1024, &mp_fp_map);
  313                 if (mp_fps != NULL)
  314                         goto found;
  315         }
scan_loc = 2;
mp_fps = mpbios_search(self, BIOS_BASE, BIOS_COUNT, &mp_fp_map);
  320         if (mp_fps != NULL)
  321                 goto found;
  323         /* nothing found */
  324         return (0);
found:
  327         if (mp_verbose)
printf("%s: MP floating pointer found in %s at 0x%lx\n",
self->dv_xname, loc_where[scan_loc], mp_fp_map.pa);
  331         if (mp_fps->pap == 0) {
  332                 if (mp_fps->mpfb1 == 0) {
printf("%s: MP fps invalid: "
  334                             "no default config and no configuration table\n",
self->dv_xname);
  337                         goto err;
  338                 }
printf("%s: MP default configuration %d\n",
self->dv_xname, mp_fps->mpfb1);
  341                 return (10);
  342         }
cthpa = mp_fps->pap;
mp_cth = mpbios_map(cthpa, sizeof (*mp_cth), &mp_cfg_table_map);
cthlen = mp_cth->base_len;
mpbios_unmap(&mp_cfg_table_map);
mp_cth = mpbios_map(cthpa, cthlen, &mp_cfg_table_map);
  352         if (mp_verbose)
printf("%s: MP config table at 0x%lx, %d bytes long\n",
self->dv_xname, cthpa, cthlen);
  356         if (mp_cth->signature != MP_CT_SIG) {
printf("%s: MP signature mismatch (%x vs %x)\n",
self->dv_xname,
MP_CT_SIG, mp_cth->signature);
  360                 goto err;
  361         }
  363         if (mpbios_cksum(mp_cth, cthlen)) {
printf ("%s: MP Configuration Table checksum mismatch\n",
self->dv_xname);
  366                 goto err;
  367         }
  368         return (10);
err:
  371         if (mp_fps) {
mp_fps = NULL;
mpbios_unmap(&mp_fp_map);
  374         }
  375         if (mp_cth) {
mp_cth = NULL;
mpbios_unmap(&mp_cfg_table_map);
  378         }
  379         return (0);
  380 }
  383 /*
  384  * Simple byte checksum used on config tables.
  385  */
  387 static __inline int
mpbios_cksum(const void *start, int len)
  389 {
  390         unsigned char res=0;
  391         const char *p = start;
  392         const char *end = p + len;
  394         while (p < end)
res += *p++;
  397         return res;
  398 }
  401 /*
  402  * Look for the MP floating pointer signature in the given physical
  403  * address range.
  404  *
  405  * We map the memory, scan through it, and unmap it.
  406  * If we find it, remap the floating pointer structure and return it.
  407  */
  409 const void *
mpbios_search(struct device *self, paddr_t start, int count, struct mp_map *map)
  411 {
  412         struct mp_map t;
  414         int i, len;
  415         const struct mpbios_fps *m;
  416         int end = count - sizeof(*m);
  417         const u_int8_t *base = mpbios_map(start, count, &t);
  419         if (mp_verbose)
printf("%s: scanning 0x%lx to 0x%lx for MP signature\n",
self->dv_xname, start, start + count - sizeof(*m));
  423         for (i = 0; i <= end; i += 4) {
m = (struct mpbios_fps *)&base[i];
  426                 if ((m->signature == MP_FP_SIG) &&
  427                     ((len = m->length << 4) != 0) &&
mpbios_cksum(m, (m->length << 4)) == 0) {
mpbios_unmap(&t);
  431                         return (mpbios_map(start + i, len, map));
  432                 }
  433         }
mpbios_unmap(&t);
  436         return (0);
  437 }
  439 /*
  440  * MP configuration table parsing.
  441  */
  443 static struct mpbios_baseentry mp_conf[] =
  444 {
  445         {0, 20, 0, "cpu"},
  446         {1, 8, 0, "bus"},
  447         {2, 8, 0, "ioapic"},
  448         {3, 8, 0, "ioint"},
  449         {4, 8, 0, "lint"},
  450 };
  452 struct mp_bus *mp_busses;
  453 int mp_nbus;
  454 struct mp_intr_map *mp_intrs;
  455 int mp_nintrs;
  457 struct mp_bus *mp_isa_bus;
  458 struct mp_bus *mp_eisa_bus;
  460 static struct mp_bus extint_bus = {
  461         "ExtINT",
  462         -1,
mp_print_special_intr,
mp_cfg_special_intr,
  465         0
  466 };
  467 static struct mp_bus smi_bus = {
  468         "SMI",
  469         -1,
mp_print_special_intr,
mp_cfg_special_intr,
  472         0
  473 };
  474 static struct mp_bus nmi_bus = {
  475         "NMI",
  476         -1,
mp_print_special_intr,
mp_cfg_special_intr,
  479         0
  480 };
  483 /*
  484  * 1st pass on BIOS's Intel MP specification table.
  485  *
  486  * initializes:
  487  *      mp_ncpus = 1
  488  *
  489  * determines:
  490  *      cpu_apic_address (common to all CPUs)
  491  *      ioapic_address[N]
  492  *      mp_naps
  493  *      mp_nbusses
  494  *      mp_napics
  495  *      nintrs
  496  */
  497 void
mpbios_scan(struct device *self)
  499 {
  500         const u_int8_t  *position, *end;
  501         int             count;
  502         int             type;
  503         int             intr_cnt;
paddr_t         lapic_base;
printf("%s: Intel MP Specification ", self->dv_xname);
  508         switch (mp_fps->spec_rev) {
  509         case 1:
printf("(Version 1.1)\n");
  511                 break;
  512         case 4:
printf("(Version 1.4)\n");
  514                 break;
  515         default:
printf("(unrecognized rev %d)\n", mp_fps->spec_rev);
  517         }
  519         /*
  520          * looks like we've got a MP system.  start setting up
  521          * infrastructure..
  522          * XXX is this the right place??
  523          */
lapic_base = LAPIC_BASE;
  526         if (mp_cth != NULL)
lapic_base = (paddr_t)mp_cth->apic_address;
lapic_boot_init(lapic_base);
  531         /* check for use of 'default' configuration */
  532         if (mp_fps->mpfb1 != 0) {
  533                 struct mpbios_proc pe;
printf("\n%s: MP default configuration %d\n",
self->dv_xname, mp_fps->mpfb1);
  538                 /* use default addresses */
pe.apic_id = cpu_number();
pe.cpu_flags = PROCENTRY_FLAG_EN|PROCENTRY_FLAG_BP;
pe.cpu_signature = cpu_info_primary.ci_signature;
pe.feature_flags = cpu_info_primary.ci_feature_flags;
mpbios_cpu((u_int8_t *)&pe, self);
pe.apic_id = 1 - cpu_number();
pe.cpu_flags = PROCENTRY_FLAG_EN;
mpbios_cpu((u_int8_t *)&pe, self);
mpbios_ioapic((u_int8_t *)&default_ioapic, self);
  553                 /* XXX */
printf("%s: WARNING: interrupts not configured\n",
self->dv_xname);
panic("lazy bum");
  557                 return;
  558         } else {
  559                 /*
  560                  * should not happen; mp_probe returns 0 in this case,
  561                  * but..
  562                  */
  563                 if (mp_cth == NULL)
panic("mpbios_scan: no config (can't happen?)");
  566                 /*
  567                  * Walk the table once, counting items
  568                  */
  569                 for (count = mp_cth->entry_count,
position = (const u_int8_t *)mp_cth + sizeof(*mp_cth),
end = position + mp_cth->base_len;
count-- && position < end;
position += mp_conf[type].length) {
type = *position;
  576                         if (type >= MPS_MCT_NTYPES) {
printf("%s: unknown entry type %x"
  578                                     " in MP config table\n",
self->dv_xname, type);
end = position;
  581                                 break;
  582                         }
mp_conf[type].count++;
  584                 }
  586                 /*
  587                  * Walk the table twice, counting int and bus entries
  588                  */
  589                 for (count = mp_cth->entry_count,
intr_cnt = 15,      /* presume all isa irqs missing */
position = (const u_int8_t *)mp_cth + sizeof(*mp_cth);
count-- && position < end;
position += mp_conf[type].length) {
type = *position;
  595                         if (type == MPS_MCT_BUS) {
  596                                 const struct mpbios_bus *bp =
  597                                     (const struct mpbios_bus *)position;
  598                                 if (bp->bus_id >= mp_nbus)
mp_nbus = bp->bus_id + 1;
  600                         }
  602                         /*
  603                          * Count actual interrupt instances.
  604                          * dst_apic_id of MPS_ALL_APICS means "wired to all
  605                          * apics of this type".
  606                          */
  607                         if ((type == MPS_MCT_IOINT) ||
  608                             (type == MPS_MCT_LINT)) {
  609                                 const struct mpbios_int *ie =
  610                                     (const struct mpbios_int *)position;
  611                                 if (ie->dst_apic_id != MPS_ALL_APICS)
intr_cnt++;
  613                                 else if (type == MPS_MCT_IOINT)
intr_cnt +=
mp_conf[MPS_MCT_IOAPIC].count;
  616                                 else
intr_cnt += mp_conf[MPS_MCT_CPU].count;
  618                         }
  619                 }
mp_busses = malloc(sizeof(struct mp_bus) * mp_nbus,
M_DEVBUF, M_NOWAIT);
memset(mp_busses, 0, sizeof(struct mp_bus) * mp_nbus);
mp_intrs = malloc(sizeof(struct mp_intr_map) * intr_cnt,
M_DEVBUF, M_NOWAIT);
  627                 /* re-walk the table, recording info of interest */
position = (const u_int8_t *)mp_cth + sizeof(*mp_cth);
count = mp_cth->entry_count;
mp_nintrs = 0;
  632                 while ((count--) && (position < end)) {
  633                         switch (type = *(u_char *)position) {
  634                         case MPS_MCT_CPU:
mpbios_cpu(position, self);
  636                                 break;
  637                         case MPS_MCT_BUS:
mpbios_bus(position, self);
  639                                 break;
  640                         case MPS_MCT_IOAPIC:
mpbios_ioapic(position, self);
  642                                 break;
  643                         case MPS_MCT_IOINT:
  644                         case MPS_MCT_LINT:
  645                                 if (mpbios_int(position,
  646                                     &mp_intrs[mp_nintrs]) == 0)
mp_nintrs++;
  648                                 break;
  649                         default:
printf("%s: unknown entry type %x "
  651                                     "in MP config table\n",
self->dv_xname, type);
  653                                 /* NOTREACHED */
  654                                 return;
  655                         }
  657                         (u_char*)position += mp_conf[type].length;
  658                 }
  659                 if (mp_verbose && mp_cth->ext_len)
printf("%s: MP WARNING: %d "
  661                             "bytes of extended entries not examined\n",
self->dv_xname, mp_cth->ext_len);
  663         }
  664         /* Clean up. */
mp_fps = NULL;
mpbios_unmap(&mp_fp_map);
  667         if (mp_cth != NULL) {
mp_cth = NULL;
mpbios_unmap(&mp_cfg_table_map);
  670         }
  672 #if NPCI > 0
  673         if (pci_mode_detect() != 0)
mpbios_intr_fixup();
  675 #endif
  676 }
  678 int
mpbios_invent(int irq, int type, int bus)
  680 {
  681         struct mp_intr_map *mip;
  682         struct mpbios_int e;
e.type = MPS_MCT_IOINT;
e.int_type = MPS_INTTYPE_INT;
  686         switch (type) {
  687         case IST_EDGE:
e.int_flags = MPS_INT(MPS_INTPO_ACTHI, MPS_INTTR_EDGE);
  689                 break;
  691         case IST_LEVEL:
e.int_flags = MPS_INT(MPS_INTPO_ACTLO, MPS_INTTR_LEVEL);
  693                 break;
  695         case IST_NONE:
  696         case IST_PULSE:
e.int_flags = MPS_INT(MPS_INTPO_DEF, MPS_INTTR_DEF);
  698                 break;
  699         }
e.src_bus_id = bus;
e.src_bus_irq = irq;
e.dst_apic_id = mp_busses[bus].mb_intrs->ioapic->sc_apicid;
e.dst_apic_int = irq;
  705         if (mpbios_int((const u_int8_t *)&e, &mp_intrs[mp_nintrs]) == 0) {
mip = &mp_intrs[mp_nintrs++];
  707                 return (mip->ioapic_ih | irq);
  708         }
  710         return irq;
  711 }
  713 void
mpbios_cpu(const u_int8_t *ent, struct device *self)
  715 {
  716         const struct mpbios_proc *entry = (const struct mpbios_proc *)ent;
  717         struct cpu_attach_args caa;
  719         /* XXX move this into the CPU attachment goo. */
  720         /* check for usability */
  721         if (!(entry->cpu_flags & PROCENTRY_FLAG_EN))
  722                 return;
  724         /* check for BSP flag */
  725         if (entry->cpu_flags & PROCENTRY_FLAG_BP)
caa.cpu_role = CPU_ROLE_BP;
  727         else
caa.cpu_role = CPU_ROLE_AP;
caa.caa_name = "cpu";
caa.cpu_number = entry->apic_id;
caa.cpu_func = &mp_cpu_funcs;
  733 #if 1 /* XXX Will be removed when the real stuff is probed */
caa.cpu_signature = entry->cpu_signature;
  736         /*
  737          * XXX this is truncated to just contain the low-order 16 bits
  738          * of the flags on at least some MP bioses
  739          */
caa.feature_flags = entry->feature_flags;
  742         /*
  743          * XXX some MP bioses don't specify a valid CPU signature; use
  744          * the result of the 'cpuid' instruction for the processor
  745          * we're running on
  746          */
  747         if ((caa.cpu_signature & 0x00000fff) == 0) {
caa.cpu_signature = cpu_id;
caa.feature_flags = cpu_feature;
  750         }
  751 #endif
config_found_sm(self, &caa, mp_print, mp_match);
  754 }
  756 /*
  757  * The following functions conspire to compute base ioapic redirection
  758  * table entry for a given interrupt line.
  759  *
  760  * Fill in: trigger mode, polarity, and possibly delivery mode.
  761  */
  762 void
mp_cfg_special_intr(const struct mpbios_int *entry, u_int32_t *redir)
  764 {
  766         /*
  767          * All of these require edge triggered, zero vector,
  768          * appropriate delivery mode.
  769          * see page 13 of the 82093AA datasheet.
  770          */
  771         *redir &= ~IOAPIC_REDLO_DEL_MASK;
  772         *redir &= ~IOAPIC_REDLO_VECTOR_MASK;
  773         *redir &= ~IOAPIC_REDLO_LEVEL;
  775         switch (entry->int_type) {
  776         case MPS_INTTYPE_NMI:
  777                 *redir |= (IOAPIC_REDLO_DEL_NMI<<IOAPIC_REDLO_DEL_SHIFT);
  778                 break;
  780         case MPS_INTTYPE_SMI:
  781                 *redir |= (IOAPIC_REDLO_DEL_SMI<<IOAPIC_REDLO_DEL_SHIFT);
  782                 break;
  783         case MPS_INTTYPE_ExtINT:
  784                 /*
  785                  * We are using the ioapic in "native" mode.
  786                  * This indicates where the 8259 is wired to the ioapic
  787                  * and/or local apic..
  788                  */
  789                 *redir |= (IOAPIC_REDLO_DEL_EXTINT<<IOAPIC_REDLO_DEL_SHIFT);
  790                 *redir |= (IOAPIC_REDLO_MASK);
  791                 break;
  792         default:
panic("unknown MPS interrupt type %d", entry->int_type);
  794         }
  795 }
  797 /* XXX too much duplicated code here. */
  799 void
mp_cfg_pci_intr(const struct mpbios_int *entry, u_int32_t *redir)
  801 {
  802         int mpspo = entry->int_flags & 0x03; /* XXX magic */
  803         int mpstrig = (entry->int_flags >> 2) & 0x03; /* XXX magic */
  805         *redir &= ~IOAPIC_REDLO_DEL_MASK;
  806         switch (mpspo) {
  807         case MPS_INTPO_ACTHI:
  808                 *redir &= ~IOAPIC_REDLO_ACTLO;
  809                 break;
  810         case MPS_INTPO_DEF:
  811         case MPS_INTPO_ACTLO:
  812                 *redir |= IOAPIC_REDLO_ACTLO;
  813                 break;
  814         default:
panic("unknown MPS interrupt polarity %d", mpspo);
  816         }
  818         if (entry->int_type != MPS_INTTYPE_INT) {
mp_cfg_special_intr(entry, redir);
  820                 return;
  821         }
  822         *redir |= (IOAPIC_REDLO_DEL_LOPRI<<IOAPIC_REDLO_DEL_SHIFT);
  824         switch (mpstrig) {
  825         case MPS_INTTR_DEF:
  826         case MPS_INTTR_LEVEL:
  827                 *redir |= IOAPIC_REDLO_LEVEL;
  828                 break;
  829         case MPS_INTTR_EDGE:
  830                 *redir &= ~IOAPIC_REDLO_LEVEL;
  831                 break;
  832         default:
panic("unknown MPS interrupt trigger %d", mpstrig);
  834         }
  835 }
  837 void
mp_cfg_eisa_intr (const struct mpbios_int *entry, u_int32_t *redir)
  839 {
  840         int mpspo = entry->int_flags & 0x03; /* XXX magic */
  841         int mpstrig = (entry->int_flags >> 2) & 0x03; /* XXX magic */
  843         *redir &= ~IOAPIC_REDLO_DEL_MASK;
  844         switch (mpspo) {
  845         case MPS_INTPO_DEF:
  846         case MPS_INTPO_ACTHI:
  847                 *redir &= ~IOAPIC_REDLO_ACTLO;
  848                 break;
  849         case MPS_INTPO_ACTLO:
  850                 *redir |= IOAPIC_REDLO_ACTLO;
  851                 break;
  852         default:
panic("unknown MPS interrupt polarity %d", mpspo);
  854         }
  856         if (entry->int_type != MPS_INTTYPE_INT) {
mp_cfg_special_intr(entry, redir);
  858                 return;
  859         }
  860         *redir |= (IOAPIC_REDLO_DEL_LOPRI<<IOAPIC_REDLO_DEL_SHIFT);
  862         switch (mpstrig) {
  863         case MPS_INTTR_LEVEL:
  864                 *redir |= IOAPIC_REDLO_LEVEL;
  865                 break;
  866         case MPS_INTTR_EDGE:
  867                 *redir &= ~IOAPIC_REDLO_LEVEL;
  868                 break;
  869         case MPS_INTTR_DEF:
  870                 /*
  871                  * Set "default" setting based on ELCR value snagged
  872                  * earlier.
  873                  */
  874                 if (mp_busses[entry->src_bus_id].mb_data &
  875                     (1<<entry->src_bus_irq)) {
  876                         *redir |= IOAPIC_REDLO_LEVEL;
  877                 } else {
  878                         *redir &= ~IOAPIC_REDLO_LEVEL;
  879                 }
  880                 break;
  881         default:
panic("unknown MPS interrupt trigger %d", mpstrig);
  883         }
  884 }
  887 void
mp_cfg_isa_intr(const struct mpbios_int *entry, u_int32_t *redir)
  889 {
  890         int mpspo = entry->int_flags & 0x03; /* XXX magic */
  891         int mpstrig = (entry->int_flags >> 2) & 0x03; /* XXX magic */
  893         *redir &= ~IOAPIC_REDLO_DEL_MASK;
  894         switch (mpspo) {
  895         case MPS_INTPO_DEF:
  896         case MPS_INTPO_ACTHI:
  897                 *redir &= ~IOAPIC_REDLO_ACTLO;
  898                 break;
  899         case MPS_INTPO_ACTLO:
  900                 *redir |= IOAPIC_REDLO_ACTLO;
  901                 break;
  902         default:
panic("unknown MPS interrupt polarity %d", mpspo);
  904         }
  906         if (entry->int_type != MPS_INTTYPE_INT) {
mp_cfg_special_intr(entry, redir);
  908                 return;
  909         }
  910         *redir |= (IOAPIC_REDLO_DEL_LOPRI << IOAPIC_REDLO_DEL_SHIFT);
  912         switch (mpstrig) {
  913         case MPS_INTTR_LEVEL:
  914                 *redir |= IOAPIC_REDLO_LEVEL;
  915                 break;
  916         case MPS_INTTR_DEF:
  917         case MPS_INTTR_EDGE:
  918                 *redir &= ~IOAPIC_REDLO_LEVEL;
  919                 break;
  920         default:
panic("unknown MPS interrupt trigger %d", mpstrig);
  922         }
  923 }
  926 void
mp_print_special_intr(int intr)
  928 {
  929 }
  931 void
mp_print_pci_intr(int intr)
  933 {
printf(" device %d INT_%c", (intr >> 2) & 0x1f, 'A' + (intr & 0x3));
  935 }
  937 void
mp_print_isa_intr(int intr)
  939 {
printf(" irq %d", intr);
  941 }
  943 void
mp_print_eisa_intr(int intr)
  945 {
printf(" EISA irq %d", intr);
  947 }
  951 #define TAB_UNIT        4
  952 #define TAB_ROUND(a)    _TAB_ROUND(a, TAB_UNIT)
  954 #define _TAB_ROUND(a,u) (((a) + (u - 1)) & ~(u - 1))
  955 #define EXTEND_TAB(a,u) (!(_TAB_ROUND(a, u) == _TAB_ROUND((a + 1), u)))
  957 void
mpbios_bus(const u_int8_t *ent, struct device *self)
  959 {
  960         const struct mpbios_bus *entry = (const struct mpbios_bus *)ent;
  961         int bus_id = entry->bus_id;
printf("%s: bus %d is type %6.6s\n", self->dv_xname,
bus_id, entry->bus_type);
  966 #ifdef DIAGNOSTIC
  967         /*
  968          * This "should not happen" unless the table changes out
  969          * from underneath us
  970          */
  971         if (bus_id >= mp_nbus) {
panic("%s: bus number %d out of range?? (type %6.6s)",
self->dv_xname, bus_id, entry->bus_type);
  974         }
  975 #endif
mp_busses[bus_id].mb_intrs = NULL;
  979         if (memcmp(entry->bus_type, "PCI   ", 6) == 0) {
mp_busses[bus_id].mb_name = "pci";
mp_busses[bus_id].mb_idx = bus_id;
mp_busses[bus_id].mb_intr_print = mp_print_pci_intr;
mp_busses[bus_id].mb_intr_cfg = mp_cfg_pci_intr;
  984         } else if (memcmp(entry->bus_type, "EISA  ", 6) == 0) {
mp_busses[bus_id].mb_name = "eisa";
mp_busses[bus_id].mb_idx = bus_id;
mp_busses[bus_id].mb_intr_print = mp_print_eisa_intr;
mp_busses[bus_id].mb_intr_cfg = mp_cfg_eisa_intr;
mp_busses[bus_id].mb_data = inb(ELCR0) | (inb(ELCR1) << 8);
  992                 if (mp_eisa_bus)
printf("%s: multiple eisa busses?\n",
self->dv_xname);
  995                 else
mp_eisa_bus = &mp_busses[bus_id];
  997         } else if (memcmp(entry->bus_type, "ISA   ", 6) == 0) {
mp_busses[bus_id].mb_name = "isa";
mp_busses[bus_id].mb_idx = bus_id;
mp_busses[bus_id].mb_intr_print = mp_print_isa_intr;
mp_busses[bus_id].mb_intr_cfg = mp_cfg_isa_intr;
 1002                 if (mp_isa_bus)
printf("%s: multiple isa busses?\n",
self->dv_xname);
 1005                 else
mp_isa_bus = &mp_busses[bus_id];
 1007         } else {
printf("%s: unsupported bus type %6.6s\n", self->dv_xname,
entry->bus_type);
 1010         }
 1011 }
 1014 void
mpbios_ioapic(const u_int8_t *ent, struct device *self)
 1016 {
 1017         const struct mpbios_ioapic *entry = (const struct mpbios_ioapic *)ent;
 1018         struct apic_attach_args aaa;
 1020         /* XXX let flags checking happen in ioapic driver.. */
 1021         if (!(entry->apic_flags & IOAPICENTRY_FLAG_EN))
 1022                 return;
aaa.aaa_name = "ioapic";
aaa.apic_id = entry->apic_id;
aaa.apic_version = entry->apic_version;
aaa.apic_address = (u_int32_t)entry->apic_address;
aaa.apic_vecbase = -1;
aaa.flags = (mp_fps->mpfb2 & 0x80) ? IOAPIC_PICMODE : IOAPIC_VWIRE;
config_found_sm(self, &aaa, mp_print, mp_match);
 1032 }
 1034 int
mpbios_int(const u_int8_t *ent, struct mp_intr_map *mpi)
 1036 {
 1037         const struct mpbios_int *entry = (const struct mpbios_int *)ent;
 1038         struct mpbios_int rw_entry = *entry;
 1039         struct ioapic_softc *sc = NULL, *sc2;
 1041         struct mp_intr_map *altmpi;
 1042         struct mp_bus *mpb;
u_int32_t id = IOAPIC_REMAPPED_ID(entry->dst_apic_id);
u_int32_t pin = entry->dst_apic_int;
u_int32_t bus = entry->src_bus_id;
u_int32_t dev = entry->src_bus_irq;
u_int32_t type = entry->int_type;
u_int32_t flags = entry->int_flags;
rw_entry.dst_apic_id = id;
 1053         switch (type) {
 1054         case MPS_INTTYPE_INT:
mpb = &(mp_busses[bus]);
 1056                 break;
 1057         case MPS_INTTYPE_ExtINT:
mpb = &extint_bus;
 1059                 break;
 1060         case MPS_INTTYPE_SMI:
mpb = &smi_bus;
 1062                 break;
 1063         case MPS_INTTYPE_NMI:
mpb = &nmi_bus;
 1065                 break;
 1066         }
mpi->bus = mpb;
mpi->bus_pin = dev;
mpi->ioapic_ih = APIC_INT_VIA_APIC |
 1071             ((id << APIC_INT_APIC_SHIFT) | ((pin << APIC_INT_PIN_SHIFT)));
mpi->type = type;
mpi->flags = flags;
mpi->redir = 0;
 1076         if (mpb->mb_intr_cfg == NULL) {
printf("mpbios: can't find bus %d for apic %d pin %d\n",
bus, id, pin);
 1079                 return (1);
 1080         }
 1082         (*mpb->mb_intr_cfg)(&rw_entry, &mpi->redir);
 1084         if (entry->type == MPS_MCT_IOINT) {
sc = ioapic_find(id);
 1086                 if (sc == NULL) {
printf("mpbios: can't find ioapic %d\n", id);
 1088                         return (1);
 1089                 }
 1091                 /*
 1092                  * XXX workaround for broken BIOSs that put the ACPI
 1093                  * global interrupt number in the entry, not the pin
 1094                  * number.
 1095                  */
 1096                 if (pin >= sc->sc_apic_sz) {
sc2 = ioapic_find_bybase(pin);
 1098                         if (sc2 != sc) {
printf("mpbios: bad pin %d for apic %d\n",
pin, id);
 1101                                 return (1);
 1102                         }
printf("mpbios: WARNING: pin %d for apic %d too high; "
 1104                                "assuming ACPI global int value\n", pin, id);
pin -= sc->sc_apic_vecbase;
 1106                 }
mpi->ioapic = sc;
mpi->ioapic_pin = pin;
altmpi = sc->sc_pins[pin].ip_map;
 1113                 if (altmpi != NULL) {
 1114                         if ((altmpi->type != type) ||
 1115                             (altmpi->flags != flags)) {
printf(
 1117                                     "%s: conflicting map entries for pin %d\n",
sc->sc_dev.dv_xname, pin);
 1119                         }
 1120                 } else {
sc->sc_pins[pin].ip_map = mpi;
 1122                 }
 1123         } else {
 1124                 if (pin >= 2)
printf("pin %d of local apic doesn't exist!\n", pin);
 1126                 else {
mpi->ioapic = NULL;
mpi->ioapic_pin = pin;
mpi->cpu_id = id;
 1130                 }
 1131         }
 1133         if (mp_verbose) {
printf("%s: int%d attached to %s",
sc ? sc->sc_dev.dv_xname : "local apic", pin,
mpb->mb_name);
 1137                 if (mpb->mb_idx != -1)
printf("%d", mpb->mb_idx);
 1140                 (*(mpb->mb_intr_print))(dev);
printf(" (type 0x%x flags 0x%x)\n", type, flags);
 1143         }
mpi->next = mpb->mb_intrs;
mpb->mb_intrs = mpi;
 1148         return (0);
 1149 }