dvma.c revision 1.9
1/* $NetBSD: dvma.c,v 1.9 1998/02/05 04:57:55 gwr 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 * 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 * DVMA (Direct Virtual Memory Access - like DMA) 41 * 42 * In the Sun3 architecture, memory cycles initiated by secondary bus 43 * masters (DVMA devices) passed through the same MMU that governed CPU 44 * accesses. All DVMA devices were wired in such a way so that an offset 45 * was added to the addresses they issued, causing them to access virtual 46 * memory starting at address 0x0FF00000 - the offset. The task of 47 * enabling a DVMA device to access main memory only involved creating 48 * valid mapping in the MMU that translated these high addresses into the 49 * appropriate physical addresses. 50 * 51 * The Sun3x presents a challenge to programming DVMA because the MMU is no 52 * longer shared by both secondary bus masters and the CPU. The MC68030's 53 * built-in MMU serves only to manage virtual memory accesses initiated by 54 * the CPU. Secondary bus master bus accesses pass through a different MMU, 55 * aptly named the 'I/O Mapper'. To enable every device driver that uses 56 * DVMA to understand that these two address spaces are disconnected would 57 * require a tremendous amount of code re-writing. To avoid this, we will 58 * ensure that the I/O Mapper and the MC68030 MMU are programmed together, 59 * so that DVMA mappings are consistent in both the CPU virtual address 60 * space and secondary bus master address space - creating an environment 61 * just like the Sun3 system. 62 * 63 * The maximum address space that any DVMA device in the Sun3x architecture 64 * is capable of addressing is 24 bits wide (16 Megabytes.) We can alias 65 * all of the mappings that exist in the I/O mapper by duplicating them in 66 * a specially reserved section of the CPU's virtual address space, 16 67 * Megabytes in size. Whenever a DVMA buffer is allocated, the allocation 68 * code will enter in a mapping both in the MC68030 MMU page tables and the 69 * I/O mapper. 70 * 71 * The address returned by the allocation routine is a virtual address that 72 * the requesting driver must use to access the buffer. It is up to the 73 * device driver to convert this virtual address into the appropriate slave 74 * address that its device should issue to access the buffer. (There will be 75 * routines that assist the driver in doing so.) 76 */ 77#include <sys/param.h> 78#include <sys/systm.h> 79#include <sys/device.h> 80#include <sys/proc.h> 81#include <sys/malloc.h> 82#include <sys/map.h> 83#include <sys/buf.h> 84#include <sys/vnode.h> 85#include <sys/user.h> 86#include <sys/core.h> 87#include <sys/exec.h> 88 89#include <vm/vm.h> 90#include <vm/vm_kern.h> 91#include <vm/vm_map.h> 92 93#include <machine/autoconf.h> 94#include <machine/cpu.h> 95#include <machine/dvma.h> 96#include <machine/pmap.h> 97/* #include <machine/reg.h> */ 98 99#include <sun3/sun3/machdep.h> 100 101#include <sun3/sun3x/enable.h> 102#include <sun3/sun3x/iommu.h> 103 104/* 105 * Use a resource map to manage DVMA scratch-memory pages. 106 * Note: SunOS says last three pages are reserved (PROM?) 107 * Note: need a separate map (sub-map?) for last 1MB for 108 * use by VME slave interface. 109 */ 110 111/* Number of slots in dvmamap. */ 112int dvma_max_segs = btoc(DVMA_MAP_SIZE); 113struct map *dvmamap; 114 115void 116dvma_init() 117{ 118 119 /* 120 * Create the resource map for DVMA pages. 121 */ 122 dvmamap = malloc((sizeof(struct map) * dvma_max_segs), 123 M_DEVBUF, M_WAITOK); 124 125 rminit(dvmamap, btoc(DVMA_MAP_AVAIL), btoc(DVMA_MAP_BASE), 126 "dvmamap", dvma_max_segs); 127 128 /* 129 * Enable DVMA in the System Enable register. 130 * Note: This is only necessary for VME slave accesses. 131 * On-board devices are always capable of DVMA. 132 */ 133 *enable_reg |= ENA_SDVMA; 134} 135 136 137/* 138 * Given a DVMA address, return the physical address that 139 * would be used by some OTHER bus-master besides the CPU. 140 * (Examples: on-board ie/le, VME xy board). 141 */ 142u_long 143dvma_kvtopa(kva, bustype) 144 void * kva; 145 int bustype; 146{ 147 u_long addr, mask; 148 149 addr = (u_long)kva; 150 if ((addr & DVMA_MAP_BASE) != DVMA_MAP_BASE) 151 panic("dvma_kvtopa: bad dmva addr=0x%x\n", addr); 152 153 switch (bustype) { 154 case BUS_OBIO: 155 case BUS_OBMEM: 156 mask = DVMA_OBIO_SLAVE_MASK; 157 break; 158 default: /* VME bus device. */ 159 mask = DVMA_VME_SLAVE_MASK; 160 break; 161 } 162 163 return(addr & mask); 164} 165 166 167/* 168 * Map a range [va, va+len] of wired virtual addresses in the given map 169 * to a kernel address in DVMA space. 170 */ 171void * 172dvma_mapin(kmem_va, len, canwait) 173 void * kmem_va; 174 int len, canwait; 175{ 176 void * dvma_addr; 177 vm_offset_t kva, tva; 178 register int npf, s; 179 register vm_offset_t pa; 180 long off, pn; 181 182 kva = (u_long)kmem_va; 183#ifdef DIAGNOSTIC 184 /* 185 * Addresses below VM_MIN_KERNEL_ADDRESS are not part of the kernel 186 * map and should not participate in DVMA. 187 */ 188 if (kva < VM_MIN_KERNEL_ADDRESS) 189 panic("dvma_mapin: bad kva"); 190#endif 191 192 /* 193 * Calculate the offset of the data buffer from a page boundary. 194 */ 195 off = (int)kva & PGOFSET; 196 kva -= off; /* Truncate starting address to nearest page. */ 197 len = round_page(len + off); /* Round the buffer length to pages. */ 198 npf = btoc(len); /* Determine the number of pages to be mapped. */ 199 200 s = splimp(); 201 for (;;) { 202 /* 203 * Try to allocate DVMA space of the appropriate size 204 * in which to do a transfer. 205 */ 206 pn = rmalloc(dvmamap, npf); 207 208 if (pn != 0) 209 break; 210 if (canwait) { 211 (void)tsleep(dvmamap, PRIBIO+1, "physio", 0); 212 continue; 213 } 214 splx(s); 215 return NULL; 216 } 217 splx(s); 218 219 220 /* 221 * Tva is the starting page to which the data buffer will be double 222 * mapped. Dvma_addr is the starting address of the buffer within 223 * that page and is the return value of the function. 224 */ 225 tva = ctob(pn); 226 dvma_addr = (void *) (tva + off); 227 228 for (;npf--; kva += NBPG, tva += NBPG) { 229 /* 230 * Retrieve the physical address of each page in the buffer 231 * and enter mappings into the I/O MMU so they may be seen 232 * by external bus masters and into the special DVMA space 233 * in the MC68030 MMU so they may be seen by the CPU. 234 */ 235 pa = pmap_extract(pmap_kernel(), kva); 236#ifdef DEBUG 237 if (pa == 0) 238 panic("dvma_mapin: null page frame"); 239#endif DEBUG 240 241 iommu_enter((tva & IOMMU_VA_MASK), pa); 242 pmap_enter(pmap_kernel(), tva, pa | PMAP_NC, 243 VM_PROT_READ|VM_PROT_WRITE, 1); 244 } 245 246 return (dvma_addr); 247} 248 249/* 250 * Remove double map of `va' in DVMA space at `kva'. 251 * 252 * TODO - This function might be the perfect place to handle the 253 * synchronization between the DVMA cache and central RAM 254 * on the 3/470. 255 */ 256void 257dvma_mapout(dvma_addr, len) 258 void * dvma_addr; 259 int len; 260{ 261 u_long kva; 262 int s, off; 263 264 kva = (u_long)dvma_addr; 265 off = (int)kva & PGOFSET; 266 kva -= off; 267 len = round_page(len + off); 268 269 iommu_remove((kva & IOMMU_VA_MASK), len); 270 271 /* 272 * XXX - don't call pmap_remove() with DVMA space yet. 273 * XXX It cannot (currently) handle the removal 274 * XXX of address ranges which do not participate in the 275 * XXX PV system by virtue of their _virtual_ addresses. 276 * XXX DVMA is one of these special address spaces. 277 */ 278#ifdef DVMA_ON_PVLIST 279 pmap_remove(pmap_kernel(), kva, kva + len); 280#endif /* DVMA_ON_PVLIST */ 281 282 s = splimp(); 283 rmfree(dvmamap, btoc(len), btoc(kva)); 284 wakeup(dvmamap); 285 splx(s); 286} 287 288/* 289 * Allocate actual memory pages in DVMA space. 290 * (For sun3 compatibility - the ie driver.) 291 */ 292void * 293dvma_malloc(bytes) 294 size_t bytes; 295{ 296 void *new_mem, *dvma_mem; 297 vm_size_t new_size; 298 299 if (!bytes) 300 return NULL; 301 new_size = m68k_round_page(bytes); 302 new_mem = (void*)kmem_alloc(kernel_map, new_size); 303 if (!new_mem) 304 return NULL; 305 dvma_mem = dvma_mapin(new_mem, new_size, 1); 306 return (dvma_mem); 307} 308 309/* 310 * Free pages from dvma_malloc() 311 */ 312void 313dvma_free(addr, size) 314 void *addr; 315 size_t size; 316{ 317 vm_size_t sz = m68k_round_page(size); 318 319 dvma_mapout(addr, sz); 320 /* XXX: need kmem address to free it... 321 Oh well, we never call this anyway. */ 322} 323