 @@ -1,14 +1,14 @@
-/*	$NetBSD: isa_dma.c,v 1.12 2016/02/26 18:16:51 christos Exp $	*/
+/*	$NetBSD: isa_dma.c,v 1.13 2021/01/04 18:23:10 thorpej Exp $	*/
 #define ISA_DMA_STATS
 /*-
  * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace
  * Simulation Facility, NASA Ames Research Center.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 @@ -23,34 +23,34 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: isa_dma.c,v 1.12 2016/02/26 18:16:51 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: isa_dma.c,v 1.13 2021/01/04 18:23:10 thorpej Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/syslog.h>
 #include <sys/device.h>
-#include <sys/malloc.h>
+#include <sys/kmem.h>
 #include <sys/proc.h>
 #include <sys/mbuf.h>
 #define _ATARI_BUS_DMA_PRIVATE
 #include <sys/bus.h>
 #include <dev/isa/isareg.h>
 #include <dev/isa/isavar.h>
 #include <uvm/uvm_extern.h>
 extern	paddr_t avail_end;
 @@ -140,48 +140,31 @@ struct atari_bus_dma_tag isa_bus_dma_tag
 		if ((v) == 0) \
 			printf("%s:%d -- Already 0!\n", __FILE__, __LINE__); \
 		else \
 			(v)--; \
 		} while (0)
 u_long	isa_dma_stats_loads;
 u_long	isa_dma_stats_bounces;
 u_long	isa_dma_stats_nbouncebufs;
 #else
 #define	STAT_INCR(v)
 #define	STAT_DECR(v)
 #endif
-/*
+static int
- * Create an ISA DMA map.
+isadma_bounce_cookieflags(bus_dma_tag_t const t, bus_dmamap_t const map,
- */
+    int const flags)
 int
 _isa_bus_dmamap_create(bus_dma_tag_t t, bus_size_t size, int nsegments, bus_size_t maxsegsz, bus_size_t boundary, int flags, bus_dmamap_t *dmamp)
+{
-	struct atari_isa_dma_cookie *cookie;
+	int cookieflags = 0;
 	bus_dmamap_t map;
 	int error, cookieflags;
 	void *cookiestore;
 	size_t cookiesize;
 	/* Call common function to create the basic map. */
 	error = _bus_dmamap_create(t, size, nsegments, maxsegsz, boundary,
 	    flags, dmamp);
 	if (error)
 		return (error);
 	map = *dmamp;
 	map->_dm_cookie = NULL;
 	cookiesize = sizeof(struct atari_isa_dma_cookie);
 	/*
 	 * ISA only has 24-bits of address space.  This means
 	 * we can't DMA to pages over 16M.  In order to DMA to
 	 * arbitrary buffers, we use "bounce buffers" - pages
 	 * in memory below the 16M boundary.  On DMA reads,
 	 * DMA happens to the bounce buffers, and is copied into
 	 * the caller's buffer.  On writes, data is copied into
 	 * but bounce buffer, and the DMA happens from those
 	 * pages.  To software using the DMA mapping interface,
 	 * this looks simply like a data cache.
+	 *
 	 * If we have more than 16M of RAM in the system, we may
 @@ -190,81 +173,134 @@ _isa_bus_dmamap_create(bus_dma_tag_t t,
 	 * There are exceptions, however.  VLB devices can do
 	 * 32-bit DMA, and indicate that here.
+	 *
 	 * ...or, there is an opposite case.  The most segments
 	 * a transfer will require is (maxxfer / PAGE_SIZE) + 1.  If
 	 * the caller can't handle that many segments (e.g. the
 	 * ISA DMA controller), we may have to bounce it as well.
 	 */
 	if (avail_end <= t->_bounce_thresh ||
 	    (flags & ISABUS_DMA_32BIT) != 0) {
 		/* Bouncing not necessary due to memory size. */
 		map->_dm_bounce_thresh = 0;
+	}
 	cookieflags = 0;
 	if (map->_dm_bounce_thresh != 0 ||
 	    ((map->_dm_size / PAGE_SIZE) + 1) > map->_dm_segcnt) {
 		cookieflags |= ID_MIGHT_NEED_BOUNCE;
+	}
 	return cookieflags;
+}
 static size_t
 isadma_bounce_cookiesize(bus_dmamap_t const map, int cookieflags)
