tools/tools/ncpus/acpi.c

   1 /*-
   2  * Copyright (c) 1998 Doug Rabson
   3  * Copyright (c) 2000 Mitsuru IWASAKI <iwasaki@FreeBSD.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  *      $FreeBSD$
  28  */
  29
  30 #include <sys/param.h>
  31 #include <sys/endian.h>
  32 #include <sys/mman.h>
  33 #include <sys/queue.h>
  34 #include <sys/stat.h>
  35 #include <sys/sysctl.h>
  36 #include <sys/wait.h>
  37 #include <assert.h>
  38 #include <err.h>
  39 #include <fcntl.h>
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <unistd.h>
  44 #include <paths.h>
  45 #include <devinfo.h>
  46
  47 #include "acpidump.h"
  48
  49 static void     acpi_handle_apic(struct ACPIsdt *sdp);
  50 static struct ACPIsdt *acpi_map_sdt(vm_offset_t pa);
  51 static void     acpi_handle_rsdt(struct ACPIsdt *rsdp);
  52 static struct acpi_user_mapping *acpi_user_find_mapping(vm_offset_t, size_t);
  53 static void *   acpi_map_physical(vm_offset_t, size_t);
  54
  55 /* Size of an address. 32-bit for ACPI 1.0, 64-bit for ACPI 2.0 and up. */
  56 static int addr_size;
  57
  58 static int ncpu;
  59
  60 int acpi_detect(void);
  61
  62 static void
  63 acpi_handle_apic(struct ACPIsdt *sdp)
  64 {
  65         struct MADTbody *madtp;
  66         struct MADT_APIC *mp;
  67         struct MADT_local_apic *apic;
  68         struct MADT_local_sapic *sapic;
  69
  70         madtp = (struct MADTbody *) sdp->body;
  71         mp = (struct MADT_APIC *)madtp->body;
  72         while (((uintptr_t)mp) - ((uintptr_t)sdp) < sdp->len) {
  73                 switch (mp->type) {
  74                 case ACPI_MADT_APIC_TYPE_LOCAL_APIC:
  75                         apic = &mp->body.local_apic;
  76                         warnx("MADT: Found CPU APIC ID %d %s",
  77                             apic->cpu_id,
  78                             apic->flags & ACPI_MADT_APIC_LOCAL_FLAG_ENABLED ?
  79                                 "enabled" : "disabled");
  80                         if (apic->flags & ACPI_MADT_APIC_LOCAL_FLAG_ENABLED)
  81                                 ncpu++;
  82                         break;
  83                 case ACPI_MADT_APIC_TYPE_LOCAL_SAPIC:
  84                         sapic = &mp->body.local_sapic;
  85                         warnx("MADT: Found CPU SAPIC ID %d %s",
  86                             sapic->cpu_id,
  87                             sapic->flags & ACPI_MADT_APIC_LOCAL_FLAG_ENABLED ?
  88                                 "enabled" : "disabled");
  89                         /* XXX is enable flag the same? */
  90                         if (sapic->flags & ACPI_MADT_APIC_LOCAL_FLAG_ENABLED)
  91                                 ncpu++;
  92                         break;
  93                 default:
  94                         break;
  95                 }
  96                 mp = (struct MADT_APIC *) ((char *)mp + mp->len);
  97         }
  98 }
  99
 100 static int
 101 acpi_checksum(void *p, size_t length)
 102 {
 103         u_int8_t *bp;
 104         u_int8_t sum;
 105
 106         bp = p;
 107         sum = 0;
 108         while (length--)
 109                 sum += *bp++;
 110
 111         return (sum);
 112 }
 113
 114 static struct ACPIsdt *
 115 acpi_map_sdt(vm_offset_t pa)
 116 {
 117         struct  ACPIsdt *sp;
 118
 119         sp = acpi_map_physical(pa, sizeof(struct ACPIsdt));
 120         sp = acpi_map_physical(pa, sp->len);
 121         return (sp);
 122 }
 123
 124 static void
 125 acpi_handle_rsdt(struct ACPIsdt *rsdp)
 126 {
 127         struct ACPIsdt *sdp;
 128         vm_offset_t addr;
 129         int entries, i;
 130
 131         entries = (rsdp->len - SIZEOF_SDT_HDR) / addr_size;
 132         for (i = 0; i < entries; i++) {
 133                 switch (addr_size) {
 134                 case 4:
 135                         addr = le32dec((char*)rsdp->body + i * addr_size);
 136                         break;
 137                 case 8:
 138                         addr = le64dec((char*)rsdp->body + i * addr_size);
 139                         break;
 140                 default:
 141                         assert((addr = 0));
 142                 }
 143
 144                 sdp = (struct ACPIsdt *)acpi_map_sdt(addr);
 145                 if (acpi_checksum(sdp, sdp->len)) {
 146 #if 0
 147                         warnx("RSDT entry %d (sig %.4s) has bad checksum", i,
 148                             sdp->signature);
 149 #endif
 150                         continue;
 151                 }
 152                 if (!memcmp(sdp->signature, "APIC", 4))
 153                         acpi_handle_apic(sdp);
 154         }
 155 }
 156
 157 static char     machdep_acpi_root[] = "machdep.acpi_root";
 158 static int      acpi_mem_fd = -1;
 159
 160 struct acpi_user_mapping {
 161         LIST_ENTRY(acpi_user_mapping) link;
 162         vm_offset_t     pa;
 163         caddr_t         va;
 164         size_t          size;
 165 };
 166
 167 LIST_HEAD(acpi_user_mapping_list, acpi_user_mapping) maplist;
 168
 169 static void
 170 acpi_user_init(void)
 171 {
 172
 173         if (acpi_mem_fd == -1) {
 174                 acpi_mem_fd = open(_PATH_MEM, O_RDONLY);
 175                 if (acpi_mem_fd == -1)
 176                         err(1, "opening " _PATH_MEM);
 177                 LIST_INIT(&maplist);
 178         }
 179 }
 180
 181 static struct acpi_user_mapping *
 182 acpi_user_find_mapping(vm_offset_t pa, size_t size)
 183 {
 184         struct  acpi_user_mapping *map;
 185
 186         /* First search for an existing mapping */
 187         for (map = LIST_FIRST(&maplist); map; map = LIST_NEXT(map, link)) {
 188                 if (map->pa <= pa && map->size >= pa + size - map->pa)
 189                         return (map);
 190         }
 191
 192         /* Then create a new one */
 193         size = round_page(pa + size) - trunc_page(pa);
 194         pa = trunc_page(pa);
 195         map = malloc(sizeof(struct acpi_user_mapping));
 196         if (!map)
 197                 errx(1, "out of memory");
 198         map->pa = pa;
 199         map->va = mmap(0, size, PROT_READ, MAP_SHARED, acpi_mem_fd, pa);
 200         map->size = size;
 201         if ((intptr_t) map->va == -1)
 202                 err(1, "can't map address");
 203         LIST_INSERT_HEAD(&maplist, map, link);
 204
 205         return (map);
 206 }
 207
 208 static void *
 209 acpi_map_physical(vm_offset_t pa, size_t size)
 210 {
 211         struct  acpi_user_mapping *map;
 212
 213         map = acpi_user_find_mapping(pa, size);
 214         return (map->va + (pa - map->pa));
 215 }
 216
 217 static struct ACPIrsdp *
 218 acpi_get_rsdp(u_long addr)
 219 {
 220         struct ACPIrsdp rsdp;
 221         size_t len;
 222
 223         /* Read in the table signature and check it. */
 224         pread(acpi_mem_fd, &rsdp, 8, addr);
 225         if (memcmp(rsdp.signature, "RSD PTR ", 8))
 226                 return (NULL);
 227
 228         /* Read the entire table. */
 229         pread(acpi_mem_fd, &rsdp, sizeof(rsdp), addr);
 230
 231         /* Run the checksum only over the version 1 header. */
 232         if (acpi_checksum(&rsdp, 20))
 233                 return (NULL);
 234
 235         /* If the revision is 0, assume a version 1 length. */
 236         if (rsdp.revision == 0)
 237                 len = 20;
 238         else
 239                 len = rsdp.length;
 240
 241         /* XXX Should handle ACPI 2.0 RSDP extended checksum here. */
 242
 243         return (acpi_map_physical(addr, len));
 244 }
 245
 246 static const char *
 247 devstate(devinfo_state_t state)
 248 {
 249         switch (state) {
 250         case DS_NOTPRESENT:
 251                 return "not-present";
 252         case DS_ALIVE:
 253                 return "alive";
 254         case DS_ATTACHED:
 255                 return "attached";
 256         case DS_BUSY:
 257                 return "busy";
 258         default:
 259                 return "unknown-state";
 260         }
 261 }
 262
 263 static int
 264 acpi0_check(struct devinfo_dev *dd, void *arg)
 265 {
 266         printf("%s: %s %s\n", __func__, dd->dd_name, devstate(dd->dd_state));
 267         /* NB: device must be present AND attached */
 268         if (strcmp(dd->dd_name, "acpi0") == 0)
 269                 return (dd->dd_state == DS_ATTACHED ||
 270                         dd->dd_state == DS_BUSY);
 271         return devinfo_foreach_device_child(dd, acpi0_check, arg);
 272 }
 273
 274 static int
 275 acpi0_present(void)
 276 {
 277         struct devinfo_dev *root;
 278         int found;
 279
 280         found = 0;
 281         devinfo_init();
 282         root = devinfo_handle_to_device(DEVINFO_ROOT_DEVICE);
 283         if (root != NULL)
 284                 found = devinfo_foreach_device_child(root, acpi0_check, NULL);
 285         devinfo_free();
 286         return found;
 287 }
 288
 289 int
 290 acpi_detect(void)
 291 {
 292         struct ACPIrsdp *rp;
 293         struct ACPIsdt *rsdp;
 294         u_long addr;
 295         size_t len;
 296
 297         if (!acpi0_present()) {
 298                 warnx("no acpi0 device located");
 299                 return -1;
 300         }
 301
 302         acpi_user_init();
 303
 304         /* Attempt to use sysctl to find RSD PTR record. */
 305         len = sizeof(addr);
 306         if (sysctlbyname(machdep_acpi_root, &addr, &len, NULL, 0) != 0) {
 307                 warnx("cannot find ACPI information");
 308                 return -1;
 309         }
 310         rp = acpi_get_rsdp(addr);
 311         if (rp == NULL) {
 312                 warnx("cannot find ACPI information: sysctl %s does not point to RSDP",
 313                         machdep_acpi_root);
 314                 return -1;
 315         }
 316         if (rp->revision < 2) {
 317                 rsdp = (struct ACPIsdt *)acpi_map_sdt(rp->rsdt_addr);
 318                 if (memcmp(rsdp->signature, "RSDT", 4) != 0 ||
 319                     acpi_checksum(rsdp, rsdp->len) != 0)
 320                         errx(1, "RSDT is corrupted");
 321                 addr_size = sizeof(uint32_t);
 322         } else {
 323                 rsdp = (struct ACPIsdt *)acpi_map_sdt(rp->xsdt_addr);
 324                 if (memcmp(rsdp->signature, "XSDT", 4) != 0 ||
 325                     acpi_checksum(rsdp, rsdp->len) != 0)
 326                         errx(1, "XSDT is corrupted");
 327                 addr_size = sizeof(uint64_t);
 328         }
 329         ncpu = 0;
 330         acpi_handle_rsdt(rsdp);
 331         return (ncpu == 0 ? 1 : ncpu);
 332 }