1 /* $NetBSD: acpi_machdep.c,v 1.26 2022/10/15 11:07:38 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.26 2022/10/15 11:07:38 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 struct acpi_intrhandler { 67 int (*ah_fn)(void *); 68 void *ah_arg; 69 TAILQ_ENTRY(acpi_intrhandler) ah_list; 70 }; 71 72 struct acpi_intrvec { 73 int ai_irq; 74 int ai_ipl; 75 int ai_type; 76 bool ai_mpsafe; 77 int ai_refcnt; 78 void *ai_arg; 79 void *ai_ih; 80 TAILQ_HEAD(, acpi_intrhandler) ai_handlers; 81 TAILQ_ENTRY(acpi_intrvec) ai_list; 82 }; 83 84 static TAILQ_HEAD(, acpi_intrvec) acpi_intrvecs = 85 TAILQ_HEAD_INITIALIZER(acpi_intrvecs); 86 87 bus_dma_tag_t arm_acpi_dma32_tag(struct acpi_softc *, struct acpi_devnode *); 88 bus_dma_tag_t arm_acpi_dma64_tag(struct acpi_softc *, struct acpi_devnode *); 89 90 static int 91 acpi_md_pmapflags(paddr_t pa) 92 { 93 int len; 94 95 const int chosen = OF_finddevice("/chosen"); 96 if (chosen == -1) 97 return 0; 98 99 const uint32_t *map = fdtbus_get_prop(chosen, "netbsd,uefi-memmap", &len); 100 if (map == NULL) 101 return 0; 102 103 while (len >= 28) { 104 const uint32_t type = be32dec(&map[0]); 105 const uint64_t phys_start = be64dec(&map[1]); 106 const uint64_t num_pages = be64dec(&map[3]); 107 const uint64_t attr = be64dec(&map[5]); 108 109 if (pa >= phys_start && pa < phys_start + (num_pages * EFI_PAGE_SIZE)) { 110 switch (type) { 111 case EFI_MD_TYPE_RECLAIM: 112 /* ACPI table memory */ 113 return PMAP_WRITE_BACK; 114 115 case EFI_MD_TYPE_IOMEM: 116 case EFI_MD_TYPE_IOPORT: 117 return PMAP_DEV; 118 119 default: 120 if ((attr & EFI_MD_ATTR_WB) != 0) 121 return PMAP_WRITE_BACK; 122 else if ((attr & EFI_MD_ATTR_WC) != 0) 123 return PMAP_WRITE_COMBINE; 124 else if ((attr & EFI_MD_ATTR_WT) != 0) 125 return 0; /* XXX */ 126 127 return PMAP_DEV; 128 } 129 } 130 131 map += 7; 132 len -= 28; 133 } 134 135 /* Not found; assume device memory */ 136 return PMAP_DEV; 137 } 138 139 ACPI_STATUS 140 acpi_md_OsInitialize(void) 141 { 142 return AE_OK; 143 } 144 145 ACPI_PHYSICAL_ADDRESS 146 acpi_md_OsGetRootPointer(void) 147 { 148 uint64_t pa; 149 150 const int chosen = OF_finddevice("/chosen"); 151 if (chosen == -1) 152 return 0; 153 154 if (of_getprop_uint64(chosen, "netbsd,acpi-root-table", &pa) != 0) 155 return 0; 156 157 return (ACPI_PHYSICAL_ADDRESS)pa; 158 } 159 160 ACPI_STATUS 161 acpi_md_OsInstallInterruptHandler(UINT32 irq, ACPI_OSD_HANDLER handler, void *context, 162 void **cookiep, const char *xname) 163 { 164 return AE_NOT_IMPLEMENTED; 165 } 166 167 void 168 acpi_md_OsRemoveInterruptHandler(void *cookie) 169 { 170 intr_disestablish(cookie); 171 } 172 173 ACPI_STATUS 174 acpi_md_OsMapMemory(ACPI_PHYSICAL_ADDRESS pa, UINT32 size, void **vap) 175 { 176 paddr_t spa, epa, curpa; 177 vaddr_t va, curva; 178 179 spa = trunc_page(pa); 180 epa = round_page(pa + size); 181 182 va = uvm_km_alloc(kernel_map, epa - spa, 0, UVM_KMF_VAONLY); 183 if (va == 0) 184 return AE_NO_MEMORY; 185 186 const int pmapflags = acpi_md_pmapflags(spa); 187 188 aprint_debug("%s: 0x%lx 0x%x flags = %#x\n", __func__, pa, size, pmapflags); 189 190 for (curpa = spa, curva = va; curpa < epa; curpa += PAGE_SIZE, curva += PAGE_SIZE) 191 pmap_kenter_pa(curva, curpa, VM_PROT_READ | VM_PROT_WRITE, pmapflags); 192 pmap_update(pmap_kernel()); 193 194 *vap = (void *)(va + (pa - spa)); 195 196 return AE_OK; 197 } 198 199 void 200 acpi_md_OsUnmapMemory(void *va, UINT32 size) 201 { 202 vaddr_t ova; 203 vsize_t osz; 204 205 ova = trunc_page((vaddr_t)va); 206 osz = round_page((vaddr_t)va + size) - ova; 207 208 pmap_kremove(ova, osz); 209 pmap_update(pmap_kernel()); 210 uvm_km_free(kernel_map, ova, osz, UVM_KMF_VAONLY); 211 } 212 213 ACPI_STATUS 214 acpi_md_OsGetPhysicalAddress(void *va, ACPI_PHYSICAL_ADDRESS *pap) 215 { 216 paddr_t pa; 217 218 if (!pmap_extract(pmap_kernel(), (vaddr_t)va, &pa)) 219 return AE_ERROR; 220 221 *pap = pa; 222 223 return AE_OK; 224 } 225 226 BOOLEAN 227 acpi_md_OsReadable(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_RO)) 241 return FALSE; 242 } 243 244 return TRUE; 245 } 246 247 BOOLEAN 248 acpi_md_OsWritable(void *va, UINT32 len) 249 { 250 vaddr_t sva, eva; 251 pt_entry_t *pte; 252 253 sva = trunc_page((vaddr_t)va); 254 eva = round_page((vaddr_t)va + len); 255 256 if (sva < VM_MIN_KERNEL_ADDRESS) 257 return FALSE; 258 259 for (; sva < eva; sva += PAGE_SIZE) { 260 pte = kvtopte(sva); 261 if ((*pte & (LX_BLKPAG_AF|LX_BLKPAG_AP)) != (LX_BLKPAG_AF|LX_BLKPAG_AP_RW)) 262 return FALSE; 263 } 264 265 return TRUE; 266 } 267 268 void 269 acpi_md_OsEnableInterrupt(void) 270 { 271 cpsie(I32_bit); 272 } 273 274 void 275 acpi_md_OsDisableInterrupt(void) 276 { 277 cpsid(I32_bit); 278 } 279 280 static struct acpi_intrvec * 281 acpi_md_intr_lookup(int irq) 282 { 283 struct acpi_intrvec *ai; 284 285 TAILQ_FOREACH(ai, &acpi_intrvecs, ai_list) { 286 if (ai->ai_irq == irq) { 287 return ai; 288 } 289 } 290 291 return NULL; 292 } 293 294 static int 295 acpi_md_intr(void *arg) 296 { 297 struct acpi_intrvec *ai = arg; 298 struct acpi_intrhandler *ah; 299 int rv = 0; 300 301 TAILQ_FOREACH(ah, &ai->ai_handlers, ah_list) { 302 rv += ah->ah_fn(ah->ah_arg); 303 } 304 305 return rv; 306 } 307 308 void * 309 acpi_md_intr_establish(uint32_t irq, int ipl, int type, int (*handler)(void *), void *arg, bool mpsafe, const char *xname) 310 { 311 struct acpi_intrvec *ai; 312 struct acpi_intrhandler *ah; 313 314 ai = acpi_md_intr_lookup(irq); 315 if (ai == NULL) { 316 ai = kmem_zalloc(sizeof(*ai), KM_SLEEP); 317 ai->ai_refcnt = 0; 318 ai->ai_irq = irq; 319 ai->ai_ipl = ipl; 320 ai->ai_type = type; 321 ai->ai_mpsafe = mpsafe; 322 ai->ai_arg = arg; 323 TAILQ_INIT(&ai->ai_handlers); 324 if (arg == NULL) { 325 ai->ai_ih = intr_establish_xname(irq, ipl, 326 type | (mpsafe ? IST_MPSAFE : 0), handler, NULL, 327 xname); 328 } else { 329 ai->ai_ih = intr_establish_xname(irq, ipl, 330 type | (mpsafe ? IST_MPSAFE : 0), acpi_md_intr, ai, 331 xname); 332 } 333 if (ai->ai_ih == NULL) { 334 kmem_free(ai, sizeof(*ai)); 335 return NULL; 336 } 337 TAILQ_INSERT_TAIL(&acpi_intrvecs, ai, ai_list); 338 } else { 339 if (ai->ai_arg == NULL) { 340 printf("ACPI: cannot share irq with NULL arg\n"); 341 return NULL; 342 } 343 if (ai->ai_ipl != ipl) { 344 printf("ACPI: cannot share irq with different ipl\n"); 345 return NULL; 346 } 347 if (ai->ai_type != type) { 348 printf("ACPI: cannot share edge and level interrupts\n"); 349 return NULL; 350 } 351 if (ai->ai_mpsafe != mpsafe) { 352 printf("ACPI: cannot share between mpsafe/non-mpsafe\n"); 353 return NULL; 354 } 355 } 356 357 ai->ai_refcnt++; 358 359 ah = kmem_zalloc(sizeof(*ah), KM_SLEEP); 360 ah->ah_fn = handler; 361 ah->ah_arg = arg; 362 TAILQ_INSERT_TAIL(&ai->ai_handlers, ah, ah_list); 363 364 return ai->ai_ih; 365 } 366 367 void 368 acpi_md_intr_disestablish(void *ih) 369 { 370 struct acpi_intrvec *ai; 371 struct acpi_intrhandler *ah; 372 373 TAILQ_FOREACH(ai, &acpi_intrvecs, ai_list) { 374 if (ai->ai_ih == ih) { 375 KASSERT(ai->ai_refcnt > 0); 376 if (ai->ai_refcnt > 1) { 377 panic("%s: cannot disestablish shared irq", __func__); 378 } 379 380 TAILQ_REMOVE(&acpi_intrvecs, ai, ai_list); 381 ah = TAILQ_FIRST(&ai->ai_handlers); 382 kmem_free(ah, sizeof(*ah)); 383 intr_disestablish(ai->ai_ih); 384 kmem_free(ai, sizeof(*ai)); 385 return; 386 } 387 } 388 389 panic("%s: interrupt not established", __func__); 390 } 391 392 void 393 acpi_md_intr_mask(void *ih) 394 { 395 intr_mask(ih); 396 } 397 398 void 399 acpi_md_intr_unmask(void *ih) 400 { 401 intr_unmask(ih); 402 } 403 404 int 405 acpi_md_sleep(int state) 406 { 407 printf("ERROR: ACPI sleep not implemented on this platform\n"); 408 return -1; 409 } 410 411 uint32_t 412 acpi_md_pdc(void) 413 { 414 return 0; 415 } 416 417 uint32_t 418 acpi_md_ncpus(void) 419 { 420 return kcpuset_countset(kcpuset_attached); 421 } 422 423 static ACPI_STATUS 424 acpi_md_madt_probe_cpu(ACPI_SUBTABLE_HEADER *hdrp, void *aux) 425 { 426 struct acpi_softc * const sc = aux; 427 428 if (hdrp->Type == ACPI_MADT_TYPE_GENERIC_INTERRUPT) 429 config_found(sc->sc_dev, hdrp, NULL, 430 CFARGS(.iattr = "acpimadtbus")); 431 432 return AE_OK; 433 } 434 435 static ACPI_STATUS 436 acpi_md_madt_probe_gic(ACPI_SUBTABLE_HEADER *hdrp, void *aux) 437 { 438 struct acpi_softc * const sc = aux; 439 440 if (hdrp->Type == ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR) 441 config_found(sc->sc_dev, hdrp, NULL, 442 CFARGS(.iattr = "acpimadtbus")); 443 444 return AE_OK; 445 } 446 447 static ACPI_STATUS 448 acpi_md_gtdt_probe(ACPI_GTDT_HEADER *hdrp, void *aux) 449 { 450 struct acpi_softc * const sc = aux; 451 452 config_found(sc->sc_dev, hdrp, NULL, 453 CFARGS(.iattr = "acpigtdtbus")); 454 455 return AE_OK; 456 } 457 458 #if NPCI > 0 459 static struct bus_space acpi_md_mcfg_bs_tag; 460 461 static int 462 acpi_md_mcfg_bs_map(void *t, bus_addr_t bpa, bus_size_t size, int flag, 463 bus_space_handle_t *bshp) 464 { 465 return arm_generic_bs_tag.bs_map(t, bpa, size, 466 flag | BUS_SPACE_MAP_NONPOSTED, bshp); 467 } 468 #endif 469 470 void 471 acpi_md_callback(struct acpi_softc *sc) 472 { 473 #if NPCI > 0 474 acpi_md_mcfg_bs_tag = arm_generic_bs_tag; 475 acpi_md_mcfg_bs_tag.bs_map = acpi_md_mcfg_bs_map; 476 acpimcfg_init(&acpi_md_mcfg_bs_tag, NULL); 477 #endif 478 479 if (acpi_madt_map() != AE_OK) 480 panic("Failed to map MADT"); 481 acpi_madt_walk(acpi_md_madt_probe_cpu, sc); 482 acpi_madt_walk(acpi_md_madt_probe_gic, sc); 483 acpi_madt_unmap(); 484 485 if (acpi_gtdt_map() != AE_OK) 486 panic("Failed to map GTDT"); 487 acpi_gtdt_walk(acpi_md_gtdt_probe, sc); 488 acpi_gtdt_unmap(); 489 } 490 491 static const char * const module_hid[] = { 492 "ACPI0004", /* Module device */ 493 NULL 494 }; 495 496 static ACPI_HANDLE 497 arm_acpi_dma_module(struct acpi_softc *sc, struct acpi_devnode *ad) 498 { 499 ACPI_HANDLE tmp; 500 ACPI_STATUS rv; 501 502 /* 503 * Search up the tree for a module device with a _DMA method. 504 */ 505 for (; ad != NULL; ad = ad->ad_parent) { 506 if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE) 507 continue; 508 if (!acpi_match_hid(ad->ad_devinfo, module_hid)) 509 continue; 510 rv = AcpiGetHandle(ad->ad_handle, "_DMA", &tmp); 511 if (ACPI_SUCCESS(rv)) 512 return ad->ad_handle; 513 } 514 515 return NULL; 516 } 517 518 static void 519 arm_acpi_dma_init_ranges(struct acpi_softc *sc, struct acpi_devnode *ad, 520 struct arm32_bus_dma_tag *dmat, uint32_t flags) 521 { 522 struct acpi_resources res; 523 struct acpi_mem *mem; 524 ACPI_HANDLE module; 525 ACPI_STATUS rv; 526 int n; 527 528 module = arm_acpi_dma_module(sc, ad->ad_parent); 529 if (module == NULL) { 530 default_tag: 531 /* No translation required */ 532 dmat->_nranges = 1; 533 dmat->_ranges = kmem_zalloc(sizeof(*dmat->_ranges), KM_SLEEP); 534 dmat->_ranges[0].dr_sysbase = 0; 535 dmat->_ranges[0].dr_busbase = 0; 536 dmat->_ranges[0].dr_len = UINTPTR_MAX; 537 dmat->_ranges[0].dr_flags = flags; 538 return; 539 } 540 541 rv = acpi_resource_parse_any(sc->sc_dev, module, "_DMA", &res, 542 &acpi_resource_parse_ops_quiet); 543 if (ACPI_FAILURE(rv)) { 544 aprint_error_dev(sc->sc_dev, 545 "failed to parse _DMA on %s: %s\n", 546 acpi_name(module), AcpiFormatException(rv)); 547 goto default_tag; 548 } 549 if (res.ar_nmem == 0) { 550 acpi_resource_cleanup(&res); 551 goto default_tag; 552 } 553 554 dmat->_nranges = res.ar_nmem; 555 dmat->_ranges = kmem_zalloc(sizeof(*dmat->_ranges) * res.ar_nmem, 556 KM_SLEEP); 557 558 for (n = 0; n < res.ar_nmem; n++) { 559 mem = acpi_res_mem(&res, n); 560 dmat->_ranges[n].dr_busbase = mem->ar_base; 561 dmat->_ranges[n].dr_sysbase = mem->ar_xbase; 562 dmat->_ranges[n].dr_len = mem->ar_length; 563 dmat->_ranges[n].dr_flags = flags; 564 565 aprint_debug_dev(sc->sc_dev, 566 "%s: DMA sys %#lx-%#lx bus %#lx-%#lx%s\n", 567 acpi_name(ad->ad_handle), 568 dmat->_ranges[n].dr_sysbase, 569 dmat->_ranges[n].dr_sysbase + dmat->_ranges[n].dr_len - 1, 570 dmat->_ranges[n].dr_busbase, 571 dmat->_ranges[n].dr_busbase + dmat->_ranges[n].dr_len - 1, 572 flags ? " (coherent)" : ""); 573 } 574 575 acpi_resource_cleanup(&res); 576 } 577 578 static uint32_t 579 arm_acpi_dma_flags(struct acpi_softc *sc, struct acpi_devnode *ad) 580 { 581 ACPI_INTEGER cca = 1; /* default cache coherent */ 582 ACPI_STATUS rv; 583 584 for (; ad != NULL; ad = ad->ad_parent) { 585 if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE) 586 continue; 587 588 rv = acpi_eval_integer(ad->ad_handle, "_CCA", &cca); 589 if (ACPI_SUCCESS(rv)) 590 break; 591 } 592 593 return cca ? _BUS_DMAMAP_COHERENT : 0; 594 } 595 596 bus_dma_tag_t 597 arm_acpi_dma32_tag(struct acpi_softc *sc, struct acpi_devnode *ad) 598 { 599 bus_dma_tag_t dmat64, dmat32; 600 int error; 601 602 if (ad->ad_dmat != NULL) 603 return ad->ad_dmat; 604 605 dmat64 = arm_acpi_dma64_tag(sc, ad); 606 607 const uint32_t flags = arm_acpi_dma_flags(sc, ad); 608 error = bus_dmatag_subregion(dmat64, 0, UINT32_MAX, &dmat32, flags); 609 if (error != 0) 610 panic("arm_acpi_dma32_tag: bus_dmatag_subregion returned %d", 611 error); 612 613 return dmat32; 614 } 615 __strong_alias(acpi_get_dma_tag,arm_acpi_dma32_tag); 616 617 bus_dma_tag_t 618 arm_acpi_dma64_tag(struct acpi_softc *sc, struct acpi_devnode *ad) 619 { 620 struct arm32_bus_dma_tag *dmat; 621 622 if (ad->ad_dmat64 != NULL) 623 return ad->ad_dmat64; 624 625 dmat = kmem_alloc(sizeof(*dmat), KM_SLEEP); 626 *dmat = arm_generic_dma_tag; 627 628 const uint32_t flags = arm_acpi_dma_flags(sc, ad); 629 arm_acpi_dma_init_ranges(sc, ad, dmat, flags); 630 631 return dmat; 632 } 633 __strong_alias(acpi_get_dma64_tag,arm_acpi_dma64_tag); 634