1 /* $NetBSD: gapspci_dma.c,v 1.7 2002/06/02 14:44:44 drochner Exp $ */ 2 3 /*- 4 * Copyright (c) 2001 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe. 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 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 /* 40 * Bus DMA implementation for the SEGA GAPS PCI bridge. 41 * 42 * NOTE: We only implement a small subset of what the bus_space(9) 43 * API specifies. Right now, the GAPS PCI bridge is only used for 44 * the Dreamcast Broadband Adatper, so we only provide what the 45 * pci(4) and rtk(4) drivers need. 46 */ 47 48 #include <sys/cdefs.h> /* RCS ID & Copyright macro defns */ 49 50 #include <sys/param.h> 51 #include <sys/systm.h> 52 #include <sys/device.h> 53 #include <sys/mbuf.h> 54 #include <sys/extent.h> 55 #include <sys/malloc.h> 56 57 #include <machine/cpu.h> 58 #include <machine/bus.h> 59 60 #include <dev/pci/pcivar.h> 61 62 #include <dreamcast/dev/g2/gapspcivar.h> 63 64 #include <uvm/uvm_extern.h> 65 66 int gaps_dmamap_create(bus_dma_tag_t, bus_size_t, int, bus_size_t, 67 bus_size_t, int, bus_dmamap_t *); 68 void gaps_dmamap_destroy(bus_dma_tag_t, bus_dmamap_t); 69 int gaps_dmamap_load(bus_dma_tag_t, bus_dmamap_t, void *, bus_size_t, 70 struct proc *, int); 71 int gaps_dmamap_load_mbuf(bus_dma_tag_t, bus_dmamap_t, struct mbuf *, int); 72 int gaps_dmamap_load_uio(bus_dma_tag_t, bus_dmamap_t, struct uio *, int); 73 int gaps_dmamap_load_raw(bus_dma_tag_t, bus_dmamap_t, bus_dma_segment_t *, 74 int, bus_size_t, int); 75 void gaps_dmamap_unload(bus_dma_tag_t, bus_dmamap_t); 76 void gaps_dmamap_sync(bus_dma_tag_t, bus_dmamap_t, bus_addr_t, 77 bus_size_t, int); 78 79 int gaps_dmamem_alloc(bus_dma_tag_t tag, bus_size_t size, 80 bus_size_t alignment, bus_size_t boundary, bus_dma_segment_t *segs, 81 int nsegs, int *rsegs, int flags); 82 void gaps_dmamem_free(bus_dma_tag_t tag, bus_dma_segment_t *segs, int nsegs); 83 int gaps_dmamem_map(bus_dma_tag_t tag, bus_dma_segment_t *segs, int nsegs, 84 size_t size, caddr_t *kvap, int flags); 85 void gaps_dmamem_unmap(bus_dma_tag_t tag, caddr_t kva, size_t size); 86 paddr_t gaps_dmamem_mmap(bus_dma_tag_t tag, bus_dma_segment_t *segs, int nsegs, 87 off_t off, int prot, int flags); 88 89 void 90 gaps_dma_init(struct gaps_softc *sc) 91 { 92 bus_dma_tag_t t = &sc->sc_dmat; 93 94 memset(t, 0, sizeof(*t)); 95 96 t->_cookie = sc; 97 t->_dmamap_create = gaps_dmamap_create; 98 t->_dmamap_destroy = gaps_dmamap_destroy; 99 t->_dmamap_load = gaps_dmamap_load; 100 t->_dmamap_load_mbuf = gaps_dmamap_load_mbuf; 101 t->_dmamap_load_uio = gaps_dmamap_load_uio; 102 t->_dmamap_load_raw = gaps_dmamap_load_raw; 103 t->_dmamap_unload = gaps_dmamap_unload; 104 t->_dmamap_sync = gaps_dmamap_sync; 105 106 t->_dmamem_alloc = gaps_dmamem_alloc; 107 t->_dmamem_free = gaps_dmamem_free; 108 t->_dmamem_map = gaps_dmamem_map; 109 t->_dmamem_unmap = gaps_dmamem_unmap; 110 t->_dmamem_mmap = gaps_dmamem_mmap; 111 112 /* 113 * The GAPS PCI bridge has 32k of DMA memory. We manage it 114 * with an extent map. 115 */ 116 sc->sc_dma_ex = extent_create("gaps dma", 117 sc->sc_dmabase, sc->sc_dmabase + (sc->sc_dmasize - 1), 118 M_DEVBUF, NULL, 0, EX_WAITOK | EXF_NOCOALESCE); 119 120 if (bus_space_map(sc->sc_memt, sc->sc_dmabase, sc->sc_dmasize, 121 0, &sc->sc_dma_memh) != 0) 122 panic("gaps_dma_init: can't map SRAM buffer"); 123 } 124 125 /* 126 * A GAPS DMA map -- has the standard DMA map, plus some extra 127 * housekeeping data. 128 */ 129 struct gaps_dmamap { 130 struct dreamcast_bus_dmamap gd_dmamap; 131 void *gd_origbuf; 132 int gd_buftype; 133 }; 134 135 #define GAPS_DMA_BUFTYPE_INVALID 0 136 #define GAPS_DMA_BUFTYPE_LINEAR 1 137 #define GAPS_DMA_BUFTYPE_MBUF 2 138 139 int 140 gaps_dmamap_create(bus_dma_tag_t t, bus_size_t size, int nsegments, 141 bus_size_t maxsegsz, bus_size_t boundary, int flags, bus_dmamap_t *dmamap) 142 { 143 struct gaps_softc *sc = t->_cookie; 144 struct gaps_dmamap *gmap; 145 bus_dmamap_t map; 146 147 /* 148 * Allocate an initialize the DMA map. The end of the map is 149 * a variable-sized array of segments, so we allocate enough 150 * room for them in one shot. Since the DMA map always includes 151 * one segment, and we only support one segment, this is really 152 * easy. 153 * 154 * Note we don't preserve the WAITOK or NOWAIT flags. Preservation 155 * of ALLOCNOW notifies others that we've reserved these resources 156 * and they are not to be freed. 157 */ 158 159 gmap = malloc(sizeof(*gmap), M_DMAMAP, 160 (flags & BUS_DMA_NOWAIT) ? M_NOWAIT : M_WAITOK); 161 if (gmap == NULL) 162 return (ENOMEM); 163 164 memset(gmap, 0, sizeof(*gmap)); 165 166 gmap->gd_buftype = GAPS_DMA_BUFTYPE_INVALID; 167 168 map = &gmap->gd_dmamap; 169 170 map->_dm_size = size; 171 map->_dm_segcnt = 1; 172 map->_dm_maxsegsz = maxsegsz; 173 map->_dm_boundary = boundary; 174 map->_dm_flags = flags & ~(BUS_DMA_WAITOK|BUS_DMA_NOWAIT); 175 176 if (flags & BUS_DMA_ALLOCNOW) { 177 u_long res; 178 int error; 179 180 error = extent_alloc(sc->sc_dma_ex, size, 1024 /* XXX */, 181 map->_dm_boundary, 182 (flags & BUS_DMA_NOWAIT) ? EX_NOWAIT : EX_WAITOK, &res); 183 if (error) { 184 free(gmap, M_DEVBUF); 185 return (error); 186 } 187 188 map->dm_segs[0].ds_addr = res; 189 map->dm_segs[0].ds_len = size; 190 191 map->dm_mapsize = size; 192 map->dm_nsegs = 1; 193 } else { 194 map->dm_mapsize = 0; /* no valid mappings */ 195 map->dm_nsegs = 0; 196 } 197 198 *dmamap = map; 199 200 return (0); 201 } 202 203 void 204 gaps_dmamap_destroy(bus_dma_tag_t t, bus_dmamap_t map) 205 { 206 struct gaps_softc *sc = t->_cookie; 207 208 if (map->_dm_flags & BUS_DMA_ALLOCNOW) { 209 (void) extent_free(sc->sc_dma_ex, 210 map->dm_segs[0].ds_addr, 211 map->dm_mapsize, EX_NOWAIT); 212 } 213 free(map, M_DMAMAP); 214 } 215 216 int 217 gaps_dmamap_load(bus_dma_tag_t t, bus_dmamap_t map, void *addr, 218 bus_size_t size, struct proc *p, int flags) 219 { 220 struct gaps_softc *sc = t->_cookie; 221 struct gaps_dmamap *gmap = (void *) map; 222 u_long res; 223 int error; 224 225 if ((map->_dm_flags & BUS_DMA_ALLOCNOW) == 0) { 226 /* 227 * Make sure that on error condition we return 228 * "no valid mappings". 229 */ 230 map->dm_mapsize = 0; 231 map->dm_nsegs = 0; 232 } 233 234 /* XXX Don't support DMA to process space right now. */ 235 if (p != NULL) 236 return (EINVAL); 237 238 if (size > map->_dm_size) 239 return (EINVAL); 240 241 error = extent_alloc(sc->sc_dma_ex, size, 1024 /* XXX */, 242 map->_dm_boundary, 243 (flags & BUS_DMA_NOWAIT) ? EX_NOWAIT : EX_WAITOK, &res); 244 if (error) 245 return (error); 246 247 map->dm_segs[0].ds_addr = res; 248 map->dm_segs[0].ds_len = size; 249 250 gmap->gd_origbuf = addr; 251 gmap->gd_buftype = GAPS_DMA_BUFTYPE_LINEAR; 252 253 map->dm_mapsize = size; 254 map->dm_nsegs = 1; 255 256 return (0); 257 } 258 259 int 260 gaps_dmamap_load_mbuf(bus_dma_tag_t t, bus_dmamap_t map, struct mbuf *m0, 261 int flags) 262 { 263 struct gaps_softc *sc = t->_cookie; 264 struct gaps_dmamap *gmap = (void *) map; 265 u_long res; 266 int error; 267 268 if ((map->_dm_flags & BUS_DMA_ALLOCNOW) == 0) { 269 /* 270 * Make sure that on error condition we return 271 * "no valid mappings". 272 */ 273 map->dm_mapsize = 0; 274 map->dm_nsegs = 0; 275 } 276 277 #ifdef DIAGNOSTIC 278 if ((m0->m_flags & M_PKTHDR) == 0) 279 panic("gaps_dmamap_load_mbuf: no packet header"); 280 #endif 281 282 if (m0->m_pkthdr.len > map->_dm_size) 283 return (EINVAL); 284 285 error = extent_alloc(sc->sc_dma_ex, m0->m_pkthdr.len, 1024 /* XXX */, 286 map->_dm_boundary, 287 (flags & BUS_DMA_NOWAIT) ? EX_NOWAIT : EX_WAITOK, &res); 288 if (error) 289 return (error); 290 291 map->dm_segs[0].ds_addr = res; 292 map->dm_segs[0].ds_len = m0->m_pkthdr.len; 293 294 gmap->gd_origbuf = m0; 295 gmap->gd_buftype = GAPS_DMA_BUFTYPE_MBUF; 296 297 map->dm_mapsize = m0->m_pkthdr.len; 298 map->dm_nsegs = 1; 299 300 return (0); 301 } 302 303 int 304 gaps_dmamap_load_uio(bus_dma_tag_t t, bus_dmamap_t map, struct uio *uio, 305 int flags) 306 { 307 308 printf("gaps_dmamap_load_uio: not implemented\n"); 309 return (EINVAL); 310 } 311 312 int 313 gaps_dmamap_load_raw(bus_dma_tag_t t, bus_dmamap_t map, 314 bus_dma_segment_t *segs, int nsegs, bus_size_t size, int flags) 315 { 316 317 printf("gaps_dmamap_load_raw: not implemented\n"); 318 return (EINVAL); 319 } 320 321 void 322 gaps_dmamap_unload(bus_dma_tag_t t, bus_dmamap_t map) 323 { 324 struct gaps_softc *sc = t->_cookie; 325 struct gaps_dmamap *gmap = (void *) map; 326 327 if (gmap->gd_buftype == GAPS_DMA_BUFTYPE_INVALID) { 328 printf("gaps_dmamap_unload: DMA map not loaded!\n"); 329 return; 330 } 331 332 if ((map->_dm_flags & BUS_DMA_ALLOCNOW) == 0) { 333 (void) extent_free(sc->sc_dma_ex, 334 map->dm_segs[0].ds_addr, 335 map->dm_mapsize, EX_NOWAIT); 336 337 map->dm_mapsize = 0; 338 map->dm_nsegs = 0; 339 } 340 341 gmap->gd_buftype = GAPS_DMA_BUFTYPE_INVALID; 342 } 343 344 void 345 gaps_dmamap_sync(bus_dma_tag_t t, bus_dmamap_t map, bus_addr_t offset, 346 bus_size_t len, int ops) 347 { 348 struct gaps_softc *sc = t->_cookie; 349 struct gaps_dmamap *gmap = (void *) map; 350 bus_addr_t dmaoff = map->dm_segs[0].ds_addr - sc->sc_dmabase; 351 352 /* 353 * Mixing PRE and POST operations is not allowed. 354 */ 355 if ((ops & (BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE)) != 0 && 356 (ops & (BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE)) != 0) 357 panic("gaps_dmamap_sync: mix PRE and POST"); 358 359 #ifdef DIAGNOSTIC 360 if ((ops & (BUS_DMASYNC_PREWRITE|BUS_DMASYNC_POSTREAD)) != 0) { 361 if (offset >= map->dm_mapsize) { 362 printf("offset 0x%lx mapsize 0x%lx\n", 363 offset, map->dm_mapsize); 364 panic("gaps_dmamap_sync: bad offset"); 365 } 366 if (len == 0 || (offset + len) > map->dm_mapsize) { 367 printf("len 0x%lx offset 0x%lx mapsize 0x%lx\n", 368 len, offset, map->dm_mapsize); 369 panic("gaps_dmamap_sync: bad length"); 370 } 371 } 372 #endif 373 374 switch (gmap->gd_buftype) { 375 case GAPS_DMA_BUFTYPE_INVALID: 376 printf("gaps_dmamap_sync: DMA map is not loaded!\n"); 377 return; 378 379 case GAPS_DMA_BUFTYPE_LINEAR: 380 /* 381 * Nothing to do for pre-read. 382 */ 383 384 if (ops & BUS_DMASYNC_PREWRITE) { 385 /* 386 * Copy the caller's buffer to the SRAM buffer. 387 */ 388 bus_space_write_region_1(sc->sc_memt, 389 sc->sc_dma_memh, 390 dmaoff + offset, 391 (u_int8_t *)gmap->gd_origbuf + offset, len); 392 } 393 394 if (ops & BUS_DMASYNC_POSTREAD) { 395 /* 396 * Copy the SRAM buffer to the caller's buffer. 397 */ 398 bus_space_read_region_1(sc->sc_memt, 399 sc->sc_dma_memh, 400 dmaoff + offset, 401 (u_int8_t *)gmap->gd_origbuf + offset, len); 402 } 403 404 /* 405 * Nothing to do for post-write. 406 */ 407 break; 408 409 case GAPS_DMA_BUFTYPE_MBUF: 410 { 411 struct mbuf *m, *m0 = gmap->gd_origbuf; 412 bus_size_t minlen, moff; 413 414 /* 415 * Nothing to do for pre-read. 416 */ 417 418 if (ops & BUS_DMASYNC_PREWRITE) { 419 /* 420 * Copy the caller's buffer into the SRAM buffer. 421 */ 422 for (moff = offset, m = m0; m != NULL && len != 0; 423 m = m->m_next) { 424 /* Find the beginning mbuf. */ 425 if (moff >= m->m_len) { 426 moff -= m->m_len; 427 continue; 428 } 429 430 /* 431 * Now at the first mbuf to sync; nail 432 * each one until we have exhausted the 433 * length. 434 */ 435 minlen = len < m->m_len - moff ? 436 len : m->m_len - moff; 437 438 bus_space_write_region_1(sc->sc_memt, 439 sc->sc_dma_memh, dmaoff + offset, 440 mtod(m, u_int8_t *) + moff, minlen); 441 442 moff = 0; 443 len -= minlen; 444 offset += minlen; 445 } 446 } 447 448 if (ops & BUS_DMASYNC_POSTREAD) { 449 /* 450 * Copy the SRAM buffer into the caller's buffer. 451 */ 452 for (moff = offset, m = m0; m != NULL && len != 0; 453 m = m->m_next) { 454 /* Find the beginning mbuf. */ 455 if (moff >= m->m_len) { 456 moff -= m->m_len; 457 continue; 458 } 459 460 /* 461 * Now at the first mbuf to sync; nail 462 * each one until we have exhausted the 463 * length. 464 */ 465 minlen = len < m->m_len - moff ? 466 len : m->m_len - moff; 467 468 bus_space_read_region_1(sc->sc_memt, 469 sc->sc_dma_memh, dmaoff + offset, 470 mtod(m, u_int8_t *) + moff, minlen); 471 472 moff = 0; 473 len -= minlen; 474 offset += minlen; 475 } 476 } 477 478 /* 479 * Nothing to do for post-write. 480 */ 481 break; 482 } 483 484 default: 485 printf("unknown buffer type %d\n", gmap->gd_buftype); 486 panic("gaps_dmamap_sync"); 487 } 488 } 489 490 int 491 gaps_dmamem_alloc(bus_dma_tag_t t, bus_size_t size, bus_size_t alignment, 492 bus_size_t boundary, bus_dma_segment_t *segs, int nsegs, int *rsegs, 493 int flags) 494 { 495 extern paddr_t avail_start, avail_end; /* from pmap.c */ 496 497 struct pglist mlist; 498 paddr_t curaddr, lastaddr; 499 struct vm_page *m; 500 int curseg, error; 501 502 /* Always round the size. */ 503 size = round_page(size); 504 505 /* 506 * Allocate the pages from the VM system. 507 */ 508 error = uvm_pglistalloc(size, avail_start, avail_end - PAGE_SIZE, 509 alignment, boundary, &mlist, nsegs, (flags & BUS_DMA_NOWAIT) == 0); 510 if (error) 511 return (error); 512 513 /* 514 * Compute the location, size, and number of segments actually 515 * returned by the VM code. 516 */ 517 m = mlist.tqh_first; 518 curseg = 0; 519 lastaddr = segs[curseg].ds_addr = VM_PAGE_TO_PHYS(m); 520 segs[curseg].ds_len = PAGE_SIZE; 521 m = TAILQ_NEXT(m, pageq); 522 523 for (; m != NULL; m = TAILQ_NEXT(m, pageq)) { 524 curaddr = VM_PAGE_TO_PHYS(m); 525 if (curaddr == (lastaddr + PAGE_SIZE)) 526 segs[curseg].ds_len += PAGE_SIZE; 527 else { 528 curseg++; 529 segs[curseg].ds_addr = curaddr; 530 segs[curseg].ds_len = PAGE_SIZE; 531 } 532 lastaddr = curaddr; 533 } 534 535 *rsegs = curseg + 1; 536 537 return (0); 538 } 539 540 void 541 gaps_dmamem_free(bus_dma_tag_t t, bus_dma_segment_t *segs, int nsegs) 542 { 543 struct pglist mlist; 544 struct vm_page *m; 545 bus_addr_t addr; 546 int curseg; 547 548 /* 549 * Build a list of pages to free back to the VM system. 550 */ 551 TAILQ_INIT(&mlist); 552 for (curseg = 0; curseg < nsegs; curseg++) { 553 for (addr = segs[curseg].ds_addr; 554 addr < segs[curseg].ds_addr + segs[curseg].ds_len; 555 addr += PAGE_SIZE) { 556 m = PHYS_TO_VM_PAGE(addr); 557 TAILQ_INSERT_TAIL(&mlist, m, pageq); 558 } 559 } 560 561 uvm_pglistfree(&mlist); 562 } 563 564 int 565 gaps_dmamem_map(bus_dma_tag_t t, bus_dma_segment_t *segs, int nsegs, 566 size_t size, caddr_t *kvap, int flags) 567 { 568 vaddr_t va; 569 bus_addr_t addr; 570 int curseg; 571 572 /* 573 * If we're only mapping 1 segment, use P2SEG, to avoid 574 * TLB thrashing. 575 */ 576 if (nsegs == 1) { 577 *kvap = (caddr_t) SH3_PHYS_TO_P2SEG(segs[0].ds_addr); 578 return (0); 579 } 580 581 size = round_page(size); 582 583 va = uvm_km_valloc(kernel_map, size); 584 585 if (va == 0) 586 return (ENOMEM); 587 588 *kvap = (caddr_t) va; 589 590 for (curseg = 0; curseg < nsegs; curseg++) { 591 for (addr = segs[curseg].ds_addr; 592 addr < segs[curseg].ds_addr + segs[curseg].ds_len; 593 addr += PAGE_SIZE, va += PAGE_SIZE, size -= PAGE_SIZE) { 594 if (size == 0) 595 panic("gaps_dmamem_map: size botch"); 596 pmap_kenter_pa(va, addr, 597 VM_PROT_READ | VM_PROT_WRITE); 598 } 599 } 600 pmap_update(pmap_kernel()); 601 602 return (0); 603 } 604 605 void 606 gaps_dmamem_unmap(bus_dma_tag_t t, caddr_t kva, size_t size) 607 { 608 609 #ifdef DIAGNOSTIC 610 if ((u_long) kva & PAGE_MASK) 611 panic("gaps_dmamem_unmap"); 612 #endif 613 614 /* 615 * Nothing to do if we mapped it with P2SEG. 616 */ 617 if (kva >= (caddr_t) SH3_P2SEG_BASE && 618 kva <= (caddr_t) SH3_P2SEG_END) 619 return; 620 621 size = round_page(size); 622 pmap_kremove((vaddr_t) kva, size); 623 pmap_update(pmap_kernel()); 624 uvm_km_free(kernel_map, (vaddr_t) kva, size); 625 } 626 627 paddr_t 628 gaps_dmamem_mmap(bus_dma_tag_t t, bus_dma_segment_t *segs, int nsegs, 629 off_t off, int prot, int flags) 630 { 631 632 /* Not implemented. */ 633 return (-1); 634 } 635