Goodbye BOUNCE_BUFFERS, for a hack it has served us well.

The last consumer of this code (the old SCSI system) has left us and
the CAM code does it's own bouncing.  The isa dma system has been
doing it's own bouncing for a while too.

Reviewed by:	core

1 files changed, 1 insertions, 478 deletions

diff --git a/sys/amd64/amd64/vm_machdep.c b/sys/amd64/amd64/vm_machdep.c
index cf16f53..8c0b274 100644
--- a/sys/amd64/amd64/vm_machdep.c
+++ b/sys/amd64/amd64/vm_machdep.c
@@ -38,11 +38,10 @@
  *
  *	from: @(#)vm_machdep.c	7.3 (Berkeley) 5/13/91
  *	Utah $Hdr: vm_machdep.c 1.16.1.1 89/06/23$
- *	$Id: vm_machdep.c,v 1.108 1998/05/19 00:00:10 tegge Exp $
+ *	$Id: vm_machdep.c,v 1.109 1998/08/18 07:46:58 msmith Exp $
  */
 
 #include "npx.h"
-#include "opt_bounce.h"
 #include "opt_user_ldt.h"
 #include "opt_vm86.h"
 #ifdef PC98
@@ -94,482 +93,6 @@ static u_int	cpu_reset_proxyid;
 static volatile u_int	cpu_reset_proxy_active;
 #endif
 
-#ifdef BOUNCE_BUFFERS
-static vm_offset_t
-		vm_bounce_kva __P((int size, int waitok));
-static void	vm_bounce_kva_free __P((vm_offset_t addr, vm_offset_t size,
-					int now));
-static vm_offset_t
-		vm_bounce_page_find __P((int count));
-static void	vm_bounce_page_free __P((vm_offset_t pa, int count));
-
-static volatile int	kvasfreecnt;
-
-caddr_t		bouncememory;
-static int	bpwait;
-static vm_offset_t	*bouncepa;
-static int		bmwait, bmfreeing;
-
-#define BITS_IN_UNSIGNED (8*sizeof(unsigned))
-static int		bounceallocarraysize;
-static unsigned	*bounceallocarray;
-static int		bouncefree;
-
-#if defined(PC98) && defined (EPSON_BOUNCEDMA)
-#define SIXTEENMEG (3840*4096)			/* 15MB boundary */
-#else
-#define SIXTEENMEG (4096*4096)
-#endif
-#define MAXBKVA 1024
-int		maxbkva = MAXBKVA*PAGE_SIZE;
-
-/* special list that can be used at interrupt time for eventual kva free */
-static struct kvasfree {
-	vm_offset_t addr;
-	vm_offset_t size;
-} kvaf[MAXBKVA];
-
-/*
- * get bounce buffer pages (count physically contiguous)
- * (only 1 inplemented now)
- */
-static vm_offset_t
-vm_bounce_page_find(count)
-	int count;
-{
-	int bit;
-	int s,i;
-
-	if (count != 1)
-		panic("vm_bounce_page_find -- no support for > 1 page yet!!!");
-
-	s = splbio();
-retry:
-	for (i = 0; i < bounceallocarraysize; i++) {
-		if (bounceallocarray[i] != 0xffffffff) {
-			bit = ffs(~bounceallocarray[i]);
-			if (bit) {
-				bounceallocarray[i] |= 1 << (bit - 1) ;
-				bouncefree -= count;
-				splx(s);
-				return bouncepa[(i * BITS_IN_UNSIGNED + (bit - 1))];
-			}
-		}
-	}
-	bpwait = 1;
-	tsleep((caddr_t) &bounceallocarray, PRIBIO, "bncwai", 0);
-	goto retry;
-}
-
-static void
-vm_bounce_kva_free(addr, size, now)
-	vm_offset_t addr;
-	vm_offset_t size;
-	int now;
-{
-	int s = splbio();
-	kvaf[kvasfreecnt].addr = addr;
-	kvaf[kvasfreecnt].size = size;
-	++kvasfreecnt;
-	if( now) {
-		/*
-		 * this will do wakeups
-		 */
-		vm_bounce_kva(0,0);
-	} else {
-		if (bmwait) {
-		/*
-		 * if anyone is waiting on the bounce-map, then wakeup
-		 */
-			wakeup((caddr_t) io_map);
-			bmwait = 0;
-		}
-	}
-	splx(s);
-}
-
-/*
- * free count bounce buffer pages
- */
-static void
-vm_bounce_page_free(pa, count)
-	vm_offset_t pa;
-	int count;
-{
-	int allocindex;
-	int index;
-	int bit;
-
-	if (count != 1)
-		panic("vm_bounce_page_free -- no support for > 1 page yet!!!");
-
-	for(index=0;index<bouncepages;index++) {
-		if( pa == bouncepa[index])
-			break;
-	}
-
-	if( index == bouncepages)
-		panic("vm_bounce_page_free: invalid bounce buffer");
-
-	allocindex = index / BITS_IN_UNSIGNED;
-	bit = index % BITS_IN_UNSIGNED;
-
-	bounceallocarray[allocindex] &= ~(1 << bit);
-
-	bouncefree += count;
-	if (bpwait) {
-		bpwait = 0;
-		wakeup((caddr_t) &bounceallocarray);
-	}
-}
-
-/*
- * allocate count bounce buffer kva pages
- */
-static vm_offset_t
-vm_bounce_kva(size, waitok)
-	int size;
-	int waitok;
-{
-	int i;
-	vm_offset_t kva = 0;
-	vm_offset_t off;
-	int s = splbio();
-more:
-	if (!bmfreeing && kvasfreecnt) {
-		bmfreeing = 1;
-		for (i = 0; i < kvasfreecnt; i++) {
-			for(off=0;off<kvaf[i].size;off+=PAGE_SIZE) {
-				pmap_kremove( kvaf[i].addr + off);
-			}
-			kmem_free_wakeup(io_map, kvaf[i].addr,
-				kvaf[i].size);
-		}
-		kvasfreecnt = 0;
-		bmfreeing = 0;
-		if( bmwait) {
-			bmwait = 0;
-			wakeup( (caddr_t) io_map);
-		}
-	}
-
-	if( size == 0) {
-		splx(s);
-		return 0;
-	}
-
-	if ((kva = kmem_alloc_pageable(io_map, size)) == 0) {
-		if( !waitok) {
-			splx(s);
-			return 0;
-		}
-		bmwait = 1;
-		tsleep((caddr_t) io_map, PRIBIO, "bmwait", 0);
-		goto more;
-	}
-	splx(s);
-	return kva;
-}
-
-/*
- * same as vm_bounce_kva -- but really allocate (but takes pages as arg)
- */
-vm_offset_t
-vm_bounce_kva_alloc(count)
-int count;
-{
-	int i;
-	vm_offset_t kva;
-	vm_offset_t pa;
-	if( bouncepages == 0) {
-		kva = (vm_offset_t) malloc(count*PAGE_SIZE, M_TEMP, M_WAITOK);
-		return kva;
-	}
-	kva = vm_bounce_kva(count*PAGE_SIZE, 1);
-	for(i=0;i<count;i++) {
-		pa = vm_bounce_page_find(1);
-		pmap_kenter(kva + i * PAGE_SIZE, pa);
-	}
-	return kva;
-}
-
-/*
- * same as vm_bounce_kva_free -- but really free
- */
-void
-vm_bounce_kva_alloc_free(kva, count)
-	vm_offset_t kva;
-	int count;
-{
-	int i;
-	vm_offset_t pa;
-	if( bouncepages == 0) {
-		free((caddr_t) kva, M_TEMP);
-		return;
-	}
-	for(i = 0; i < count; i++) {
-		pa = pmap_kextract(kva + i * PAGE_SIZE);
-		vm_bounce_page_free(pa, 1);
-	}
-	vm_bounce_kva_free(kva, count*PAGE_SIZE, 0);
-}
-
-/*
- * do the things necessary to the struct buf to implement
- * bounce buffers...  inserted before the disk sort
- */
-void
-vm_bounce_alloc(bp)
-	struct buf *bp;
-{
-	int countvmpg;
-	vm_offset_t vastart, vaend;
-	vm_offset_t vapstart, vapend;
-	vm_offset_t va, kva;
-	vm_offset_t pa;
-	int dobounceflag = 0;
-	int i;
-
-	if (bouncepages == 0)
-		return;
-
-	if (bp->b_flags & B_BOUNCE) {
-		printf("vm_bounce_alloc: called recursively???\n");
-		return;
-	}
-
-	if (bp->b_bufsize < bp->b_bcount) {
-		printf(
-		    "vm_bounce_alloc: b_bufsize(0x%lx) < b_bcount(0x%lx) !!\n",
-			bp->b_bufsize, bp->b_bcount);
-		panic("vm_bounce_alloc");
-	}
-
-/*
- *  This is not really necessary
- *	if( bp->b_bufsize != bp->b_bcount) {
- *		printf("size: %d, count: %d\n", bp->b_bufsize, bp->b_bcount);
- *	}
- */
-
-
-	vastart = (vm_offset_t) bp->b_data;
-	vaend = (vm_offset_t) bp->b_data + bp->b_bufsize;
-
-	vapstart = trunc_page(vastart);
-	vapend = round_page(vaend);
-	countvmpg = (vapend - vapstart) / PAGE_SIZE;
-
-/*
- * if any page is above 16MB, then go into bounce-buffer mode
- */
-	va = vapstart;
-	for (i = 0; i < countvmpg; i++) {
-		pa = pmap_kextract(va);
-		if (pa >= SIXTEENMEG)
-			++dobounceflag;
-		if( pa == 0)
-			panic("vm_bounce_alloc: Unmapped page");
-		va += PAGE_SIZE;
-	}
-	if (dobounceflag == 0)
-		return;
-
-	if (bouncepages < dobounceflag)
-		panic("Not enough bounce buffers!!!");
-
-/*
- * allocate a replacement kva for b_addr
- */
-	kva = vm_bounce_kva(countvmpg*PAGE_SIZE, 1);
-#if 0
-	printf("%s: vapstart: %x, vapend: %x, countvmpg: %d, kva: %x ",
-		(bp->b_flags & B_READ) ? "read":"write",
-			vapstart, vapend, countvmpg, kva);
-#endif
-	va = vapstart;
-	for (i = 0; i < countvmpg; i++) {
-		pa = pmap_kextract(va);
-		if (pa >= SIXTEENMEG) {
-			/*
-			 * allocate a replacement page
-			 */
-			vm_offset_t bpa = vm_bounce_page_find(1);
-			pmap_kenter(kva + (PAGE_SIZE * i), bpa);
-#if 0
-			printf("r(%d): (%x,%x,%x) ", i, va, pa, bpa);
-#endif
-			/*
-			 * if we are writing, the copy the data into the page
-			 */
-			if ((bp->b_flags & B_READ) == 0) {
-				bcopy((caddr_t) va, (caddr_t) kva + (PAGE_SIZE * i), PAGE_SIZE);
-			}
-		} else {
-			/*
-			 * use original page
-			 */
-			pmap_kenter(kva + (PAGE_SIZE * i), pa);
-		}
-		va += PAGE_SIZE;
-	}
-
-/*
- * flag the buffer as being bounced
- */
-	bp->b_flags |= B_BOUNCE;
-/*
- * save the original buffer kva
- */
-	bp->b_savekva = bp->b_data;
-/*
- * put our new kva into the buffer (offset by original offset)
- */
-	bp->b_data = (caddr_t) (((vm_offset_t) kva) |
-				((vm_offset_t) bp->b_savekva & PAGE_MASK));
-#if 0
-	printf("b_savekva: %x, newva: %x\n", bp->b_savekva, bp->b_data);
-#endif
-	return;
-}
-
-/*
- * hook into biodone to free bounce buffer
- */
-void
-vm_bounce_free(bp)
-	struct buf *bp;
-{
-	int i;
-	vm_offset_t origkva, bouncekva, bouncekvaend;
-
-/*
- * if this isn't a bounced buffer, then just return
- */
-	if ((bp->b_flags & B_BOUNCE) == 0)
-		return;
-
-/*
- *  This check is not necessary
- *	if (bp->b_bufsize != bp->b_bcount) {
- *		printf("vm_bounce_free: b_bufsize=%d, b_bcount=%d\n",
- *			bp->b_bufsize, bp->b_bcount);
- *	}
- */
-
-	origkva = (vm_offset_t) bp->b_savekva;
-	bouncekva = (vm_offset_t) bp->b_data;
-/*
-	printf("free: %d ", bp->b_bufsize);
-*/
-
-/*
- * check every page in the kva space for b_addr
- */
-	for (i = 0; i < bp->b_bufsize; ) {
-		vm_offset_t mybouncepa;
-		vm_offset_t copycount;
-
-		copycount = round_page(bouncekva + 1) - bouncekva;
-		mybouncepa = pmap_kextract(trunc_page(bouncekva));
-
-/*
- * if this is a bounced pa, then process as one
- */
-		if ( mybouncepa != pmap_kextract( trunc_page( origkva))) {
-			vm_offset_t tocopy = copycount;
-			if (i + tocopy > bp->b_bufsize)
-				tocopy = bp->b_bufsize - i;
-/*
- * if this is a read, then copy from bounce buffer into original buffer
- */
-			if (bp->b_flags & B_READ)
-				bcopy((caddr_t) bouncekva, (caddr_t) origkva, tocopy);
-/*
- * free the bounce allocation
- */
-
-/*
-			printf("(kva: %x, pa: %x)", bouncekva, mybouncepa);
-*/
-			vm_bounce_page_free(mybouncepa, 1);
-		}
-
-		origkva += copycount;
-		bouncekva += copycount;
-		i += copycount;
-	}
-
-/*
-	printf("\n");
-*/
-/*
- * add the old kva into the "to free" list
- */
-
-	bouncekva= trunc_page((vm_offset_t) bp->b_data);
-	bouncekvaend= round_page((vm_offset_t)bp->b_data + bp->b_bufsize);
-
-/*
-	printf("freeva: %d\n", (bouncekvaend - bouncekva) / PAGE_SIZE);
-*/
-	vm_bounce_kva_free( bouncekva, (bouncekvaend - bouncekva), 0);
-	bp->b_data = bp->b_savekva;
-	bp->b_savekva = 0;
-	bp->b_flags &= ~B_BOUNCE;
-
-	return;
-}
-
-
-/*
- * init the bounce buffer system
- */
-void
-vm_bounce_init()
-{
-	int i;
-
-	kvasfreecnt = 0;
-
-	if (bouncepages == 0)
-		return;
-
-	bounceallocarraysize = (bouncepages + BITS_IN_UNSIGNED - 1) / BITS_IN_UNSIGNED;
-	bounceallocarray = malloc(bounceallocarraysize * sizeof(unsigned), M_TEMP, M_NOWAIT);
-
-	if (!bounceallocarray)
-		panic("Cannot allocate bounce resource array");
-
-	bouncepa = malloc(bouncepages * sizeof(vm_offset_t), M_TEMP, M_NOWAIT);
-	if (!bouncepa)
-		panic("Cannot allocate physical memory array");
-
-	for(i=0;i<bounceallocarraysize;i++) {
-		bounceallocarray[i] = 0xffffffff;
-	}
-
-	for(i=0;i<bouncepages;i++) {
-		vm_offset_t pa;
-		if( (pa = pmap_kextract((vm_offset_t) bouncememory + i * PAGE_SIZE)) >= SIXTEENMEG) {
-			printf("vm_bounce_init: bounce memory out of range -- bounce disabled\n");
-			free(bounceallocarray, M_TEMP);
-			bounceallocarray = NULL;
-			free(bouncepa, M_TEMP);
-			bouncepa = NULL;
-			bouncepages = 0;
-			break;
-		}
-		if( pa == 0)
-			panic("bounce memory not resident");
-		bouncepa[i] = pa;
-		bounceallocarray[i/(8*sizeof(int))] &= ~(1<<(i%(8*sizeof(int))));
-	}
-	bouncefree = bouncepages;
-
-}
-#endif /* BOUNCE_BUFFERS */
-
 /*
  * quick version of vm_fault
  */