sys/arch/sun3/sun3x/dvma.c

   1 /*      $NetBSD: dvma.c,v 1.39 2009/11/10 17:37:15 he Exp $     */
   2
   3 /*-
   4  * Copyright (c) 1996 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Gordon W. Ross and Jeremy Cooper.
   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 /*
  33  * DVMA (Direct Virtual Memory Access - like DMA)
  34  *
  35  * In the Sun3 architecture, memory cycles initiated by secondary bus
  36  * masters (DVMA devices) passed through the same MMU that governed CPU
  37  * accesses.  All DVMA devices were wired in such a way so that an offset
  38  * was added to the addresses they issued, causing them to access virtual
  39  * memory starting at address 0x0FF00000 - the offset.  The task of
  40  * enabling a DVMA device to access main memory only involved creating
  41  * valid mapping in the MMU that translated these high addresses into the
  42  * appropriate physical addresses.
  43  *
  44  * The Sun3x presents a challenge to programming DVMA because the MMU is no
  45  * longer shared by both secondary bus masters and the CPU.  The MC68030's
  46  * built-in MMU serves only to manage virtual memory accesses initiated by
  47  * the CPU.  Secondary bus master bus accesses pass through a different MMU,
  48  * aptly named the 'I/O Mapper'.  To enable every device driver that uses
  49  * DVMA to understand that these two address spaces are disconnected would
  50  * require a tremendous amount of code re-writing. To avoid this, we will
  51  * ensure that the I/O Mapper and the MC68030 MMU are programmed together,
  52  * so that DVMA mappings are consistent in both the CPU virtual address
  53  * space and secondary bus master address space - creating an environment
  54  * just like the Sun3 system.
  55  *
  56  * The maximum address space that any DVMA device in the Sun3x architecture
  57  * is capable of addressing is 24 bits wide (16 Megabytes.)  We can alias
  58  * all of the mappings that exist in the I/O mapper by duplicating them in
  59  * a specially reserved section of the CPU's virtual address space, 16
  60  * Megabytes in size.  Whenever a DVMA buffer is allocated, the allocation
  61  * code will enter in a mapping both in the MC68030 MMU page tables and the
  62  * I/O mapper.
  63  *
  64  * The address returned by the allocation routine is a virtual address that
  65  * the requesting driver must use to access the buffer.  It is up to the
  66  * device driver to convert this virtual address into the appropriate slave
  67  * address that its device should issue to access the buffer.  (There will be
  68  * routines that assist the driver in doing so.)
  69  */
  70
  71 #include <sys/cdefs.h>
  72 __KERNEL_RCSID(0, "$NetBSD: dvma.c,v 1.39 2009/11/10 17:37:15 he Exp $");
  73
  74 #include <sys/param.h>
  75 #include <sys/systm.h>
  76 #include <sys/device.h>
  77 #include <sys/proc.h>
  78 #include <sys/malloc.h>
  79 #include <sys/extent.h>
  80 #include <sys/buf.h>
  81 #include <sys/vnode.h>
  82 #include <sys/core.h>
  83 #include <sys/exec.h>
  84
  85 #include <uvm/uvm_extern.h>
  86
  87 #define _SUN68K_BUS_DMA_PRIVATE
  88 #include <machine/autoconf.h>
  89 #include <machine/bus.h>
  90 #include <machine/cpu.h>
  91 #include <machine/dvma.h>
  92 #include <machine/pmap.h>
  93
  94 #include <sun3/sun3/machdep.h>
  95
  96 #include <sun3/sun3x/enable.h>
  97 #include <sun3/sun3x/iommu.h>
  98
  99 /*
 100  * Use an extent map to manage DVMA scratch-memory pages.
 101  * Note: SunOS says last three pages are reserved (PROM?)
 102  * Note: need a separate map (sub-map?) for last 1MB for
 103  *       use by VME slave interface.
 104  */
 105
 106 /* Number of slots in dvmamap. */
 107 struct extent *dvma_extent;
 108
 109 void
 110 dvma_init(void)
 111 {
 112
 113         /*
 114          * Create the extent map for DVMA pages.
 115          */
 116         dvma_extent = extent_create("dvma", DVMA_MAP_BASE,
 117             DVMA_MAP_BASE + (DVMA_MAP_AVAIL - 1), M_DEVBUF,
 118             NULL, 0, EX_NOCOALESCE|EX_NOWAIT);
 119
 120         /*
 121          * Enable DVMA in the System Enable register.
 122          * Note:  This is only necessary for VME slave accesses.
 123          *        On-board devices are always capable of DVMA.
 124          */
 125         *enable_reg |= ENA_SDVMA;
 126 }
 127
 128
 129 /*
 130  * Given a DVMA address, return the physical address that
 131  * would be used by some OTHER bus-master besides the CPU.
 132  * (Examples: on-board ie/le, VME xy board).
 133  */
 134 u_long
 135 dvma_kvtopa(void *kva, int bustype)
 136 {
 137         u_long addr, mask;
 138
 139         addr = (u_long)kva;
 140         if ((addr & DVMA_MAP_BASE) != DVMA_MAP_BASE)
 141                 panic("dvma_kvtopa: bad dmva addr=0x%lx", addr);
 142
 143         switch (bustype) {
 144         case BUS_OBIO:
 145         case BUS_OBMEM:
 146                 mask = DVMA_OBIO_SLAVE_MASK;
 147                 break;
 148         default:        /* VME bus device. */
 149                 mask = DVMA_VME_SLAVE_MASK;
 150                 break;
 151         }
 152
 153         return addr & mask;
 154 }
 155
 156
 157 /*
 158  * Map a range [va, va+len] of wired virtual addresses in the given map
 159  * to a kernel address in DVMA space.
 160  */
 161 void *
 162 dvma_mapin(void *kmem_va, int len, int canwait)
 163 {
 164         void *dvma_addr;
 165         vaddr_t kva, tva;
 166         int npf, s, error;
 167         paddr_t pa;
 168         long off;
 169         bool rv;
 170
 171         kva = (vaddr_t)kmem_va;
 172 #ifdef  DIAGNOSTIC
 173         /*
 174          * Addresses below VM_MIN_KERNEL_ADDRESS are not part of the kernel
 175          * map and should not participate in DVMA.
 176          */
 177         if (kva < VM_MIN_KERNEL_ADDRESS)
 178                 panic("dvma_mapin: bad kva");
 179 #endif
 180
 181         /*
 182          * Calculate the offset of the data buffer from a page boundary.
 183          */
 184         off = kva & PGOFSET;
 185         kva -= off;     /* Truncate starting address to nearest page. */
 186         len = round_page(len + off); /* Round the buffer length to pages. */
 187         npf = btoc(len); /* Determine the number of pages to be mapped. */
 188
 189         /*
 190          * Try to allocate DVMA space of the appropriate size
 191          * in which to do a transfer.
 192          */
 193         s = splvm();
 194         error = extent_alloc(dvma_extent, len, PAGE_SIZE, 0,
 195             EX_FAST | EX_NOWAIT | (canwait ? EX_WAITSPACE : 0), &tva);
 196         splx(s);
 197         if (error)
 198                 return NULL;
 199
 200         /*
 201          * Tva is the starting page to which the data buffer will be double
 202          * mapped.  Dvma_addr is the starting address of the buffer within
 203          * that page and is the return value of the function.
 204          */
 205         dvma_addr = (void *)(tva + off);
 206
 207         for (; npf--; kva += PAGE_SIZE, tva += PAGE_SIZE) {
 208                 /*
 209                  * Retrieve the physical address of each page in the buffer
 210                  * and enter mappings into the I/O MMU so they may be seen
 211                  * by external bus masters and into the special DVMA space
 212                  * in the MC68030 MMU so they may be seen by the CPU.
 213                  */
 214                 rv = pmap_extract(pmap_kernel(), kva, &pa);
 215 #ifdef  DEBUG
 216                 if (rv == false)
 217                         panic("dvma_mapin: null page frame");
 218 #endif  /* DEBUG */
 219
 220                 iommu_enter((tva & IOMMU_VA_MASK), pa);
 221                 pmap_kenter_pa(tva,
 222                     pa | PMAP_NC, VM_PROT_READ | VM_PROT_WRITE, 0);
 223         }
 224         pmap_update(pmap_kernel());
 225
 226         return dvma_addr;
 227 }
 228
 229 /*
 230  * Remove double map of `va' in DVMA space at `kva'.
 231  *
 232  * TODO - This function might be the perfect place to handle the
 233  *       synchronization between the DVMA cache and central RAM
 234  *       on the 3/470.
 235  */
 236 void
 237 dvma_mapout(void *dvma_addr, int len)
 238 {
 239         u_long kva;
 240         int s, off;
 241
 242         kva = (u_long)dvma_addr;
 243         off = (int)kva & PGOFSET;
 244         kva -= off;
 245         len = round_page(len + off);
 246
 247         iommu_remove((kva & IOMMU_VA_MASK), len);
 248         pmap_kremove(kva, len);
 249         pmap_update(pmap_kernel());
 250
 251         s = splvm();
 252         if (extent_free(dvma_extent, kva, len, EX_NOWAIT | EX_MALLOCOK))
 253                 panic("dvma_mapout: unable to free region: 0x%lx,0x%x",
 254                     kva, len);
 255         splx(s);
 256 }
 257
 258 /*
 259  * Allocate actual memory pages in DVMA space.
 260  * (For sun3 compatibility - the ie driver.)
 261  */
 262 void *
 263 dvma_malloc(size_t bytes)
 264 {
 265         void *new_mem, *dvma_mem;
 266         vsize_t new_size;
 267
 268         if (bytes == 0)
 269                 return NULL;
 270         new_size = m68k_round_page(bytes);
 271         new_mem = (void *)uvm_km_alloc(kernel_map, new_size, 0, UVM_KMF_WIRED);
 272         if (new_mem == 0)
 273                 return NULL;
 274         dvma_mem = dvma_mapin(new_mem, new_size, 1);
 275         return dvma_mem;
 276 }
 277
 278 /*
 279  * Free pages from dvma_malloc()
 280  */
 281 void
 282 dvma_free(void *addr, size_t size)
 283 {
 284         vsize_t sz = m68k_round_page(size);
 285
 286         dvma_mapout(addr, sz);
 287         /* XXX: need kmem address to free it...
 288            Oh well, we never call this anyway. */
 289 }
 290
 291 int
 292 _bus_dmamap_load_raw(bus_dma_tag_t t, bus_dmamap_t map, bus_dma_segment_t *segs,
 293     int nsegs, bus_size_t size, int flags)
 294 {
 295
 296         panic("_bus_dmamap_load_raw(): not implemented yet.");
 297 }
 298
 299 int
 300 _bus_dmamap_load(bus_dma_tag_t t, bus_dmamap_t map, void *buf,
 301     bus_size_t buflen, struct proc *p, int flags)
 302 {
 303         vaddr_t kva, dva;
 304         vsize_t off, sgsize;
 305         paddr_t pa;
 306         pmap_t pmap;
 307         int error, rv, s;
 308
 309         /*
 310          * Make sure that on error condition we return "no valid mappings".
 311          */
 312         map->dm_nsegs = 0;
 313         map->dm_mapsize = 0;
 314
 315         if (buflen > map->_dm_size)
 316                 return EINVAL;
 317
 318         kva = (vaddr_t)buf;
 319         off = kva & PGOFSET;
 320         sgsize = round_page(off + buflen);
 321
 322         /* Try to allocate DVMA space. */
 323         s = splvm();
 324         error = extent_alloc(dvma_extent, sgsize, PAGE_SIZE, 0,
 325             EX_FAST | ((flags & BUS_DMA_NOWAIT) == 0 ? EX_WAITOK : EX_NOWAIT),
 326             &dva);
 327         splx(s);
 328         if (error)
 329                 return ENOMEM;
 330
 331         /* Fill in the segment. */
 332         map->dm_segs[0].ds_addr = dva + off;
 333         map->dm_segs[0].ds_len = buflen;
 334         map->dm_segs[0]._ds_va = dva;
 335         map->dm_segs[0]._ds_sgsize = sgsize;
 336
 337         /*
 338          * Now map the DVMA addresses we allocated to point to the
 339          * pages of the caller's buffer.
 340          */
 341         if (p != NULL)
 342                 pmap = p->p_vmspace->vm_map.pmap;
 343         else
 344                 pmap = pmap_kernel();
 345
 346         while (sgsize > 0) {
 347                 rv = pmap_extract(pmap, kva, &pa);
 348 #ifdef DIAGNOSTIC
 349                 if (rv == false)
 350                         panic("%s: unmapped VA", __func__);
 351 #endif
 352                 iommu_enter((dva & IOMMU_VA_MASK), pa);
 353                 pmap_kenter_pa(dva,
 354                     pa | PMAP_NC, VM_PROT_READ | VM_PROT_WRITE, 0);
 355                 kva += PAGE_SIZE;
 356                 dva += PAGE_SIZE;
 357                 sgsize -= PAGE_SIZE;
 358         }
 359
 360         map->dm_nsegs = 1;
 361         map->dm_mapsize = map->dm_segs[0].ds_len;
 362
 363         return 0;
 364 }
 365
 366 void
 367 _bus_dmamap_unload(bus_dma_tag_t t, bus_dmamap_t map)
 368 {
 369         bus_dma_segment_t *segs;
 370         vaddr_t dva;
 371         vsize_t sgsize;
 372         int error, s;
 373
 374 #ifdef DIAGNOSTIC
 375         if (map->dm_nsegs != 1)
 376                 panic("%s: invalid nsegs = %d", __func__, map->dm_nsegs);
 377 #endif
 378
 379         segs = map->dm_segs;
 380         dva = segs[0]._ds_va & ~PGOFSET;
 381         sgsize = segs[0]._ds_sgsize;
 382
 383         /* Unmap the DVMA addresses. */
 384         iommu_remove((dva & IOMMU_VA_MASK), sgsize);
 385         pmap_kremove(dva, sgsize);
 386         pmap_update(pmap_kernel());
 387
 388         /* Free the DVMA addresses. */
 389         s = splvm();
 390         error = extent_free(dvma_extent, dva, sgsize, EX_NOWAIT);
 391         splx(s);
 392 #ifdef DIAGNOSTIC
 393         if (error)
 394                 panic("%s: unable to free DVMA region", __func__);
 395 #endif
 396
 397         /* Mark the mappings as invalid. */
 398         map->dm_mapsize = 0;
 399         map->dm_nsegs = 0;
 400 }