+{
 	size_t cookiesize = sizeof(struct atari_isa_dma_cookie);
 	if (cookieflags & ID_MIGHT_NEED_BOUNCE) {
 		cookiesize += (sizeof(bus_dma_segment_t) * map->_dm_segcnt);
+	}
 	return cookiesize;
+}
 static int
 isadma_bounce_cookie_alloc(bus_dma_tag_t const t, bus_dmamap_t const map,
     int const flags)
+{
 	struct atari_isa_dma_cookie *cookie;
 	int cookieflags = isadma_bounce_cookieflags(t, map, flags);
 	if ((cookie = kmem_zalloc(isadma_bounce_cookiesize(map, cookieflags),
 	     (flags & BUS_DMA_NOWAIT) ? KM_NOSLEEP : KM_SLEEP)) == NULL) {
 		return ENOMEM;
+	}
 	cookie->id_flags = cookieflags;
 	map->_dm_cookie = cookie;
 	return 0;
+}
 static void
 isadma_bounce_cookie_free(bus_dmamap_t const map)
+{
 	struct atari_isa_dma_cookie *cookie = map->_dm_cookie;
 	if (cookie != NULL) {
 		kmem_free(map->_dm_cookie,
 		    isadma_bounce_cookiesize(map, cookie->id_flags));
 		map->_dm_cookie = NULL;
+	}
+}
 /*
  * Create an ISA DMA map.
  */
 int
 _isa_bus_dmamap_create(bus_dma_tag_t t, bus_size_t size, int nsegments, bus_size_t maxsegsz, bus_size_t boundary, int flags, bus_dmamap_t *dmamp)
+{
 	struct atari_isa_dma_cookie *cookie;
 	bus_dmamap_t map;
 	int error;
 	/* Call common function to create the basic map. */
 	error = _bus_dmamap_create(t, size, nsegments, maxsegsz, boundary,
 	    flags, dmamp);
 	if (error)
 		return (error);
 	map = *dmamp;
 	map->_dm_cookie = NULL;
 	/*
 	 * Allocate our cookie.
 	 */
-	if ((cookiestore = malloc(cookiesize, M_DMAMAP,
+	if ((error = isadma_bounce_cookie_alloc(t, map, flags)) != 0) {
 	    (flags & BUS_DMA_NOWAIT) ? M_NOWAIT : M_WAITOK)) == NULL) {
 		error = ENOMEM;
 		goto out;
+	}
-	memset(cookiestore, 0, cookiesize);
+	cookie = map->_dm_cookie;
 	cookie = (struct atari_isa_dma_cookie *)cookiestore;
 	cookie->id_flags = cookieflags;
 	map->_dm_cookie = cookie;
-	if (cookieflags & ID_MIGHT_NEED_BOUNCE) {
+	if (cookie->id_flags & ID_MIGHT_NEED_BOUNCE) {
 		/*
 		 * Allocate the bounce pages now if the caller
 		 * wishes us to do so.
 		 */
-		if ((flags & BUS_DMA_ALLOCNOW) == 0)
+		if (flags & BUS_DMA_ALLOCNOW) {
-			goto out;
+			error = _isa_dma_alloc_bouncebuf(t, map, size, flags);
+		}
 		error = _isa_dma_alloc_bouncebuf(t, map, size, flags);
+	}
  out:
 	if (error) {
-		if (map->_dm_cookie != NULL)
+		isadma_bounce_cookie_free(map);
 			free(map->_dm_cookie, M_DMAMAP);
 		_bus_dmamap_destroy(t, map);
+	}
 	return (error);
+}
 /*
  * Destroy an ISA DMA map.
  */
 void
 _isa_bus_dmamap_destroy(bus_dma_tag_t t, bus_dmamap_t map)
+{
 	struct atari_isa_dma_cookie *cookie = map->_dm_cookie;
 	/*
 	 * Free any bounce pages this map might hold.
 	 */
 	if (cookie->id_flags & ID_HAS_BOUNCE)
 		_isa_dma_free_bouncebuf(t, map);
-	free(cookie, M_DMAMAP);
+	isadma_bounce_cookie_free(map);
 	_bus_dmamap_destroy(t, map);
+}
 /*
  * Load an ISA DMA map with a linear buffer.
  */
 int
 _isa_bus_dmamap_load(bus_dma_tag_t t, bus_dmamap_t map, void *buf,
     bus_size_t buflen, struct proc *p, int flags)
+{
 	struct atari_isa_dma_cookie *cookie = map->_dm_cookie;
 	int error;