1 /* $NetBSD: acpi_machdep.c,v 1.19 2020/01/21 11:24:47 jmcneill Exp $ */ 2 3 /*- 4 * Copyright (c) 2018 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jared McNeill <jmcneill@invisible.ca>. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include "pci.h" 33 34 #include <sys/cdefs.h> 35 __KERNEL_RCSID(0, "$NetBSD: acpi_machdep.c,v 1.19 2020/01/21 11:24:47 jmcneill Exp $"); 36 37 #include <sys/param.h> 38 #include <sys/systm.h> 39 #include <sys/bus.h> 40 #include <sys/cpu.h> 41 #include <sys/device.h> 42 #include <sys/kmem.h> 43 44 #include <uvm/uvm_extern.h> 45 46 #include <dev/fdt/fdtvar.h> 47 48 #include <dev/acpi/acpica.h> 49 #include <dev/acpi/acpivar.h> 50 #if NPCI > 0 51 #include <dev/acpi/acpi_mcfg.h> 52 #endif 53 54 #include <arm/arm/efi_runtime.h> 55 56 #include <arm/pic/picvar.h> 57 58 #include <arm/locore.h> 59 60 #include <machine/acpi_machdep.h> 61 62 extern struct bus_space arm_generic_bs_tag; 63 extern struct arm32_bus_dma_tag acpi_coherent_dma_tag; 64 extern struct arm32_bus_dma_tag arm_generic_dma_tag; 65 66 bus_dma_tag_t arm_acpi_dma32_tag(struct acpi_softc *, struct acpi_devnode *); 67 bus_dma_tag_t arm_acpi_dma64_tag(struct acpi_softc *, struct acpi_devnode *); 68 69 static int 70 acpi_md_pmapflags(paddr_t pa) 71 { 72 int len; 73 74 const int chosen = OF_finddevice("/chosen"); 75 if (chosen == -1) 76 return 0; 77 78 const uint32_t *map = fdtbus_get_prop(chosen, "netbsd,uefi-memmap", &len); 79 if (map == NULL) 80 return 0; 81 82 while (len >= 28) { 83 const uint32_t type = be32dec(&map[0]); 84 const uint64_t phys_start = be64dec(&map[1]); 85 const uint64_t num_pages = be64dec(&map[3]); 86 const uint64_t attr = be64dec(&map[5]); 87 88 if (pa >= phys_start && pa < phys_start + (num_pages * EFI_PAGE_SIZE)) { 89 switch (type) { 90 case EFI_MD_TYPE_RECLAIM: 91 /* ACPI table memory */ 92 return PMAP_WRITE_BACK; 93 94 case EFI_MD_TYPE_IOMEM: 95 case EFI_MD_TYPE_IOPORT: 96 return PMAP_DEV; 97 98 default: 99 if ((attr & EFI_MD_ATTR_WB) != 0) 100 return PMAP_WRITE_BACK; 101 else if ((attr & EFI_MD_ATTR_WC) != 0) 102 return PMAP_WRITE_COMBINE; 103 else if ((attr & EFI_MD_ATTR_WT) != 0) 104 return 0; /* XXX */ 105 106 return PMAP_DEV; 107 } 108 } 109 110 map += 7; 111 len -= 28; 112 } 113 114 /* Not found; assume device memory */ 115 return PMAP_DEV; 116 } 117 118 ACPI_STATUS 119 acpi_md_OsInitialize(void) 120 { 121 return AE_OK; 122 } 123 124 ACPI_PHYSICAL_ADDRESS 125 acpi_md_OsGetRootPointer(void) 126 { 127 uint64_t pa; 128 129 const int chosen = OF_finddevice("/chosen"); 130 if (chosen == -1) 131 return 0; 132 133 if (of_getprop_uint64(chosen, "netbsd,acpi-root-table", &pa) != 0) 134 return 0; 135 136 return (ACPI_PHYSICAL_ADDRESS)pa; 137 } 138 139 ACPI_STATUS 140 acpi_md_OsInstallInterruptHandler(UINT32 irq, ACPI_OSD_HANDLER handler, void *context, 141 void **cookiep, const char *xname) 142 { 143 return AE_NOT_IMPLEMENTED; 144 } 145 146 void 147 acpi_md_OsRemoveInterruptHandler(void *cookie) 148 { 149 intr_disestablish(cookie); 150 } 151 152 ACPI_STATUS 153 acpi_md_OsMapMemory(ACPI_PHYSICAL_ADDRESS pa, UINT32 size, void **vap) 154 { 155 paddr_t spa, epa, curpa; 156 vaddr_t va, curva; 157 158 spa = trunc_page(pa); 159 epa = round_page(pa + size); 160 161 va = uvm_km_alloc(kernel_map, epa - spa, 0, UVM_KMF_VAONLY); 162 if (va == 0) 163 return AE_NO_MEMORY; 164 165 const int pmapflags = acpi_md_pmapflags(spa); 166 167 aprint_debug("%s: 0x%lx 0x%x flags = %#x\n", __func__, pa, size, pmapflags); 168 169 for (curpa = spa, curva = va; curpa < epa; curpa += PAGE_SIZE, curva += PAGE_SIZE) 170 pmap_kenter_pa(curva, curpa, VM_PROT_READ | VM_PROT_WRITE, pmapflags); 171 pmap_update(pmap_kernel()); 172 173 *vap = (void *)(va + (pa - spa)); 174 175 return AE_OK; 176 } 177 178 void 179 acpi_md_OsUnmapMemory(void *va, UINT32 size) 180 { 181 vaddr_t ova; 182 vsize_t osz; 183 184 ova = trunc_page((vaddr_t)va); 185 osz = round_page((vaddr_t)va + size) - ova; 186 187 pmap_kremove(ova, osz); 188 pmap_update(pmap_kernel()); 189 uvm_km_free(kernel_map, ova, osz, UVM_KMF_VAONLY); 190 } 191 192 ACPI_STATUS 193 acpi_md_OsGetPhysicalAddress(void *va, ACPI_PHYSICAL_ADDRESS *pap) 194 { 195 paddr_t pa; 196 197 if (!pmap_extract(pmap_kernel(), (vaddr_t)va, &pa)) 198 return AE_ERROR; 199 200 *pap = pa; 201 202 return AE_OK; 203 } 204 205 BOOLEAN 206 acpi_md_OsReadable(void *va, UINT32 len) 207 { 208 vaddr_t sva, eva; 209 pt_entry_t *pte; 210 211 sva = trunc_page((vaddr_t)va); 212 eva = round_page((vaddr_t)va + len); 213 214 if (sva < VM_MIN_KERNEL_ADDRESS) 215 return FALSE; 216 217 for (; sva < eva; sva += PAGE_SIZE) { 218 pte = kvtopte(sva); 219 if ((*pte & (LX_BLKPAG_AF|LX_BLKPAG_AP)) != (LX_BLKPAG_AF|LX_BLKPAG_AP_RO)) 220 return FALSE; 221 } 222 223 return TRUE; 224 } 225 226 BOOLEAN 227 acpi_md_OsWritable(void *va, UINT32 len) 228 { 229 vaddr_t sva, eva; 230 pt_entry_t *pte; 231 232 sva = trunc_page((vaddr_t)va); 233 eva = round_page((vaddr_t)va + len); 234 235 if (sva < VM_MIN_KERNEL_ADDRESS) 236 return FALSE; 237 238 for (; sva < eva; sva += PAGE_SIZE) { 239 pte = kvtopte(sva); 240 if ((*pte & (LX_BLKPAG_AF|LX_BLKPAG_AP)) != (LX_BLKPAG_AF|LX_BLKPAG_AP_RW)) 241 return FALSE; 242 } 243 244 return TRUE; 245 } 246 247 void 248 acpi_md_OsEnableInterrupt(void) 249 { 250 cpsie(I32_bit); 251 } 252 253 void 254 acpi_md_OsDisableInterrupt(void) 255 { 256 cpsid(I32_bit); 257 } 258 259 void * 260 acpi_md_intr_establish(uint32_t irq, int ipl, int type, int (*handler)(void *), void *arg, bool mpsafe, const char *xname) 261 { 262 return intr_establish_xname(irq, ipl, type | (mpsafe ? IST_MPSAFE : 0), handler, arg, xname); 263 } 264 265 void 266 acpi_md_intr_mask(void *ih) 267 { 268 intr_mask(ih); 269 } 270 271 void 272 acpi_md_intr_unmask(void *ih) 273 { 274 intr_unmask(ih); 275 } 276 277 void 278 acpi_md_intr_disestablish(void *ih) 279 { 280 intr_disestablish(ih); 281 } 282 283 int 284 acpi_md_sleep(int state) 285 { 286 printf("ERROR: ACPI sleep not implemented on this platform\n"); 287 return -1; 288 } 289 290 uint32_t 291 acpi_md_pdc(void) 292 { 293 return 0; 294 } 295 296 uint32_t 297 acpi_md_ncpus(void) 298 { 299 return kcpuset_countset(kcpuset_attached); 300 } 301 302 static ACPI_STATUS 303 acpi_md_madt_probe_cpu(ACPI_SUBTABLE_HEADER *hdrp, void *aux) 304 { 305 struct acpi_softc * const sc = aux; 306 307 if (hdrp->Type == ACPI_MADT_TYPE_GENERIC_INTERRUPT) 308 config_found_ia(sc->sc_dev, "acpimadtbus", hdrp, NULL); 309 310 return AE_OK; 311 } 312 313 static ACPI_STATUS 314 acpi_md_madt_probe_gic(ACPI_SUBTABLE_HEADER *hdrp, void *aux) 315 { 316 struct acpi_softc * const sc = aux; 317 318 if (hdrp->Type == ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR) 319 config_found_ia(sc->sc_dev, "acpimadtbus", hdrp, NULL); 320 321 return AE_OK; 322 } 323 324 static ACPI_STATUS 325 acpi_md_gtdt_probe(ACPI_GTDT_HEADER *hdrp, void *aux) 326 { 327 struct acpi_softc * const sc = aux; 328 329 config_found_ia(sc->sc_dev, "acpigtdtbus", hdrp, NULL); 330 331 return AE_OK; 332 } 333 334 #if NPCI > 0 335 static struct bus_space acpi_md_mcfg_bs_tag; 336 337 static int 338 acpi_md_mcfg_bs_map(void *t, bus_addr_t bpa, bus_size_t size, int flag, 339 bus_space_handle_t *bshp) 340 { 341 return arm_generic_bs_tag.bs_map(t, bpa, size, 342 flag | _ARM_BUS_SPACE_MAP_STRONGLY_ORDERED, bshp); 343 } 344 #endif 345 346 void 347 acpi_md_callback(struct acpi_softc *sc) 348 { 349 ACPI_TABLE_HEADER *hdrp; 350 351 #if NPCI > 0 352 acpi_md_mcfg_bs_tag = arm_generic_bs_tag; 353 acpi_md_mcfg_bs_tag.bs_map = acpi_md_mcfg_bs_map; 354 acpimcfg_init(&acpi_md_mcfg_bs_tag, NULL); 355 #endif 356 357 if (acpi_madt_map() != AE_OK) 358 panic("Failed to map MADT"); 359 acpi_madt_walk(acpi_md_madt_probe_cpu, sc); 360 acpi_madt_walk(acpi_md_madt_probe_gic, sc); 361 acpi_madt_unmap(); 362 363 if (acpi_gtdt_map() != AE_OK) 364 panic("Failed to map GTDT"); 365 acpi_gtdt_walk(acpi_md_gtdt_probe, sc); 366 acpi_gtdt_unmap(); 367 368 if (ACPI_SUCCESS(AcpiGetTable(ACPI_SIG_GTDT, 0, &hdrp))) 369 config_found_ia(sc->sc_dev, "acpisdtbus", hdrp, NULL); 370 } 371 372 static const char * const module_hid[] = { 373 "ACPI0004", /* Module device */ 374 NULL 375 }; 376 377 static ACPI_HANDLE 378 arm_acpi_dma_module(struct acpi_softc *sc, struct acpi_devnode *ad) 379 { 380 ACPI_HANDLE tmp; 381 ACPI_STATUS rv; 382 383 /* 384 * Search up the tree for a module device with a _DMA method. 385 */ 386 for (; ad != NULL; ad = ad->ad_parent) { 387 if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE) 388 continue; 389 if (!acpi_match_hid(ad->ad_devinfo, module_hid)) 390 continue; 391 rv = AcpiGetHandle(ad->ad_handle, "_DMA", &tmp); 392 if (ACPI_SUCCESS(rv)) 393 return ad->ad_handle; 394 } 395 396 return NULL; 397 } 398 399 static void 400 arm_acpi_dma_init_ranges(struct acpi_softc *sc, struct acpi_devnode *ad, 401 struct arm32_bus_dma_tag *dmat, uint32_t flags) 402 { 403 struct acpi_resources res; 404 struct acpi_mem *mem; 405 ACPI_HANDLE module; 406 ACPI_STATUS rv; 407 int n; 408 409 module = arm_acpi_dma_module(sc, ad->ad_parent); 410 if (module == NULL) { 411 default_tag: 412 /* No translation required */ 413 dmat->_nranges = 1; 414 dmat->_ranges = kmem_zalloc(sizeof(*dmat->_ranges), KM_SLEEP); 415 dmat->_ranges[0].dr_sysbase = 0; 416 dmat->_ranges[0].dr_busbase = 0; 417 dmat->_ranges[0].dr_len = UINTPTR_MAX; 418 dmat->_ranges[0].dr_flags = flags; 419 return; 420 } 421 422 rv = acpi_resource_parse(sc->sc_dev, module, "_DMA", &res, 423 &acpi_resource_parse_ops_quiet); 424 if (ACPI_FAILURE(rv)) { 425 aprint_error_dev(sc->sc_dev, 426 "failed to parse _DMA on %s: %s\n", 427 acpi_name(module), AcpiFormatException(rv)); 428 goto default_tag; 429 } 430 if (res.ar_nmem == 0) { 431 acpi_resource_cleanup(&res); 432 goto default_tag; 433 } 434 435 dmat->_nranges = res.ar_nmem; 436 dmat->_ranges = kmem_zalloc(sizeof(*dmat->_ranges) * res.ar_nmem, 437 KM_SLEEP); 438 439 for (n = 0; n < res.ar_nmem; n++) { 440 mem = acpi_res_mem(&res, n); 441 dmat->_ranges[n].dr_busbase = mem->ar_base; 442 dmat->_ranges[n].dr_sysbase = mem->ar_xbase; 443 dmat->_ranges[n].dr_len = mem->ar_length; 444 dmat->_ranges[n].dr_flags = flags; 445 446 aprint_debug_dev(sc->sc_dev, 447 "%s: DMA sys %#lx-%#lx bus %#lx-%#lx%s\n", 448 acpi_name(ad->ad_handle), 449 dmat->_ranges[n].dr_sysbase, 450 dmat->_ranges[n].dr_sysbase + dmat->_ranges[n].dr_len - 1, 451 dmat->_ranges[n].dr_busbase, 452 dmat->_ranges[n].dr_busbase + dmat->_ranges[n].dr_len - 1, 453 flags ? " (coherent)" : ""); 454 } 455 456 acpi_resource_cleanup(&res); 457 } 458 459 static uint32_t 460 arm_acpi_dma_flags(struct acpi_softc *sc, struct acpi_devnode *ad) 461 { 462 ACPI_INTEGER cca = 1; /* default cache coherent */ 463 ACPI_STATUS rv; 464 465 for (; ad != NULL; ad = ad->ad_parent) { 466 if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE) 467 continue; 468 469 rv = acpi_eval_integer(ad->ad_handle, "_CCA", &cca); 470 if (ACPI_SUCCESS(rv)) 471 break; 472 } 473 474 return cca ? _BUS_DMAMAP_COHERENT : 0; 475 } 476 477 bus_dma_tag_t 478 arm_acpi_dma32_tag(struct acpi_softc *sc, struct acpi_devnode *ad) 479 { 480 bus_dma_tag_t dmat64, dmat32; 481 int error; 482 483 if (ad->ad_dmat != NULL) 484 return ad->ad_dmat; 485 486 dmat64 = arm_acpi_dma64_tag(sc, ad); 487 488 const uint32_t flags = arm_acpi_dma_flags(sc, ad); 489 error = bus_dmatag_subregion(dmat64, 0, UINT32_MAX, &dmat32, flags); 490 if (error != 0) 491 panic("arm_acpi_dma32_tag: bus_dmatag_subregion returned %d", 492 error); 493 494 return dmat32; 495 } 496 __strong_alias(acpi_get_dma_tag,arm_acpi_dma32_tag); 497 498 bus_dma_tag_t 499 arm_acpi_dma64_tag(struct acpi_softc *sc, struct acpi_devnode *ad) 500 { 501 struct arm32_bus_dma_tag *dmat; 502 503 if (ad->ad_dmat64 != NULL) 504 return ad->ad_dmat64; 505 506 dmat = kmem_alloc(sizeof(*dmat), KM_SLEEP); 507 *dmat = arm_generic_dma_tag; 508 509 const uint32_t flags = arm_acpi_dma_flags(sc, ad); 510 arm_acpi_dma_init_ranges(sc, ad, dmat, flags); 511 512 return dmat; 513 } 514 __strong_alias(acpi_get_dma64_tag,arm_acpi_dma64_tag); 515