uturn.c revision 1.6
1 /* $NetBSD: uturn.c,v 1.6 2022/09/29 06:42:14 skrll Exp $ */ 2 3 /* $OpenBSD: uturn.c,v 1.6 2007/12/29 01:26:14 kettenis Exp $ */ 4 5 /*- 6 * Copyright (c) 2012 The NetBSD Foundation, Inc. 7 * All rights reserved. 8 * 9 * This code is derived from software contributed to The NetBSD Foundation 10 * by Nick Hudson. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 23 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 * POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 /* 35 * Copyright (c) 2007 Mark Kettenis 36 * 37 * Permission to use, copy, modify, and distribute this software for any 38 * purpose with or without fee is hereby granted, provided that the above 39 * copyright notice and this permission notice appear in all copies. 40 * 41 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 42 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 43 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 44 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 45 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 46 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 47 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 48 */ 49 50 /* 51 * Copyright (c) 2004 Michael Shalayeff 52 * All rights reserved. 53 * 54 * Redistribution and use in source and binary forms, with or without 55 * modification, are permitted provided that the following conditions 56 * are met: 57 * 1. Redistributions of source code must retain the above copyright 58 * notice, this list of conditions and the following disclaimer. 59 * 2. Redistributions in binary form must reproduce the above copyright 60 * notice, this list of conditions and the following disclaimer in the 61 * documentation and/or other materials provided with the distribution. 62 * 63 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 64 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 65 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 66 * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT, 67 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 68 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 69 * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 70 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 71 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 72 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 73 * THE POSSIBILITY OF SUCH DAMAGE. 74 */ 75 76 /* 77 * References: 78 * 1. Hardware Cache Coherent Input/Output. Hewlett-Packard Journal, February 79 * 1996. 80 * 2. PA-RISC 1.1 Architecture and Instruction Set Reference Manual, 81 * Hewlett-Packard, February 1994, Third Edition 82 */ 83 84 #include <sys/param.h> 85 86 #include <sys/systm.h> 87 #include <sys/device.h> 88 #include <sys/extent.h> 89 #include <sys/kmem.h> 90 #include <sys/mbuf.h> 91 #include <sys/reboot.h> 92 #include <sys/tree.h> 93 94 #include <uvm/uvm.h> 95 96 #include <sys/bus.h> 97 #include <machine/iomod.h> 98 #include <machine/autoconf.h> 99 100 #include <hppa/dev/cpudevs.h> 101 102 #define UTURNDEBUG 103 #ifdef UTURNDEBUG 104 105 #define DPRINTF(s) do { \ 106 if (uturndebug) \ 107 printf s; \ 108 } while(0) 109 110 int uturndebug = 0; 111 #else 112 #define DPRINTF(s) /* */ 113 #endif 114 115 struct uturn_regs { 116 /* Runway Supervisory Set */ 117 int32_t unused1[12]; 118 uint32_t io_command; /* Offset 12 */ 119 #define UTURN_CMD_TLB_PURGE 33 /* Purge I/O TLB entry */ 120 #define UTURN_CMD_TLB_DIRECT_WRITE 35 /* I/O TLB Writes */ 121 122 uint32_t io_status; /* Offset 13 */ 123 uint32_t io_control; /* Offset 14 */ 124 #define UTURN_IOCTRL_TLB_REAL 0x00000000 125 #define UTURN_IOCTRL_TLB_ERROR 0x00010000 126 #define UTURN_IOCTRL_TLB_NORMAL 0x00020000 127 128 #define UTURN_IOCTRL_MODE_OFF 0x00000000 129 #define UTURN_IOCTRL_MODE_INCLUDE 0x00000080 130 #define UTURN_IOCTRL_MODE_PEEK 0x00000180 131 132 #define UTURN_VIRTUAL_MODE \ 133 (UTURN_IOCTRL_TLB_NORMAL | UTURN_IOCTRL_MODE_INCLUDE) 134 135 #define UTURN_REAL_MODE \ 136 UTURN_IOCTRL_MODE_INCLUDE 137 138 int32_t unused2[1]; 139 140 /* Runway Auxiliary Register Set */ 141 uint32_t io_err_resp; /* Offset 0 */ 142 uint32_t io_err_info; /* Offset 1 */ 143 uint32_t io_err_req; /* Offset 2 */ 144 uint32_t io_err_resp_hi; /* Offset 3 */ 145 uint32_t io_tlb_entry_m; /* Offset 4 */ 146 uint32_t io_tlb_entry_l; /* Offset 5 */ 147 uint32_t unused3[1]; 148 uint32_t io_pdir_base; /* Offset 7 */ 149 uint32_t io_io_low_hv; /* Offset 8 */ 150 uint32_t io_io_high_hv; /* Offset 9 */ 151 uint32_t unused4[1]; 152 uint32_t io_chain_id_mask; /* Offset 11 */ 153 uint32_t unused5[2]; 154 uint32_t io_io_low; /* Offset 14 */ 155 uint32_t io_io_high; /* Offset 15 */ 156 }; 157 158 159 /* Uturn supports 256 TLB entries */ 160 #define UTURN_CHAINID_SHIFT 8 161 #define UTURN_CHAINID_MASK 0xff 162 #define UTURN_TLB_ENTRIES (1 << UTURN_CHAINID_SHIFT) 163 164 #define UTURN_IOVP_SIZE PAGE_SIZE 165 #define UTURN_IOVP_SHIFT PAGE_SHIFT 166 #define UTURN_IOVP_MASK PAGE_MASK 167 168 #define UTURN_IOVA(iovp, off) ((iovp) | (off)) 169 #define UTURN_IOVP(iova) ((iova) & UTURN_IOVP_MASK) 170 #define UTURN_IOVA_INDEX(iova) ((iova) >> UTURN_IOVP_SHIFT) 171 172 struct uturn_softc { 173 device_t sc_dv; 174 175 bus_dma_tag_t sc_dmat; 176 struct uturn_regs volatile *sc_regs; 177 uint64_t *sc_pdir; 178 uint32_t sc_chainid_shift; 179 180 char sc_mapname[20]; 181 struct extent *sc_map; 182 183 struct hppa_bus_dma_tag sc_dmatag; 184 }; 185 186 /* 187 * per-map IOVA page table 188 */ 189 struct uturn_page_entry { 190 SPLAY_ENTRY(uturn_page_entry) upe_node; 191 paddr_t upe_pa; 192 vaddr_t upe_va; 193 bus_addr_t upe_iova; 194 }; 195 196 struct uturn_page_map { 197 SPLAY_HEAD(uturn_page_tree, uturn_page_entry) upm_tree; 198 int upm_maxpage; /* Size of allocated page map */ 199 int upm_pagecnt; /* Number of entries in use */ 200 struct uturn_page_entry upm_map[1]; 201 }; 202 203 /* 204 * per-map UTURN state 205 */ 206 struct uturn_map_state { 207 struct uturn_softc *ums_sc; 208 bus_addr_t ums_iovastart; 209 bus_size_t ums_iovasize; 210 struct uturn_page_map ums_map; /* map must be last (array at end) */ 211 }; 212 213 int uturnmatch(device_t, cfdata_t, void *); 214 void uturnattach(device_t, device_t, void *); 215 static device_t uturn_callback(device_t, struct confargs *); 216 217 CFATTACH_DECL_NEW(uturn, sizeof(struct uturn_softc), 218 uturnmatch, uturnattach, NULL, NULL); 219 220 extern struct cfdriver uturn_cd; 221 222 int uturn_dmamap_create(void *, bus_size_t, int, bus_size_t, bus_size_t, int, 223 bus_dmamap_t *); 224 void uturn_dmamap_destroy(void *, bus_dmamap_t); 225 int uturn_dmamap_load(void *, bus_dmamap_t, void *, bus_size_t, struct proc *, 226 int); 227 int uturn_dmamap_load_mbuf(void *, bus_dmamap_t, struct mbuf *, int); 228 int uturn_dmamap_load_uio(void *, bus_dmamap_t, struct uio *, int); 229 int uturn_dmamap_load_raw(void *, bus_dmamap_t, bus_dma_segment_t *, int, 230 bus_size_t, int); 231 void uturn_dmamap_unload(void *, bus_dmamap_t); 232 void uturn_dmamap_sync(void *, bus_dmamap_t, bus_addr_t, bus_size_t, int); 233 int uturn_dmamem_alloc(void *, bus_size_t, bus_size_t, bus_size_t, 234 bus_dma_segment_t *, int, int *, int); 235 void uturn_dmamem_free(void *, bus_dma_segment_t *, int); 236 int uturn_dmamem_map(void *, bus_dma_segment_t *, int, size_t, void **, int); 237 void uturn_dmamem_unmap(void *, void *, size_t); 238 paddr_t uturn_dmamem_mmap(void *, bus_dma_segment_t *, int, off_t, int, int); 239 240 static void uturn_iommu_enter(struct uturn_softc *, bus_addr_t, pa_space_t, 241 vaddr_t, paddr_t); 242 static void uturn_iommu_remove(struct uturn_softc *, bus_addr_t, bus_size_t); 243 244 struct uturn_map_state *uturn_iomap_create(int, int); 245 void uturn_iomap_destroy(struct uturn_map_state *); 246 int uturn_iomap_insert_page(struct uturn_map_state *, vaddr_t, paddr_t); 247 bus_addr_t uturn_iomap_translate(struct uturn_map_state *, paddr_t); 248 void uturn_iomap_clear_pages(struct uturn_map_state *); 249 250 static int uturn_iomap_load_map(struct uturn_softc *, bus_dmamap_t, int); 251 252 const struct hppa_bus_dma_tag uturn_dmat = { 253 NULL, 254 uturn_dmamap_create, uturn_dmamap_destroy, 255 uturn_dmamap_load, uturn_dmamap_load_mbuf, 256 uturn_dmamap_load_uio, uturn_dmamap_load_raw, 257 uturn_dmamap_unload, uturn_dmamap_sync, 258 259 uturn_dmamem_alloc, uturn_dmamem_free, uturn_dmamem_map, 260 uturn_dmamem_unmap, uturn_dmamem_mmap 261 }; 262 263 int 264 uturnmatch(device_t parent, cfdata_t cf, void *aux) 265 { 266 struct confargs *ca = aux; 267 268 /* there will be only one */ 269 if (ca->ca_type.iodc_type != HPPA_TYPE_IOA || 270 ca->ca_type.iodc_sv_model != HPPA_IOA_UTURN) 271 return 0; 272 273 if (ca->ca_type.iodc_model == 0x58 && 274 ca->ca_type.iodc_revision >= 0x20) 275 return 0; 276 277 return 1; 278 } 279 280 void 281 uturnattach(device_t parent, device_t self, void *aux) 282 { 283 struct confargs *ca = aux, nca; 284 struct uturn_softc *sc = device_private(self); 285 bus_space_handle_t ioh; 286 volatile struct uturn_regs *r; 287 struct pglist pglist; 288 int iova_bits; 289 vaddr_t va; 290 psize_t size; 291 int i; 292 293 if (bus_space_map(ca->ca_iot, ca->ca_hpa, IOMOD_HPASIZE, 0, &ioh)) { 294 aprint_error(": can't map IO space\n"); 295 return; 296 } 297 298 sc->sc_dv = self; 299 sc->sc_dmat = ca->ca_dmatag; 300 sc->sc_regs = r = bus_space_vaddr(ca->ca_iot, ioh); 301 302 aprint_normal(": %x-%x", r->io_io_low << 16, r->io_io_high << 16); 303 aprint_normal(": %x-%x", r->io_io_low_hv << 16, r->io_io_high_hv << 16); 304 305 aprint_normal(": %s rev %d\n", 306 ca->ca_type.iodc_revision < 0x10 ? "U2" : "UTurn", 307 ca->ca_type.iodc_revision & 0xf); 308 309 /* 310 * Setup the iommu. 311 */ 312 313 /* XXX 28 bits gives us 256Mb of iova space */ 314 /* Calculate based on %age of RAM */ 315 iova_bits = 28; 316 317 /* 318 * size is # of pdir entries (64bits) in bytes. 1 entry per IOVA 319 * page. 320 */ 321 size = (1 << (iova_bits - UTURN_IOVP_SHIFT)) * sizeof(uint64_t); 322 323 /* 324 * Chainid is the upper most bits of an IOVP used to determine which 325 * TLB entry an IOVP will use. 326 */ 327 sc->sc_chainid_shift = iova_bits - UTURN_CHAINID_SHIFT; 328 329 /* 330 * Allocate memory for I/O pagetables. They need to be physically 331 * contiguous. 332 */ 333 334 if (uvm_pglistalloc(size, 0, -1, PAGE_SIZE, 0, &pglist, 1, 0) != 0) 335 panic("%s: no memory", __func__); 336 337 va = (vaddr_t)VM_PAGE_TO_PHYS(TAILQ_FIRST(&pglist)); 338 sc->sc_pdir = (int64_t *)va; 339 340 memset(sc->sc_pdir, 0, size); 341 342 r->io_chain_id_mask = UTURN_CHAINID_MASK << sc->sc_chainid_shift; 343 r->io_pdir_base = VM_PAGE_TO_PHYS(TAILQ_FIRST(&pglist)); 344 345 r->io_tlb_entry_m = 0; 346 r->io_tlb_entry_l = 0; 347 348 /* for (i = UTURN_TLB_ENTRIES; i != 0; i--) { */ 349 for (i = 0; i < UTURN_TLB_ENTRIES; i++) { 350 r->io_command = 351 UTURN_CMD_TLB_DIRECT_WRITE | (i << sc->sc_chainid_shift); 352 } 353 /* 354 * Go to "Virtual Mode" 355 */ 356 r->io_control = UTURN_VIRTUAL_MODE; 357 358 snprintf(sc->sc_mapname, sizeof(sc->sc_mapname), "%s_map", 359 device_xname(sc->sc_dv)); 360 sc->sc_map = extent_create(sc->sc_mapname, 0, (1 << iova_bits), 361 0, 0, EX_WAITOK); 362 363 sc->sc_dmatag = uturn_dmat; 364 sc->sc_dmatag._cookie = sc; 365 366 /* 367 * U2/UTurn is actually a combination of an Upper Bus Converter (UBC) 368 * and a Lower Bus Converter (LBC). This driver attaches to the UBC; 369 * the LBC isn't very interesting, so we skip it. This is easy, since 370 * it always is module 63, hence the MAXMODBUS - 1 below. 371 */ 372 nca = *ca; 373 nca.ca_hpabase = r->io_io_low << 16; 374 nca.ca_dmatag = &sc->sc_dmatag; 375 nca.ca_nmodules = MAXMODBUS - 1; 376 pdc_scanbus(self, &nca, uturn_callback); 377 } 378 379 static device_t 380 uturn_callback(device_t self, struct confargs *ca) 381 { 382 383 return config_found(self, ca, mbprint, 384 CFARGS(.submatch = mbsubmatch)); 385 } 386 387 /* 388 * PDIR entry format (HP bit number) 389 * 390 * +-------+----------------+----------------------------------------------+ 391 * |0 3|4 15|16 31| 392 * | PPN | Virtual Index | Physical Page Number (PPN) | 393 * | [0:3] | [0:11] | [4:19] | 394 * +-------+----------------+----------------------------------------------+ 395 * 396 * +-----------------------+-----------------------------------------------+ 397 * |0 19|20 24| 25 | | | | 30 | 31 | 398 * | PPN | Rsvd | PH |Update | Rsvd |Lock | Safe | Valid | 399 * | [20:39 | | Enable |Enable | |Enable| DMA | | 400 * +-----------------------+-----------------------------------------------+ 401 * 402 */ 403 404 #define UTURN_PENTRY_PREFETCH 0x40 405 #define UTURN_PENTRY_UPDATE 0x20 406 #define UTURN_PENTRY_LOCK 0x04 /* eisa devices only */ 407 #define UTURN_PENTRY_SAFEDMA 0x02 /* use safe dma - for subcacheline */ 408 #define UTURN_PENTRY_VALID 0x01 409 410 static void 411 uturn_iommu_enter(struct uturn_softc *sc, bus_addr_t iova, pa_space_t sp, 412 vaddr_t va, paddr_t pa) 413 { 414 uint64_t pdir_entry; 415 uint64_t *pdirp; 416 uint32_t ci; /* coherent index */ 417 418 pdirp = &sc->sc_pdir[UTURN_IOVA_INDEX(iova)]; 419 420 DPRINTF(("%s: iova %lx pdir %p pdirp %p pa %lx", __func__, iova, 421 sc->sc_pdir, pdirp, pa)); 422 423 ci = lci(HPPA_SID_KERNEL, va); 424 425 /* setup hints, etc */ 426 pdir_entry = (UTURN_PENTRY_LOCK | UTURN_PENTRY_SAFEDMA | 427 UTURN_PENTRY_VALID); 428 429 /* 430 * bottom 36 bits of pa map directly into entry to form PPN[4:39] 431 * leaving last 12 bits for hints, etc. 432 */ 433 pdir_entry |= (pa & ~PAGE_MASK); 434 435 /* mask off top PPN bits */ 436 pdir_entry &= 0x0000ffffffffffffUL; 437 438 /* insert the virtual index bits */ 439 pdir_entry |= (((uint64_t)ci >> 12) << 48); 440 441 /* PPN[0:3] of the 40bit PPN go in entry[0:3] */ 442 pdir_entry |= ((((uint64_t)pa & 0x000f000000000000UL) >> 48) << 60); 443 444 *pdirp = pdir_entry; 445 446 DPRINTF((": pdir_entry %llx\n", pdir_entry)); 447 448 /* 449 * We could use PDC_MODEL_CAPABILITIES here 450 */ 451 fdcache(HPPA_SID_KERNEL, (vaddr_t)pdirp, sizeof(uint64_t)); 452 } 453 454 455 static void 456 uturn_iommu_remove(struct uturn_softc *sc, bus_addr_t iova, bus_size_t size) 457 { 458 uint32_t chain_size = 1 << sc->sc_chainid_shift; 459 bus_size_t len; 460 461 KASSERT((iova & PAGE_MASK) == 0); 462 KASSERT((size & PAGE_MASK) == 0); 463 464 DPRINTF(("%s: sc %p iova %lx size %lx\n", __func__, sc, iova, size)); 465 len = size; 466 while (len != 0) { 467 uint64_t *pdirp = &sc->sc_pdir[UTURN_IOVA_INDEX(iova)]; 468 469 /* XXX Just the valid bit??? */ 470 *pdirp = 0; 471 472 /* 473 * We could use PDC_MODEL_CAPABILITIES here 474 */ 475 fdcache(HPPA_SID_KERNEL, (vaddr_t)pdirp, sizeof(uint64_t)); 476 477 iova += PAGE_SIZE; 478 len -= PAGE_SIZE; 479 } 480 481 len = size + chain_size; 482 483 while (len > chain_size) { 484 sc->sc_regs->io_command = UTURN_CMD_TLB_PURGE | iova; 485 iova += chain_size; 486 len -= chain_size; 487 } 488 } 489 490 int 491 uturn_dmamap_create(void *v, bus_size_t size, int nsegments, 492 bus_size_t maxsegsz, bus_size_t boundary, int flags, bus_dmamap_t *dmamap) 493 { 494 struct uturn_softc *sc = v; 495 bus_dmamap_t map; 496 struct uturn_map_state *ums; 497 int error; 498 499 error = bus_dmamap_create(sc->sc_dmat, size, nsegments, maxsegsz, 500 boundary, flags, &map); 501 if (error) 502 return (error); 503 504 ums = uturn_iomap_create(atop(round_page(size)), flags); 505 if (ums == NULL) { 506 bus_dmamap_destroy(sc->sc_dmat, map); 507 return (ENOMEM); 508 } 509 510 ums->ums_sc = sc; 511 map->_dm_cookie = ums; 512 *dmamap = map; 513 514 return (0); 515 } 516 517 void 518 uturn_dmamap_destroy(void *v, bus_dmamap_t map) 519 { 520 struct uturn_softc *sc = v; 521 522 /* 523 * The specification (man page) requires a loaded 524 * map to be unloaded before it is destroyed. 525 */ 526 if (map->dm_nsegs) 527 uturn_dmamap_unload(sc, map); 528 529 if (map->_dm_cookie) 530 uturn_iomap_destroy(map->_dm_cookie); 531 map->_dm_cookie = NULL; 532 533 bus_dmamap_destroy(sc->sc_dmat, map); 534 } 535 536 static int 537 uturn_iomap_load_map(struct uturn_softc *sc, bus_dmamap_t map, int flags) 538 { 539 struct uturn_map_state *ums = map->_dm_cookie; 540 struct uturn_page_map *upm = &ums->ums_map; 541 struct uturn_page_entry *e; 542 int err, seg, s; 543 paddr_t pa, paend; 544 vaddr_t va; 545 bus_size_t sgsize; 546 bus_size_t align, boundary; 547 u_long iovaddr; 548 bus_addr_t iova; 549 int i; 550 551 /* XXX */ 552 boundary = map->_dm_boundary; 553 align = PAGE_SIZE; 554 555 uturn_iomap_clear_pages(ums); 556 557 for (seg = 0; seg < map->dm_nsegs; seg++) { 558 struct hppa_bus_dma_segment *ds = &map->dm_segs[seg]; 559 560 paend = round_page(ds->ds_addr + ds->ds_len); 561 for (pa = trunc_page(ds->ds_addr), va = trunc_page(ds->_ds_va); 562 pa < paend; pa += PAGE_SIZE, va += PAGE_SIZE) { 563 err = uturn_iomap_insert_page(ums, va, pa); 564 if (err) { 565 printf("iomap insert error: %d for " 566 "va 0x%lx pa 0x%lx\n", err, va, pa); 567 bus_dmamap_unload(sc->sc_dmat, map); 568 uturn_iomap_clear_pages(ums); 569 } 570 } 571 } 572 573 sgsize = ums->ums_map.upm_pagecnt * PAGE_SIZE; 574 /* XXXNH */ 575 s = splhigh(); 576 err = extent_alloc(sc->sc_map, sgsize, align, boundary, 577 EX_NOWAIT | EX_BOUNDZERO, &iovaddr); 578 splx(s); 579 if (err) 580 return (err); 581 582 ums->ums_iovastart = iovaddr; 583 ums->ums_iovasize = sgsize; 584 585 iova = iovaddr; 586 for (i = 0, e = upm->upm_map; i < upm->upm_pagecnt; ++i, ++e) { 587 e->upe_iova = iova; 588 uturn_iommu_enter(sc, e->upe_iova, HPPA_SID_KERNEL, e->upe_va, 589 e->upe_pa); 590 iova += PAGE_SIZE; 591 } 592 593 for (seg = 0; seg < map->dm_nsegs; seg++) { 594 struct hppa_bus_dma_segment *ds = &map->dm_segs[seg]; 595 ds->ds_addr = uturn_iomap_translate(ums, ds->ds_addr); 596 } 597 598 return (0); 599 } 600 601 int 602 uturn_dmamap_load(void *v, bus_dmamap_t map, void *addr, bus_size_t size, 603 struct proc *p, int flags) 604 { 605 struct uturn_softc *sc = v; 606 int err; 607 608 err = bus_dmamap_load(sc->sc_dmat, map, addr, size, p, flags); 609 if (err) 610 return (err); 611 612 return uturn_iomap_load_map(sc, map, flags); 613 } 614 615 int 616 uturn_dmamap_load_mbuf(void *v, bus_dmamap_t map, struct mbuf *m, int flags) 617 { 618 struct uturn_softc *sc = v; 619 int err; 620 621 err = bus_dmamap_load_mbuf(sc->sc_dmat, map, m, flags); 622 if (err) 623 return (err); 624 625 return uturn_iomap_load_map(sc, map, flags); 626 } 627 628 int 629 uturn_dmamap_load_uio(void *v, bus_dmamap_t map, struct uio *uio, int flags) 630 { 631 struct uturn_softc *sc = v; 632 633 printf("load_uio\n"); 634 635 return (bus_dmamap_load_uio(sc->sc_dmat, map, uio, flags)); 636 } 637 638 int 639 uturn_dmamap_load_raw(void *v, bus_dmamap_t map, bus_dma_segment_t *segs, 640 int nsegs, bus_size_t size, int flags) 641 { 642 struct uturn_softc *sc = v; 643 644 printf("load_raw\n"); 645 646 return (bus_dmamap_load_raw(sc->sc_dmat, map, segs, nsegs, size, flags)); 647 } 648 649 void 650 uturn_dmamap_unload(void *v, bus_dmamap_t map) 651 { 652 struct uturn_softc *sc = v; 653 struct uturn_map_state *ums = map->_dm_cookie; 654 struct uturn_page_map *upm = &ums->ums_map; 655 struct uturn_page_entry *e; 656 int err, i, s; 657 658 /* Remove the IOMMU entries. */ 659 for (i = 0, e = upm->upm_map; i < upm->upm_pagecnt; ++i, ++e) 660 uturn_iommu_remove(sc, e->upe_iova, PAGE_SIZE); 661 662 /* Clear the iomap. */ 663 uturn_iomap_clear_pages(ums); 664 665 bus_dmamap_unload(sc->sc_dmat, map); 666 667 s = splhigh(); 668 err = extent_free(sc->sc_map, ums->ums_iovastart, 669 ums->ums_iovasize, EX_NOWAIT); 670 ums->ums_iovastart = 0; 671 ums->ums_iovasize = 0; 672 splx(s); 673 if (err) 674 printf("warning: %ld of IOVA space lost\n", ums->ums_iovasize); 675 } 676 677 void 678 uturn_dmamap_sync(void *v, bus_dmamap_t map, bus_addr_t off, 679 bus_size_t len, int ops) 680 { 681 /* Nothing to do; DMA is cache-coherent. */ 682 } 683 684 int 685 uturn_dmamem_alloc(void *v, bus_size_t size, bus_size_t alignment, 686 bus_size_t boundary, bus_dma_segment_t *segs, 687 int nsegs, int *rsegs, int flags) 688 { 689 struct uturn_softc *sc = v; 690 691 return (bus_dmamem_alloc(sc->sc_dmat, size, alignment, boundary, 692 segs, nsegs, rsegs, flags)); 693 } 694 695 void 696 uturn_dmamem_free(void *v, bus_dma_segment_t *segs, int nsegs) 697 { 698 struct uturn_softc *sc = v; 699 700 bus_dmamem_free(sc->sc_dmat, segs, nsegs); 701 } 702 703 int 704 uturn_dmamem_map(void *v, bus_dma_segment_t *segs, int nsegs, size_t size, 705 void **kvap, int flags) 706 { 707 struct uturn_softc *sc = v; 708 709 return (bus_dmamem_map(sc->sc_dmat, segs, nsegs, size, kvap, flags)); 710 } 711 712 void 713 uturn_dmamem_unmap(void *v, void *kva, size_t size) 714 { 715 struct uturn_softc *sc = v; 716 717 bus_dmamem_unmap(sc->sc_dmat, kva, size); 718 } 719 720 paddr_t 721 uturn_dmamem_mmap(void *v, bus_dma_segment_t *segs, int nsegs, off_t off, 722 int prot, int flags) 723 { 724 struct uturn_softc *sc = v; 725 726 return (bus_dmamem_mmap(sc->sc_dmat, segs, nsegs, off, prot, flags)); 727 } 728 729 /* 730 * Utility function used by splay tree to order page entries by pa. 731 */ 732 static inline int 733 upe_compare(struct uturn_page_entry *a, struct uturn_page_entry *b) 734 { 735 return ((a->upe_pa > b->upe_pa) ? 1 : 736 (a->upe_pa < b->upe_pa) ? -1 : 0); 737 } 738 739 SPLAY_PROTOTYPE(uturn_page_tree, uturn_page_entry, upe_node, upe_compare); 740 741 SPLAY_GENERATE(uturn_page_tree, uturn_page_entry, upe_node, upe_compare); 742 743 /* 744 * Create a new iomap. 745 */ 746 struct uturn_map_state * 747 uturn_iomap_create(int n, int flags) 748 { 749 struct uturn_map_state *ums; 750 751 /* Safety for heavily fragmented data, such as mbufs */ 752 n += 4; 753 if (n < 16) 754 n = 16; 755 const size_t sz = 756 sizeof(*ums) + (n - 1) * sizeof(ums->ums_map.upm_map[0]); 757 ums = kmem_zalloc(sz, (flags & BUS_DMA_NOWAIT) ? KM_NOSLEEP : KM_SLEEP); 758 if (ums == NULL) 759 return (NULL); 760 761 /* Initialize the map. */ 762 ums->ums_map.upm_maxpage = n; 763 SPLAY_INIT(&ums->ums_map.upm_tree); 764 765 return (ums); 766 } 767 768 /* 769 * Destroy an iomap. 770 */ 771 void 772 uturn_iomap_destroy(struct uturn_map_state *ums) 773 { 774 KASSERT(ums->ums_map.upm_pagecnt == 0); 775 const int n = ums->ums_map.upm_maxpage; 776 const size_t sz = 777 sizeof(*ums) + (n - 1) * sizeof(ums->ums_map.upm_map[0]); 778 779 kmem_free(ums, sz); 780 } 781 782 /* 783 * Insert a pa entry in the iomap. 784 */ 785 int 786 uturn_iomap_insert_page(struct uturn_map_state *ums, vaddr_t va, paddr_t pa) 787 { 788 struct uturn_page_map *upm = &ums->ums_map; 789 struct uturn_page_entry *e; 790 791 if (upm->upm_pagecnt >= upm->upm_maxpage) { 792 struct uturn_page_entry upe; 793 794 upe.upe_pa = pa; 795 if (SPLAY_FIND(uturn_page_tree, &upm->upm_tree, &upe)) 796 return (0); 797 798 return (ENOMEM); 799 } 800 801 e = &upm->upm_map[upm->upm_pagecnt]; 802 803 e->upe_pa = pa; 804 e->upe_va = va; 805 e->upe_iova = 0; 806 807 e = SPLAY_INSERT(uturn_page_tree, &upm->upm_tree, e); 808 809 /* Duplicates are okay, but only count them once. */ 810 if (e) 811 return (0); 812 813 ++upm->upm_pagecnt; 814 815 return (0); 816 } 817 818 /* 819 * Translate a physical address (pa) into a IOVA address. 820 */ 821 bus_addr_t 822 uturn_iomap_translate(struct uturn_map_state *ums, paddr_t pa) 823 { 824 struct uturn_page_map *upm = &ums->ums_map; 825 struct uturn_page_entry *e; 826 struct uturn_page_entry pe; 827 paddr_t offset = pa & PAGE_MASK; 828 829 pe.upe_pa = trunc_page(pa); 830 831 e = SPLAY_FIND(uturn_page_tree, &upm->upm_tree, &pe); 832 833 if (e == NULL) { 834 panic("couldn't find pa %lx\n", pa); 835 return 0; 836 } 837 838 return (e->upe_iova | offset); 839 } 840 841 /* 842 * Clear the iomap table and tree. 843 */ 844 void 845 uturn_iomap_clear_pages(struct uturn_map_state *ums) 846 { 847 ums->ums_map.upm_pagecnt = 0; 848 SPLAY_INIT(&ums->ums_map.upm_tree); 849 } 850
Indexes created Mon Sep 22 21:09:42 GMT 2025