sys/arm64/acpica/acpi_machdep.c

   1 /*-
   2  * Copyright (c) 2001 Mitsuru IWASAKI
   3  * Copyright (c) 2015 The FreeBSD Foundation
   4  * All rights reserved.
   5  *
   6  * This software was developed by Andrew Turner under
   7  * sponsorship from the FreeBSD Foundation.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <sys/param.h>
  35 #include <sys/bus.h>
  36 #include <sys/kernel.h>
  37
  38 #include <vm/vm.h>
  39 #include <vm/pmap.h>
  40
  41 #include <machine/machdep.h>
  42
  43 #include <contrib/dev/acpica/include/acpi.h>
  44 #include <contrib/dev/acpica/include/accommon.h>
  45 #include <contrib/dev/acpica/include/actables.h>
  46
  47 #include <dev/acpica/acpivar.h>
  48
  49 extern struct bus_space memmap_bus;
  50
  51 int
  52 acpi_machdep_init(device_t dev)
  53 {
  54
  55         return (0);
  56 }
  57
  58 int
  59 acpi_machdep_quirks(int *quirks)
  60 {
  61
  62         return (0);
  63 }
  64
  65 static void *
  66 map_table(vm_paddr_t pa, const char *sig)
  67 {
  68         ACPI_TABLE_HEADER *header;
  69         vm_size_t length;
  70         void *table;
  71
  72         header = pmap_mapbios(pa, sizeof(ACPI_TABLE_HEADER));
  73         if (strncmp(header->Signature, sig, ACPI_NAMESEG_SIZE) != 0) {
  74                 pmap_unmapbios((vm_offset_t)header, sizeof(ACPI_TABLE_HEADER));
  75                 return (NULL);
  76         }
  77         length = header->Length;
  78         pmap_unmapbios((vm_offset_t)header, sizeof(ACPI_TABLE_HEADER));
  79
  80         table = pmap_mapbios(pa, length);
  81         if (ACPI_FAILURE(AcpiTbChecksum(table, length))) {
  82                 if (bootverbose)
  83                         printf("ACPI: Failed checksum for table %s\n", sig);
  84 #if (ACPI_CHECKSUM_ABORT)
  85                 pmap_unmapbios(table, length);
  86                 return (NULL);
  87 #endif
  88         }
  89         return (table);
  90 }
  91
  92 /*
  93  * See if a given ACPI table is the requested table.  Returns the
  94  * length of the table if it matches or zero on failure.
  95  */
  96 static int
  97 probe_table(vm_paddr_t address, const char *sig)
  98 {
  99         ACPI_TABLE_HEADER *table;
 100
 101         table = pmap_mapbios(address, sizeof(ACPI_TABLE_HEADER));
 102         if (table == NULL) {
 103                 if (bootverbose)
 104                         printf("ACPI: Failed to map table at 0x%jx\n",
 105                             (uintmax_t)address);
 106                 return (0);
 107         }
 108
 109         if (strncmp(table->Signature, sig, ACPI_NAMESEG_SIZE) != 0) {
 110                 pmap_unmapbios((vm_offset_t)table, sizeof(ACPI_TABLE_HEADER));
 111                 return (0);
 112         }
 113         pmap_unmapbios((vm_offset_t)table, sizeof(ACPI_TABLE_HEADER));
 114         return (1);
 115 }
 116
 117 /* Unmap a table previously mapped via acpi_map_table(). */
 118 void
 119 acpi_unmap_table(void *table)
 120 {
 121         ACPI_TABLE_HEADER *header;
 122
 123         header = (ACPI_TABLE_HEADER *)table;
 124         pmap_unmapbios((vm_offset_t)table, header->Length);
 125 }
 126
 127 /*
 128  * Try to map a table at a given physical address previously returned
 129  * by acpi_find_table().
 130  */
 131 void *
 132 acpi_map_table(vm_paddr_t pa, const char *sig)
 133 {
 134
 135         return (map_table(pa, sig));
 136 }
 137
 138 /*
 139  * Return the physical address of the requested table or zero if one
 140  * is not found.
 141  */
 142 vm_paddr_t
 143 acpi_find_table(const char *sig)
 144 {
 145         ACPI_PHYSICAL_ADDRESS rsdp_ptr;
 146         ACPI_TABLE_RSDP *rsdp;
 147         ACPI_TABLE_XSDT *xsdt;
 148         ACPI_TABLE_HEADER *table;
 149         vm_paddr_t addr;
 150         int i, count;
 151
 152         if (resource_disabled("acpi", 0))
 153                 return (0);
 154
 155         /*
 156          * Map in the RSDP.  Since ACPI uses AcpiOsMapMemory() which in turn
 157          * calls pmap_mapbios() to find the RSDP, we assume that we can use
 158          * pmap_mapbios() to map the RSDP.
 159          */
 160         if ((rsdp_ptr = AcpiOsGetRootPointer()) == 0)
 161                 return (0);
 162         rsdp = pmap_mapbios(rsdp_ptr, sizeof(ACPI_TABLE_RSDP));
 163         if (rsdp == NULL) {
 164                 printf("ACPI: Failed to map RSDP\n");
 165                 return (0);
 166         }
 167
 168         addr = 0;
 169         if (rsdp->Revision >= 2 && rsdp->XsdtPhysicalAddress != 0) {
 170                 /*
 171                  * AcpiOsGetRootPointer only verifies the checksum for
 172                  * the version 1.0 portion of the RSDP.  Version 2.0 has
 173                  * an additional checksum that we verify first.
 174                  */
 175                 if (AcpiTbChecksum((UINT8 *)rsdp, ACPI_RSDP_XCHECKSUM_LENGTH)) {
 176                         printf("ACPI: RSDP failed extended checksum\n");
 177                         pmap_unmapbios((vm_offset_t)rsdp,
 178                             sizeof(ACPI_TABLE_RSDP));
 179                         return (0);
 180                 }
 181                 xsdt = map_table(rsdp->XsdtPhysicalAddress, ACPI_SIG_XSDT);
 182                 if (xsdt == NULL) {
 183                         printf("ACPI: Failed to map XSDT\n");
 184                         pmap_unmapbios((vm_offset_t)rsdp,
 185                             sizeof(ACPI_TABLE_RSDP));
 186                         return (0);
 187                 }
 188                 count = (xsdt->Header.Length - sizeof(ACPI_TABLE_HEADER)) /
 189                     sizeof(UINT64);
 190                 for (i = 0; i < count; i++)
 191                         if (probe_table(xsdt->TableOffsetEntry[i], sig)) {
 192                                 addr = xsdt->TableOffsetEntry[i];
 193                                 break;
 194                         }
 195                 acpi_unmap_table(xsdt);
 196         } else {
 197                 printf("ACPI: Unsupported RSDP version %d and XSDT %#lx\n",
 198                     rsdp->Revision, rsdp->XsdtPhysicalAddress);
 199         }
 200         pmap_unmapbios((vm_offset_t)rsdp, sizeof(ACPI_TABLE_RSDP));
 201
 202         if (addr == 0)
 203                 return (0);
 204
 205         /*
 206          * Verify that we can map the full table and that its checksum is
 207          * correct, etc.
 208          */
 209         table = map_table(addr, sig);
 210         if (table == NULL)
 211                 return (0);
 212         acpi_unmap_table(table);
 213
 214         return (addr);
 215 }
 216
 217 int
 218 acpi_map_addr(struct acpi_generic_address *addr, bus_space_tag_t *tag,
 219     bus_space_handle_t *handle, bus_size_t size)
 220 {
 221         bus_addr_t phys;
 222
 223         /* Check if the device is Memory mapped */
 224         if (addr->SpaceId != 0)
 225                 return (ENXIO);
 226
 227         phys = addr->Address;
 228         *tag = &memmap_bus;
 229
 230         return (bus_space_map(*tag, phys, size, 0, handle));
 231 }
 232
 233 #if MAXMEMDOM > 1
 234 static void
 235 parse_pxm_tables(void *dummy)
 236 {
 237         uint64_t mmfr0, parange;
 238
 239         /* Only parse ACPI tables when booting via ACPI */
 240         if (arm64_bus_method != ARM64_BUS_ACPI)
 241                 return;
 242
 243         if (!get_kernel_reg(ID_AA64MMFR0_EL1, &mmfr0)) {
 244                 /* chosen arbitrarily */
 245                 mmfr0 = ID_AA64MMFR0_PARange_1T;
 246         }
 247
 248         switch (ID_AA64MMFR0_PARange_VAL(mmfr0)) {
 249         case ID_AA64MMFR0_PARange_4G:
 250                 parange = (vm_paddr_t)4 << 30 /* GiB */;
 251                 break;
 252         case ID_AA64MMFR0_PARange_64G:
 253                 parange = (vm_paddr_t)64 << 30 /* GiB */;
 254                 break;
 255         case ID_AA64MMFR0_PARange_1T:
 256                 parange = (vm_paddr_t)1 << 40 /* TiB */;
 257                 break;
 258         case ID_AA64MMFR0_PARange_4T:
 259                 parange = (vm_paddr_t)4 << 40 /* TiB */;
 260                 break;
 261         case ID_AA64MMFR0_PARange_16T:
 262                 parange = (vm_paddr_t)16 << 40 /* TiB */;
 263                 break;
 264         case ID_AA64MMFR0_PARange_256T:
 265                 parange = (vm_paddr_t)256 << 40 /* TiB */;
 266                 break;
 267         case ID_AA64MMFR0_PARange_4P:
 268                 parange = (vm_paddr_t)4 << 50 /* PiB */;
 269                 break;
 270         default:
 271                 /* chosen arbitrarily */
 272                 parange = (vm_paddr_t)1 << 40 /* TiB */;
 273                 printf("Unknown value for PARange in mmfr0 (%#lx)\n", mmfr0);
 274                 break;
 275         }
 276
 277         acpi_pxm_init(MAXCPU, parange);
 278         acpi_pxm_parse_tables();
 279         acpi_pxm_set_mem_locality();
 280 }
 281 SYSINIT(parse_pxm_tables, SI_SUB_VM - 1, SI_ORDER_FIRST, parse_pxm_tables,
 282     NULL);
 283 #endif