acpi_machdep.c revision 1.6.4.3
1 /* $NetBSD: acpi_machdep.c,v 1.6.4.3 2020/04/08 14:07:27 martin 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 (at) 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.6.4.3 2020/04/08 14:07:27 martin 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/pic/picvar.h> 55 56 #include <arm/locore.h> 57 58 #include <machine/acpi_machdep.h> 59 60 extern struct bus_space arm_generic_bs_tag; 61 extern struct arm32_bus_dma_tag acpi_coherent_dma_tag; 62 extern struct arm32_bus_dma_tag arm_generic_dma_tag; 63 64 bus_dma_tag_t arm_acpi_dma32_tag(struct acpi_softc *, struct acpi_devnode *); 65 bus_dma_tag_t arm_acpi_dma64_tag(struct acpi_softc *, struct acpi_devnode *); 66 67 ACPI_STATUS 68 acpi_md_OsInitialize(void) 69 { 70 return AE_OK; 71 } 72 73 ACPI_PHYSICAL_ADDRESS 74 acpi_md_OsGetRootPointer(void) 75 { 76 uint64_t pa; 77 78 const int chosen = OF_finddevice("/chosen"); 79 if (chosen == -1) 80 return 0; 81 82 if (of_getprop_uint64(chosen, "netbsd,acpi-root-table", &pa) != 0) 83 return 0; 84 85 return (ACPI_PHYSICAL_ADDRESS)pa; 86 } 87 88 ACPI_STATUS 89 acpi_md_OsInstallInterruptHandler(UINT32 irq, ACPI_OSD_HANDLER handler, void *context, 90 void **cookiep, const char *xname) 91 { 92 return AE_NOT_IMPLEMENTED; 93 } 94 95 void 96 acpi_md_OsRemoveInterruptHandler(void *cookie) 97 { 98 intr_disestablish(cookie); 99 } 100 101 ACPI_STATUS 102 acpi_md_OsMapMemory(ACPI_PHYSICAL_ADDRESS pa, UINT32 size, void **vap) 103 { 104 paddr_t spa, epa, curpa; 105 vaddr_t va, curva; 106 107 spa = trunc_page(pa); 108 epa = round_page(pa + size); 109 110 va = uvm_km_alloc(kernel_map, epa - spa, 0, UVM_KMF_VAONLY); 111 if (va == 0) 112 return AE_NO_MEMORY; 113 114 for (curpa = spa, curva = va; curpa < epa; curpa += PAGE_SIZE, curva += PAGE_SIZE) 115 pmap_kenter_pa(curva, curpa, VM_PROT_READ | VM_PROT_WRITE, 0); 116 pmap_update(pmap_kernel()); 117 118 *vap = (void *)(va + (pa - spa)); 119 120 return AE_OK; 121 } 122 123 void 124 acpi_md_OsUnmapMemory(void *va, UINT32 size) 125 { 126 vaddr_t ova; 127 vsize_t osz; 128 129 ova = trunc_page((vaddr_t)va); 130 osz = round_page((vaddr_t)va + size) - ova; 131 132 pmap_kremove(ova, osz); 133 pmap_update(pmap_kernel()); 134 uvm_km_free(kernel_map, ova, osz, UVM_KMF_VAONLY); 135 } 136 137 ACPI_STATUS 138 acpi_md_OsGetPhysicalAddress(void *va, ACPI_PHYSICAL_ADDRESS *pap) 139 { 140 paddr_t pa; 141 142 if (!pmap_extract(pmap_kernel(), (vaddr_t)va, &pa)) 143 return AE_ERROR; 144 145 *pap = pa; 146 147 return AE_OK; 148 } 149 150 BOOLEAN 151 acpi_md_OsReadable(void *va, UINT32 len) 152 { 153 vaddr_t sva, eva; 154 pt_entry_t *pte; 155 156 sva = trunc_page((vaddr_t)va); 157 eva = round_page((vaddr_t)va + len); 158 159 if (sva < VM_MIN_KERNEL_ADDRESS) 160 return FALSE; 161 162 for (; sva < eva; sva += PAGE_SIZE) { 163 pte = kvtopte(sva); 164 if ((*pte & (LX_BLKPAG_AF|LX_BLKPAG_AP_RO)) != (LX_BLKPAG_AF|LX_BLKPAG_AP_RO)) 165 return FALSE; 166 } 167 168 return TRUE; 169 } 170 171 BOOLEAN 172 acpi_md_OsWritable(void *va, UINT32 len) 173 { 174 vaddr_t sva, eva; 175 pt_entry_t *pte; 176 177 sva = trunc_page((vaddr_t)va); 178 eva = round_page((vaddr_t)va + len); 179 180 if (sva < VM_MIN_KERNEL_ADDRESS) 181 return FALSE; 182 183 for (; sva < eva; sva += PAGE_SIZE) { 184 pte = kvtopte(sva); 185 if ((*pte & (LX_BLKPAG_AF|LX_BLKPAG_AP_RW)) != (LX_BLKPAG_AF|LX_BLKPAG_AP_RW)) 186 return FALSE; 187 } 188 189 return TRUE; 190 } 191 192 void 193 acpi_md_OsEnableInterrupt(void) 194 { 195 cpsie(I32_bit); 196 } 197 198 void 199 acpi_md_OsDisableInterrupt(void) 200 { 201 cpsid(I32_bit); 202 } 203 204 void * 205 acpi_md_intr_establish(uint32_t irq, int ipl, int type, int (*handler)(void *), void *arg, bool mpsafe, const char *xname) 206 { 207 return intr_establish_xname(irq, ipl, type | (mpsafe ? IST_MPSAFE : 0), handler, arg, xname); 208 } 209 210 void 211 acpi_md_intr_mask(void *ih) 212 { 213 intr_mask(ih); 214 } 215 216 void 217 acpi_md_intr_unmask(void *ih) 218 { 219 intr_unmask(ih); 220 } 221 222 void 223 acpi_md_intr_disestablish(void *ih) 224 { 225 intr_disestablish(ih); 226 } 227 228 int 229 acpi_md_sleep(int state) 230 { 231 printf("ERROR: ACPI sleep not implemented on this platform\n"); 232 return -1; 233 } 234 235 uint32_t 236 acpi_md_pdc(void) 237 { 238 return 0; 239 } 240 241 uint32_t 242 acpi_md_ncpus(void) 243 { 244 return kcpuset_countset(kcpuset_attached); 245 } 246 247 static ACPI_STATUS 248 acpi_md_madt_probe_cpu(ACPI_SUBTABLE_HEADER *hdrp, void *aux) 249 { 250 struct acpi_softc * const sc = aux; 251 252 if (hdrp->Type == ACPI_MADT_TYPE_GENERIC_INTERRUPT) 253 config_found_ia(sc->sc_dev, "acpimadtbus", hdrp, NULL); 254 255 return AE_OK; 256 } 257 258 static ACPI_STATUS 259 acpi_md_madt_probe_gic(ACPI_SUBTABLE_HEADER *hdrp, void *aux) 260 { 261 struct acpi_softc * const sc = aux; 262 263 if (hdrp->Type == ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR) 264 config_found_ia(sc->sc_dev, "acpimadtbus", hdrp, NULL); 265 266 return AE_OK; 267 } 268 269 static ACPI_STATUS 270 acpi_md_gtdt_probe(ACPI_GTDT_HEADER *hdrp, void *aux) 271 { 272 struct acpi_softc * const sc = aux; 273 274 config_found_ia(sc->sc_dev, "acpigtdtbus", hdrp, NULL); 275 276 return AE_OK; 277 } 278 279 #if NPCI > 0 280 static struct bus_space acpi_md_mcfg_bs_tag; 281 282 static int 283 acpi_md_mcfg_bs_map(void *t, bus_addr_t bpa, bus_size_t size, int flag, 284 bus_space_handle_t *bshp) 285 { 286 return arm_generic_bs_tag.bs_map(t, bpa, size, 287 flag | _ARM_BUS_SPACE_MAP_STRONGLY_ORDERED, bshp); 288 } 289 #endif 290 291 void 292 acpi_md_callback(struct acpi_softc *sc) 293 { 294 ACPI_TABLE_HEADER *hdrp; 295 296 #if NPCI > 0 297 acpi_md_mcfg_bs_tag = arm_generic_bs_tag; 298 acpi_md_mcfg_bs_tag.bs_map = acpi_md_mcfg_bs_map; 299 acpimcfg_init(&acpi_md_mcfg_bs_tag, NULL); 300 #endif 301 302 if (acpi_madt_map() != AE_OK) 303 panic("Failed to map MADT"); 304 acpi_madt_walk(acpi_md_madt_probe_cpu, sc); 305 acpi_madt_walk(acpi_md_madt_probe_gic, sc); 306 acpi_madt_unmap(); 307 308 if (acpi_gtdt_map() != AE_OK) 309 panic("Failed to map GTDT"); 310 acpi_gtdt_walk(acpi_md_gtdt_probe, sc); 311 acpi_gtdt_unmap(); 312 313 if (ACPI_SUCCESS(AcpiGetTable(ACPI_SIG_GTDT, 0, &hdrp))) 314 config_found_ia(sc->sc_dev, "acpisdtbus", hdrp, NULL); 315 } 316 317 static const char * const module_hid[] = { 318 "ACPI0004", /* Module device */ 319 NULL 320 }; 321 322 static ACPI_HANDLE 323 arm_acpi_dma_module(struct acpi_softc *sc, struct acpi_devnode *ad) 324 { 325 ACPI_HANDLE tmp; 326 ACPI_STATUS rv; 327 328 /* 329 * Search up the tree for a module device with a _DMA method. 330 */ 331 for (; ad != NULL; ad = ad->ad_parent) { 332 if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE) 333 continue; 334 if (!acpi_match_hid(ad->ad_devinfo, module_hid)) 335 continue; 336 rv = AcpiGetHandle(ad->ad_handle, "_DMA", &tmp); 337 if (ACPI_SUCCESS(rv)) 338 return ad->ad_handle; 339 } 340 341 return NULL; 342 } 343 344 static void 345 arm_acpi_dma_init_ranges(struct acpi_softc *sc, struct acpi_devnode *ad, 346 struct arm32_bus_dma_tag *dmat, uint32_t flags) 347 { 348 struct acpi_resources res; 349 struct acpi_mem *mem; 350 ACPI_HANDLE module; 351 ACPI_STATUS rv; 352 int n; 353 354 module = arm_acpi_dma_module(sc, ad->ad_parent); 355 if (module == NULL) { 356 default_tag: 357 /* No translation required */ 358 dmat->_nranges = 1; 359 dmat->_ranges = kmem_zalloc(sizeof(*dmat->_ranges), KM_SLEEP); 360 dmat->_ranges[0].dr_sysbase = 0; 361 dmat->_ranges[0].dr_busbase = 0; 362 dmat->_ranges[0].dr_len = UINTPTR_MAX; 363 dmat->_ranges[0].dr_flags = flags; 364 return; 365 } 366 367 rv = acpi_resource_parse(sc->sc_dev, module, "_DMA", &res, 368 &acpi_resource_parse_ops_quiet); 369 if (ACPI_FAILURE(rv)) { 370 aprint_error_dev(sc->sc_dev, 371 "failed to parse _DMA on %s: %s\n", 372 acpi_name(module), AcpiFormatException(rv)); 373 goto default_tag; 374 } 375 if (res.ar_nmem == 0) { 376 acpi_resource_cleanup(&res); 377 goto default_tag; 378 } 379 380 dmat->_nranges = res.ar_nmem; 381 dmat->_ranges = kmem_zalloc(sizeof(*dmat->_ranges) * res.ar_nmem, 382 KM_SLEEP); 383 384 for (n = 0; n < res.ar_nmem; n++) { 385 mem = acpi_res_mem(&res, n); 386 dmat->_ranges[n].dr_busbase = mem->ar_base; 387 dmat->_ranges[n].dr_sysbase = mem->ar_xbase; 388 dmat->_ranges[n].dr_len = mem->ar_length; 389 dmat->_ranges[n].dr_flags = flags; 390 391 aprint_debug_dev(sc->sc_dev, 392 "%s: DMA sys %#lx-%#lx bus %#lx-%#lx%s\n", 393 acpi_name(ad->ad_handle), 394 dmat->_ranges[n].dr_sysbase, 395 dmat->_ranges[n].dr_sysbase + dmat->_ranges[n].dr_len - 1, 396 dmat->_ranges[n].dr_busbase, 397 dmat->_ranges[n].dr_busbase + dmat->_ranges[n].dr_len - 1, 398 flags ? " (coherent)" : ""); 399 } 400 401 acpi_resource_cleanup(&res); 402 } 403 404 static uint32_t 405 arm_acpi_dma_flags(struct acpi_softc *sc, struct acpi_devnode *ad) 406 { 407 ACPI_INTEGER cca = 1; /* default cache coherent */ 408 ACPI_STATUS rv; 409 410 for (; ad != NULL; ad = ad->ad_parent) { 411 if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE) 412 continue; 413 414 rv = acpi_eval_integer(ad->ad_handle, "_CCA", &cca); 415 if (ACPI_SUCCESS(rv)) 416 break; 417 } 418 419 return cca ? _BUS_DMAMAP_COHERENT : 0; 420 } 421 422 bus_dma_tag_t 423 arm_acpi_dma32_tag(struct acpi_softc *sc, struct acpi_devnode *ad) 424 { 425 bus_dma_tag_t dmat64, dmat32; 426 int error; 427 428 if (ad->ad_dmat != NULL) 429 return ad->ad_dmat; 430 431 dmat64 = arm_acpi_dma64_tag(sc, ad); 432 433 const uint32_t flags = arm_acpi_dma_flags(sc, ad); 434 error = bus_dmatag_subregion(dmat64, 0, UINT32_MAX, &dmat32, flags); 435 if (error != 0) 436 panic("arm_acpi_dma32_tag: bus_dmatag_subregion returned %d", 437 error); 438 439 return dmat32; 440 } 441 __strong_alias(acpi_get_dma_tag,arm_acpi_dma32_tag); 442 443 bus_dma_tag_t 444 arm_acpi_dma64_tag(struct acpi_softc *sc, struct acpi_devnode *ad) 445 { 446 struct arm32_bus_dma_tag *dmat; 447 448 if (ad->ad_dmat64 != NULL) 449 return ad->ad_dmat64; 450 451 dmat = kmem_alloc(sizeof(*dmat), KM_SLEEP); 452 *dmat = arm_generic_dma_tag; 453 454 const uint32_t flags = arm_acpi_dma_flags(sc, ad); 455 arm_acpi_dma_init_ranges(sc, ad, dmat, flags); 456 457 return dmat; 458 } 459 __strong_alias(acpi_get_dma64_tag,arm_acpi_dma64_tag); 460
Indexes created Wed Oct 22 00:09:40 GMT 2025