1 /* $NetBSD: dvma.c,v 1.40 2009/11/21 04:16:53 rmind 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.40 2009/11/21 04:16:53 rmind 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 } 401