 @@ -1,173 +1,181 @@
-/* $NetBSD: sgmap_common.c,v 1.28 2021/07/04 22:42:35 thorpej Exp $ */
+/* $NetBSD: sgmap_common.c,v 1.29 2021/07/18 05:12:27 thorpej Exp $ */
 /*-
  * Copyright (c) 1997, 1998, 2001 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * 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
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``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>			/* RCS ID & Copyright macro defns */
-__KERNEL_RCSID(0, "$NetBSD: sgmap_common.c,v 1.28 2021/07/04 22:42:35 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sgmap_common.c,v 1.29 2021/07/18 05:12:27 thorpej Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <uvm/uvm_extern.h>
 #define	_ALPHA_BUS_DMA_PRIVATE
 #include <sys/bus.h>
 #include <alpha/common/sgmapvar.h>
 /*
  * Some systems will prefetch the next page during a memory -> device DMA.
  * This can cause machine checks if there is not a spill page after the
  * last page of the DMA (thus avoiding hitting an invalid SGMAP PTE).
  */
 vaddr_t		alpha_sgmap_prefetch_spill_page_va;
 bus_addr_t	alpha_sgmap_prefetch_spill_page_pa;
 void
 alpha_sgmap_init(bus_dma_tag_t t, struct alpha_sgmap *sgmap, const char *name,
     bus_addr_t wbase, bus_addr_t sgvabase, bus_size_t sgvasize, size_t ptesize,
     void *ptva, bus_size_t minptalign)
+{
 	bus_dma_segment_t seg;
 	size_t ptsize;
 	int rseg;
 	if (sgvasize & PGOFSET) {
 		printf("size botch for sgmap `%s'\n", name);
 		goto die;
+	}
 	/*
 	 * If we don't yet have a minimum SGVA alignment, default
 	 * to the system page size.
 	 */
 	if (t->_sgmap_minalign < PAGE_SIZE) {
 		t->_sgmap_minalign = PAGE_SIZE;
+	}
 	sgmap->aps_wbase = wbase;
 	sgmap->aps_sgvabase = sgvabase;
 	sgmap->aps_sgvasize = sgvasize;
 	if (ptva != NULL) {
 		/*
 		 * We already have a page table; this may be a system
 		 * where the page table resides in bridge-resident SRAM.
 		 */
 		sgmap->aps_pt = ptva;
 		sgmap->aps_ptpa = 0;
 	} else {
 		/*
 		 * Compute the page table size and allocate it.  At minimum,
 		 * this must be aligned to the page table size.  However,
 		 * some platforms have more strict alignment reqirements.
 		 */
 		ptsize = (sgvasize / PAGE_SIZE) * ptesize;
 		if (minptalign != 0) {
 			if (minptalign < ptsize)
 				minptalign = ptsize;
 		} else
 			minptalign = ptsize;
 		if (bus_dmamem_alloc(t, ptsize, minptalign, 0, &seg, 1, &rseg,
 		    BUS_DMA_NOWAIT)) {
 			panic("unable to allocate page table for sgmap `%s'",
 			    name);
 			goto die;
+		}
 		sgmap->aps_ptpa = seg.ds_addr;
 		sgmap->aps_pt = (void *)ALPHA_PHYS_TO_K0SEG(sgmap->aps_ptpa);
+	}
 	/*
 	 * Create the arena used to manage the virtual address
 	 * space.
+	 *
 	 * XXX Consider using a quantum cache up to MAXPHYS+PAGE_SIZE
 	 * XXX (extra page to handle the spill page).  For now, we don't,
 	 * XXX because we are using constrained allocations everywhere.
 	 */
 	sgmap->aps_arena = vmem_create(name, sgvabase, sgvasize,
 				       PAGE_SIZE,	/* quantum */
 				       NULL,		/* importfn */
 				       NULL,		/* releasefn */
 				       NULL,		/* source */
 ,		/* qcache_max */
 				       VM_SLEEP,
 				       IPL_VM);
 	KASSERT(sgmap->aps_arena != NULL);
 	/*
 	 * Allocate a spill page if that hasn't already been done.
 	 */
 	if (alpha_sgmap_prefetch_spill_page_va == 0) {
 		if (bus_dmamem_alloc(t, PAGE_SIZE, 0, 0, &seg, 1, &rseg,
 		    BUS_DMA_NOWAIT)) {
 			printf("unable to allocate spill page for sgmap `%s'\n",
 			    name);
 			goto die;
+		}
 		alpha_sgmap_prefetch_spill_page_pa = seg.ds_addr;
 		alpha_sgmap_prefetch_spill_page_va =
 		    ALPHA_PHYS_TO_K0SEG(alpha_sgmap_prefetch_spill_page_pa);
 		memset((void *)alpha_sgmap_prefetch_spill_page_va, 0,
 		    PAGE_SIZE);
+	}
 	return;
  die:
 	panic("alpha_sgmap_init");
+}
 int
 alpha_sgmap_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)
+{
 	bus_dmamap_t map;
 	int error;
 	error = _bus_dmamap_create(t, size, nsegments, maxsegsz,
 	    boundary, flags, &map);
 	if (error)
 		return (error);
 	/* XXX BUS_DMA_ALLOCNOW */
 	if (error == 0)
 		*dmamp = map;
 	else
 		alpha_sgmap_dmamap_destroy(t, map);
 	return (error);
+}
 void
 alpha_sgmap_dmamap_destroy(bus_dma_tag_t t, bus_dmamap_t map)
+{
 	KASSERT(map->dm_mapsize == 0);
 	_bus_dmamap_destroy(t, map);
+}

 @@ -1,599 +1,603 @@
-/* $NetBSD: sgmap_typedep.c,v 1.42 2021/06/24 16:41:16 thorpej Exp $ */
+/* $NetBSD: sgmap_typedep.c,v 1.43 2021/07/18 05:12:27 thorpej Exp $ */
 /*-
  * Copyright (c) 1997, 1998, 2001 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * 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
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``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(1, "$NetBSD: sgmap_typedep.c,v 1.42 2021/06/24 16:41:16 thorpej Exp $");
+__KERNEL_RCSID(1, "$NetBSD: sgmap_typedep.c,v 1.43 2021/07/18 05:12:27 thorpej Exp $");
 #include "opt_ddb.h"
 #include <sys/evcnt.h>
 #include <uvm/uvm_extern.h>
 #define	DMA_COUNT_DECL(cnt)	_DMA_COUNT_DECL(dma_sgmap, cnt)
 #define	DMA_COUNT(cnt)		_DMA_COUNT(dma_sgmap, cnt)
 #ifdef SGMAP_DEBUG
 int			__C(SGMAP_TYPE,_debug) = 0;
 #endif
 SGMAP_PTE_TYPE		__C(SGMAP_TYPE,_prefetch_spill_page_pte);
 static void		__C(SGMAP_TYPE,_do_unload)(bus_dma_tag_t, bus_dmamap_t,
 			    struct alpha_sgmap *);
 void
 __C(SGMAP_TYPE,_init_spill_page_pte)(void)
+{
 	__C(SGMAP_TYPE,_prefetch_spill_page_pte) =
 	    (alpha_sgmap_prefetch_spill_page_pa >>
 	     SGPTE_PGADDR_SHIFT) | SGPTE_VALID;
+}
 DMA_COUNT_DECL(spill_page);
 DMA_COUNT_DECL(extra_segment);
 DMA_COUNT_DECL(extra_segment_and_spill);
 static int
 __C(SGMAP_TYPE,_load_buffer)(bus_dma_tag_t t, bus_dmamap_t map, void *buf,
     size_t buflen, struct vmspace *vm, int flags, int * const segp,
     struct alpha_sgmap *sgmap)
+{
 	vaddr_t endva, va = (vaddr_t)buf;
 	paddr_t pa;
 	bus_addr_t dmaoffset, sgva, extra_sgva;
 	bus_size_t sgvalen, extra_sgvalen, boundary, alignment;
 	SGMAP_PTE_TYPE *pte, *page_table = sgmap->aps_pt;
 	int pteidx, error, spill, seg = *segp;
 	/* Initialize the spill page PTE if it hasn't been already. */
 	if (__C(SGMAP_TYPE,_prefetch_spill_page_pte) == 0)
 		__C(SGMAP_TYPE,_init_spill_page_pte)();
 	if (seg == map->_dm_segcnt) {
 		/* Ran of segments. */
 		return EFBIG;
+	}
 	KASSERT(seg < map->_dm_segcnt);
 	/*
 	 * Remember the offset into the first page and the total
 	 * transfer length.
 	 */
 	dmaoffset = ((u_long)buf) & PGOFSET;
 #ifdef SGMAP_DEBUG
 	if (__C(SGMAP_TYPE,_debug)) {
 		printf("sgmap_load: ----- buf = %p -----\n", buf);
 		printf("sgmap_load: dmaoffset = 0x%lx, buflen = 0x%lx\n",
 		    dmaoffset, buflen);
+	}
 #endif
 	/*
 	 * Allocate the necessary virtual address space for the
 	 * mapping.  Round the size, since we deal with whole pages.
 	 */
 	/*
 	 * XXX Always allocate a spill page for now.  Note
 	 * the spill page is not needed for an in-bound-only
 	 * transfer.
 	 */
 	if ((flags & BUS_DMA_READ) == 0)
 		spill = 1;
 	else
 		spill = 0;
 	boundary = map->_dm_boundary;
 	/*
 	 * Caller's mistake if the requested length is larger than
 	 * their own boundary constraint.
 	 */
 	if (__predict_false(boundary != 0 && buflen > boundary)) {
 		return EINVAL;
+	}
 	endva = round_page(va + buflen);
 	va = trunc_page(va);
 	const vm_flag_t vmflags = VM_INSTANTFIT |
 	    ((flags & BUS_DMA_NOWAIT) ? VM_NOSLEEP : VM_SLEEP);
-	alignment = PAGE_SIZE;
+	KASSERT(t->_sgmap_minalign != 0);
 	alignment = t->_sgmap_minalign;
 	sgvalen = (endva - va);
 	SGMAP_PTE_TYPE spill_pte_v = __C(SGMAP_TYPE,_prefetch_spill_page_pte);
 	/*
 	 * If we have a boundary constraint, it's possible to end up in
 	 * a situation where sgvalen > boundary if the caller's buffer
 	 * is not page aligned.  In this case, we will have to allocate
 	 * an extra SG segment and split the buffer.
 	 */
 	if (__predict_false(boundary != 0 && boundary < sgvalen)) {
 #ifdef SGMAP_DEBUG
 		if (__C(SGMAP_TYPE,_debug)) {
 			printf("sgmap_load: extra segment needed\n");
+		}
 #endif
 		DMA_COUNT(extra_segment);
 		/* This should only ever happen for unaligned buffers. */
 		KASSERT(dmaoffset != 0);
 		extra_sgvalen = sgvalen - boundary;
 		KASSERT(extra_sgvalen == PAGE_SIZE);
 		/*
 		 * Adjust the lengths of the first segment.  The length
 		 * of the second segment will be dmaoffset.
 		 */
 		sgvalen -= extra_sgvalen;
 		endva -= extra_sgvalen;
 		buflen -= dmaoffset;
 		if (spill) {
 			DMA_COUNT(extra_segment_and_spill);
 			extra_sgvalen += PAGE_SIZE;
+		}
 		error = vmem_xalloc(sgmap->aps_arena, extra_sgvalen,
 				    alignment,		/* alignment */
 ,			/* phase */
 				    boundary,		/* nocross */
 				    VMEM_ADDR_MIN,	/* minaddr */
 				    VMEM_ADDR_MAX,	/* maxaddr */
 				    vmflags,
 				    &extra_sgva);
 		if (error) {
 			return error;
+		}
 	} else {
 		extra_sgvalen = 0;
 		extra_sgva = 0;
+	}
 	if (spill) {
 		DMA_COUNT(spill_page);
 		sgvalen += PAGE_SIZE;
 		/*
 		 * ARGH!  If the addition of the spill page bumped us
 		 * over our boundary, we have to 2x the boundary limit.
 		 * To compensate (and enforce the original boundary
-		 * constraint), we force our alignment to be the previous
+		 * constraint), we force our alignment to be at least the
-		 * boundary, thus ensuring that the only boundary violation
+		 * previous boundary, thus ensuring that the only boundary
-		 * is the pre-fetch that the SGMAP controller performs that
+		 * violation is the pre-fetch that the SGMAP controller
-		 * necessitates the spill page in the first place.
+		 * performs that necessitates the spill page in the first
 		 * place.
 		 */
 		if (boundary && boundary < sgvalen) {
-			alignment = boundary;
+			if (alignment < boundary) {
 				alignment = boundary;
+			}
 			do {
 				boundary <<= 1;
 			} while (boundary < sgvalen);
+		}
+	}
 #ifdef SGMAP_DEBUG
 	if (__C(SGMAP_TYPE,_debug)) {
 		printf("sgmap_load: va:endva = 0x%lx:0x%lx\n", va, endva);
 		printf("sgmap_load: sgvalen = 0x%lx, boundary = 0x%lx\n",
 		       sgvalen, boundary);
+	}
 #endif
 	error = vmem_xalloc(sgmap->aps_arena, sgvalen,
 			    alignment,		/* alignment */
 ,			/* phase */
 			    boundary,		/* nocross */
 			    VMEM_ADDR_MIN,	/* minaddr */
 			    VMEM_ADDR_MAX,	/* maxaddr */
 			    vmflags,
 			    &sgva);
 	if (error) {
 		if (extra_sgvalen != 0) {
 			vmem_xfree(sgmap->aps_arena, extra_sgva, extra_sgvalen);
+		}
 		return error;
+	}
 	pteidx = sgva >> SGMAP_ADDR_PTEIDX_SHIFT;
 	pte = &page_table[pteidx * SGMAP_PTE_SPACING];
 #ifdef SGMAP_DEBUG
 	if (__C(SGMAP_TYPE,_debug))
 		printf("sgmap_load: sgva = 0x%lx, pteidx = %d, "
 		    "pte = %p (pt = %p)\n", sgva, pteidx, pte,
 		    page_table);
 #endif
 	/* Generate the DMA address. */
 	map->dm_segs[seg].ds_addr = sgmap->aps_wbase | sgva | dmaoffset;
 	map->dm_segs[seg].ds_len = buflen;
 	if (__predict_false(extra_sgvalen != 0)) {
 		if (++seg == map->_dm_segcnt) {
 			/* Boo! Ran out of segments! */
 			vmem_xfree(sgmap->aps_arena, extra_sgva, extra_sgvalen);
 			vmem_xfree(sgmap->aps_arena, sgva, sgvalen);
 			return EFBIG;
+		}
 		map->dm_segs[seg].ds_addr = sgmap->aps_wbase | extra_sgva;
 		map->dm_segs[seg].ds_len = dmaoffset;
 		*segp = seg;
+	}
 #ifdef SGMAP_DEBUG
 	if (__C(SGMAP_TYPE,_debug))
 		printf("sgmap_load: wbase = 0x%lx, vpage = 0x%lx, "
 		    "DMA addr = 0x%lx\n", sgmap->aps_wbase, (uint64_t)sgva,
 		    map->dm_segs[seg].ds_addr);
 #endif
 	for (; va < endva; va += PAGE_SIZE, pteidx++,
 	     pte = &page_table[pteidx * SGMAP_PTE_SPACING]) {
 		/* Get the physical address for this segment. */
 		if (!VMSPACE_IS_KERNEL_P(vm))
 			(void) pmap_extract(vm->vm_map.pmap, va, &pa);
 		else
 			pa = vtophys(va);
 		/* Load the current PTE with this page. */
 		*pte = (pa >> SGPTE_PGADDR_SHIFT) | SGPTE_VALID;
 #ifdef SGMAP_DEBUG
 		if (__C(SGMAP_TYPE,_debug))
 			printf("sgmap_load:     pa = 0x%lx, pte = %p, "
 			    "*pte = 0x%lx\n", pa, pte, (u_long)(*pte));
 #endif
+	}
 	if (__predict_false(extra_sgvalen != 0)) {
 		int extra_pteidx = extra_sgva >> SGMAP_ADDR_PTEIDX_SHIFT;
 		SGMAP_PTE_TYPE *extra_pte =
 		    &page_table[extra_pteidx * SGMAP_PTE_SPACING];
 		/* va == endva == address of extra page */
 		KASSERT(va == endva);
 		if (!VMSPACE_IS_KERNEL_P(vm))
 			(void) pmap_extract(vm->vm_map.pmap, va, &pa);
 		else
 			pa = vtophys(va);
 		/*
 		 * If a spill page is needed, the previous segment will
 		 * need to use this PTE value for it.
 		 */
 		spill_pte_v = (pa >> SGPTE_PGADDR_SHIFT) | SGPTE_VALID;
 		*extra_pte = spill_pte_v;
 		/* ...but the extra segment uses the real spill PTE. */
 		if (spill) {
 			extra_pteidx++;
 			extra_pte =
 			    &page_table[extra_pteidx * SGMAP_PTE_SPACING];
 			*extra_pte = __C(SGMAP_TYPE,_prefetch_spill_page_pte);
+		}
+	}
 	if (spill) {
 		/* ...and the prefetch-spill page. */
 		*pte = spill_pte_v;
 #ifdef SGMAP_DEBUG
 		if (__C(SGMAP_TYPE,_debug)) {
 			printf("sgmap_load:     spill page, pte = %p, "
 			    "*pte = 0x%lx\n", pte, (uint64_t)*pte);
+		}
 #endif
+	}
 	return (0);
+}
 DMA_COUNT_DECL(load);
 DMA_COUNT_DECL(load_next_window);
 int
 __C(SGMAP_TYPE,_load)(bus_dma_tag_t t, bus_dmamap_t map, void *buf,
     bus_size_t buflen, struct proc *p, int flags, struct alpha_sgmap *sgmap)
+{
 	int seg, error;
 	struct vmspace *vm;
 	/*
 	 * Make sure that on error condition we return "no valid mappings".
 	 */
 	map->dm_mapsize = 0;
 	map->dm_nsegs = 0;
 	if (buflen > map->_dm_size)
 		return (EINVAL);
 	KASSERT((map->_dm_flags & (BUS_DMA_READ|BUS_DMA_WRITE)) == 0);
 	KASSERT((flags & (BUS_DMA_READ|BUS_DMA_WRITE)) !=
 	    (BUS_DMA_READ|BUS_DMA_WRITE));
 	map->_dm_flags |= flags & (BUS_DMA_READ|BUS_DMA_WRITE);
 	if (p != NULL) {
 		vm = p->p_vmspace;
 	} else {
 		vm = vmspace_kernel();
+	}
 	seg = 0;
 	error = __C(SGMAP_TYPE,_load_buffer)(t, map, buf, buflen, vm,
 	    flags, &seg, sgmap);
 	alpha_mb();
 #if defined(SGMAP_DEBUG) && defined(DDB)
 	if (__C(SGMAP_TYPE,_debug) > 1)
 		Debugger();
 #endif
 	if (error == 0) {
 		DMA_COUNT(load);
 		map->dm_mapsize = buflen;
 		map->dm_nsegs = seg + 1;
 		map->_dm_window = t;
 	} else {
 		map->_dm_flags &= ~(BUS_DMA_READ|BUS_DMA_WRITE);
 		if (t->_next_window != NULL) {
 			/* Give the next window a chance. */
 			DMA_COUNT(load_next_window);
 			error = bus_dmamap_load(t->_next_window, map, buf,
 			    buflen, p, flags);
+		}
+	}
 	return (error);
+}
 DMA_COUNT_DECL(load_mbuf);
 DMA_COUNT_DECL(load_mbuf_next_window);
 int
 __C(SGMAP_TYPE,_load_mbuf)(bus_dma_tag_t t, bus_dmamap_t map,
     struct mbuf *m0, int flags, struct alpha_sgmap *sgmap)
+{
 	struct mbuf *m;
 	int seg, error;
 	/*
 	 * Make sure that on error condition we return "no valid mappings".
 	 */
 	map->dm_mapsize = 0;
 	map->dm_nsegs = 0;
 #ifdef DIAGNOSTIC
 	if ((m0->m_flags & M_PKTHDR) == 0)
 		panic(__S(__C(SGMAP_TYPE,_load_mbuf)) ": no packet header");
 #endif
 	if (m0->m_pkthdr.len > map->_dm_size)
 		return (EINVAL);
 	KASSERT((map->_dm_flags & (BUS_DMA_READ|BUS_DMA_WRITE)) == 0);
 	KASSERT((flags & (BUS_DMA_READ|BUS_DMA_WRITE)) !=
 	    (BUS_DMA_READ|BUS_DMA_WRITE));
 	map->_dm_flags |= flags & (BUS_DMA_READ|BUS_DMA_WRITE);
 	seg = 0;
 	error = 0;
 	for (m = m0; m != NULL && error == 0; m = m->m_next) {
 		if (m->m_len == 0)
 			continue;
 		error = __C(SGMAP_TYPE,_load_buffer)(t, map,
 		    m->m_data, m->m_len, vmspace_kernel(), flags, &seg, sgmap);
 		seg++;
+	}
 	alpha_mb();
 #if defined(SGMAP_DEBUG) && defined(DDB)
 	if (__C(SGMAP_TYPE,_debug) > 1)
 		Debugger();
 #endif
 	if (error == 0) {
 		DMA_COUNT(load_mbuf);
 		map->dm_mapsize = m0->m_pkthdr.len;
 		map->dm_nsegs = seg;
 		map->_dm_window = t;
 	} else {
 		/* Need to back out what we've done so far. */
 		map->dm_nsegs = seg - 1;
 		__C(SGMAP_TYPE,_do_unload)(t, map, sgmap);
 		map->_dm_flags &= ~(BUS_DMA_READ|BUS_DMA_WRITE);
 		if (t->_next_window != NULL) {
 			/* Give the next window a chance. */
 			DMA_COUNT(load_mbuf_next_window);
 			error = bus_dmamap_load_mbuf(t->_next_window, map,
 			    m0, flags);
+		}
+	}
 	return (error);
+}
 DMA_COUNT_DECL(load_uio);
 DMA_COUNT_DECL(load_uio_next_window);
 int
 __C(SGMAP_TYPE,_load_uio)(bus_dma_tag_t t, bus_dmamap_t map, struct uio *uio,
     int flags, struct alpha_sgmap *sgmap)
+{
 	bus_size_t minlen, resid;
 	struct vmspace *vm;
 	struct iovec *iov;
 	void *addr;
 	int i, seg, error;
 	/*
 	 * Make sure that on error condition we return "no valid mappings".
 	 */
 	map->dm_mapsize = 0;
 	map->dm_nsegs = 0;
 	KASSERT((map->_dm_flags & (BUS_DMA_READ|BUS_DMA_WRITE)) == 0);
 	KASSERT((flags & (BUS_DMA_READ|BUS_DMA_WRITE)) !=
 	    (BUS_DMA_READ|BUS_DMA_WRITE));
 	map->_dm_flags |= flags & (BUS_DMA_READ|BUS_DMA_WRITE);
 	resid = uio->uio_resid;
 	iov = uio->uio_iov;
 	vm = uio->uio_vmspace;
 	seg = 0;
 	error = 0;
 	for (i = 0; i < uio->uio_iovcnt && resid != 0 && error == 0; i++) {
 		/*
 		 * Now at the first iovec to load.  Load each iovec
 		 * until we have exhausted the residual count.
 		 */
 		minlen = resid < iov[i].iov_len ? resid : iov[i].iov_len;
 		addr = (void *)iov[i].iov_base;
 		error = __C(SGMAP_TYPE,_load_buffer)(t, map,
 		    addr, minlen, vm, flags, &seg, sgmap);
 		seg++;
 		resid -= minlen;
+	}
 	alpha_mb();
 #if defined(SGMAP_DEBUG) && defined(DDB)
 	if (__C(SGMAP_TYPE,_debug) > 1)
 		Debugger();
 #endif
 	if (error == 0) {
 		DMA_COUNT(load_uio);
 		map->dm_mapsize = uio->uio_resid;
 		map->dm_nsegs = seg;
 		map->_dm_window = t;
 	} else {
 		/* Need to back out what we've done so far. */
 		map->dm_nsegs = seg - 1;
 		__C(SGMAP_TYPE,_do_unload)(t, map, sgmap);
 		map->_dm_flags &= ~(BUS_DMA_READ|BUS_DMA_WRITE);
 		if (t->_next_window != NULL) {
 			/* Give the next window a chance. */
 			DMA_COUNT(load_uio_next_window);
 			error = bus_dmamap_load_uio(t->_next_window, map,
 			    uio, flags);
+		}
+	}
 	return (error);
+}
 int
 __C(SGMAP_TYPE,_load_raw)(bus_dma_tag_t t, bus_dmamap_t map,
     bus_dma_segment_t *segs, int nsegs, bus_size_t size, int flags,
     struct alpha_sgmap *sgmap)
+{
 	KASSERT((map->_dm_flags & (BUS_DMA_READ|BUS_DMA_WRITE)) == 0);
 	KASSERT((flags & (BUS_DMA_READ|BUS_DMA_WRITE)) !=
 	    (BUS_DMA_READ|BUS_DMA_WRITE));
 	panic(__S(__C(SGMAP_TYPE,_load_raw)) ": not implemented");
+}
 static void
 __C(SGMAP_TYPE,_do_unload)(bus_dma_tag_t t, bus_dmamap_t map,
     struct alpha_sgmap *sgmap)
+{
 	SGMAP_PTE_TYPE *pte, *page_table = sgmap->aps_pt;
 	bus_addr_t osgva, sgva, esgva;
 	int spill, seg, pteidx;
 	for (seg = 0; seg < map->dm_nsegs; seg++) {
 		/*
 		 * XXX Always allocate a spill page for now.  Note
 		 * the spill page is not needed for an in-bound-only
 		 * transfer.
 		 */
 		if ((map->_dm_flags & BUS_DMA_READ) == 0)
 			spill = 1;
 		else
 			spill = 0;
 		sgva = map->dm_segs[seg].ds_addr & ~sgmap->aps_wbase;
 		esgva = round_page(sgva + map->dm_segs[seg].ds_len);
 		osgva = sgva = trunc_page(sgva);
 		if (spill)
 			esgva += PAGE_SIZE;
 		/* Invalidate the PTEs for the mapping. */
 		for (pteidx = sgva >> SGMAP_ADDR_PTEIDX_SHIFT;
 		     sgva < esgva; sgva += PAGE_SIZE, pteidx++) {
 			pte = &page_table[pteidx * SGMAP_PTE_SPACING];
 #ifdef SGMAP_DEBUG
 			if (__C(SGMAP_TYPE,_debug))
 				printf("sgmap_unload:     pte = %p, "
 				    "*pte = 0x%lx\n", pte, (u_long)(*pte));
 #endif
 			*pte = 0;
+		}
 		alpha_mb();
 		/* Free the virtual address space used by the mapping. */
 		vmem_xfree(sgmap->aps_arena, osgva, (esgva - osgva));
+	}
 	map->_dm_flags &= ~(BUS_DMA_READ|BUS_DMA_WRITE);
 	/* Mark the mapping invalid. */
 	map->dm_mapsize = 0;
 	map->dm_nsegs = 0;
 	map->_dm_window = NULL;
+}
 DMA_COUNT_DECL(unload);
 void
 __C(SGMAP_TYPE,_unload)(bus_dma_tag_t t, bus_dmamap_t map,
     struct alpha_sgmap *sgmap)
+{
 	KASSERT(map->_dm_window == t);
 	DMA_COUNT(unload);
 	__C(SGMAP_TYPE,_do_unload)(t, map, sgmap);
+}

 @@ -1,453 +1,459 @@
-/* $NetBSD: bus_defs.h,v 1.5 2019/09/23 16:17:54 skrll Exp $ */
+/* $NetBSD: bus_defs.h,v 1.6 2021/07/18 05:12:27 thorpej Exp $ */
 /*-
  * Copyright (c) 1997, 1998, 2000, 2001 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * 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
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``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.
  */
 /*
  * Copyright (c) 1996 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Author: Chris G. Demetriou
+ *
  * Permission to use, copy, modify and distribute this software and
  * its documentation is hereby granted, provided that both the copyright
  * notice and this permission notice appear in all copies of the
  * software, derivative works or modified versions, and any portions
  * thereof, and that both notices appear in supporting documentation.
+ *
  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ *
  * Carnegie Mellon requests users of this software to return to
+ *
  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  *  School of Computer Science
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 #ifndef _ALPHA_BUS_DEFS_H_
 #define	_ALPHA_BUS_DEFS_H_
 #include <sys/types.h>
 #include <machine/bus_user.h>
 #if !defined(_KERNEL) && !defined(_STANDALONE)
 #include <stdbool.h>
 #endif
 #include <sys/stdint.h>
 #ifdef _KERNEL
 /*
  * Turn on BUS_SPACE_DEBUG if the global DEBUG option is enabled.
  */
 #if defined(DEBUG) && !defined(BUS_SPACE_DEBUG)
 #define	BUS_SPACE_DEBUG
 #endif
 #ifdef BUS_SPACE_DEBUG
 #include <sys/systm.h> /* for printf() prototype */
 /*
  * Macros for checking the aligned-ness of pointers passed to bus
  * space ops.  Strict alignment is required by the Alpha architecture,
  * and a trap will occur if unaligned access is performed.  These
  * may aid in the debugging of a broken device driver by displaying
  * useful information about the problem.
  */
 #define	__BUS_SPACE_ALIGNED_ADDRESS(p, t)				\
 	((((u_long)(p)) & (sizeof(t)-1)) == 0)
 #define	__BUS_SPACE_ADDRESS_SANITY(p, t, d)				\
 ({									\
 	if (__BUS_SPACE_ALIGNED_ADDRESS((p), t) == 0) {			\
 		printf("%s 0x%lx not aligned to %lu bytes %s:%d\n",	\
 		    d, (u_long)(p), sizeof(t), __FILE__, __LINE__);	\
 	}								\
 	(void) 0;							\
 })
 #define BUS_SPACE_ALIGNED_POINTER(p, t) __BUS_SPACE_ALIGNED_ADDRESS(p, t)
 #else
 #define	__BUS_SPACE_ADDRESS_SANITY(p, t, d)	(void) 0
 #define BUS_SPACE_ALIGNED_POINTER(p, t) ALIGNED_POINTER(p, t)
 #endif /* BUS_SPACE_DEBUG */
 #endif /* _KERNEL */
 struct alpha_bus_space_translation;
 /*
  * Access methods for bus space.
  */
 typedef struct alpha_bus_space *bus_space_tag_t;
 typedef u_long bus_space_handle_t;
 #define PRIxBSH		"lx"
 struct alpha_bus_space {
 	/* cookie */
 	void		*abs_cookie;
 	/* mapping/unmapping */
 	int		(*abs_map)(void *, bus_addr_t, bus_size_t,
 			    int, bus_space_handle_t *, int);
 	void		(*abs_unmap)(void *, bus_space_handle_t,
 			    bus_size_t, int);
 	int		(*abs_subregion)(void *, bus_space_handle_t,
 			    bus_size_t, bus_size_t, bus_space_handle_t *);
 	/* ALPHA SPECIFIC MAPPING METHOD */
 	int		(*abs_translate)(void *, bus_addr_t, bus_size_t,
 			    int, struct alpha_bus_space_translation *);
 	int		(*abs_get_window)(void *, int,
 			    struct alpha_bus_space_translation *);
 	/* allocation/deallocation */
 	int		(*abs_alloc)(void *, bus_addr_t, bus_addr_t,
 			    bus_size_t, bus_size_t, bus_size_t, int,
 			    bus_addr_t *, bus_space_handle_t *);
 	void		(*abs_free)(void *, bus_space_handle_t,
 			    bus_size_t);
 	/* get kernel virtual address */
 	void *		(*abs_vaddr)(void *, bus_space_handle_t);
 	/* mmap bus space for user */
 	paddr_t		(*abs_mmap)(void *, bus_addr_t, off_t, int, int);
 	/* barrier */
 	void		(*abs_barrier)(void *, bus_space_handle_t,
 			    bus_size_t, bus_size_t, int);
 	/* read (single) */
 	uint8_t	(*abs_r_1)(void *, bus_space_handle_t,
 			    bus_size_t);
 	uint16_t	(*abs_r_2)(void *, bus_space_handle_t,
 			    bus_size_t);
 	uint32_t	(*abs_r_4)(void *, bus_space_handle_t,
 			    bus_size_t);
 	uint64_t	(*abs_r_8)(void *, bus_space_handle_t,
 			    bus_size_t);
 	/* read multiple */
 	void		(*abs_rm_1)(void *, bus_space_handle_t,
 			    bus_size_t, uint8_t *, bus_size_t);
 	void		(*abs_rm_2)(void *, bus_space_handle_t,
 			    bus_size_t, uint16_t *, bus_size_t);
 	void		(*abs_rm_4)(void *, bus_space_handle_t,
 			    bus_size_t, uint32_t *, bus_size_t);
 	void		(*abs_rm_8)(void *, bus_space_handle_t,
 			    bus_size_t, uint64_t *, bus_size_t);
 	/* read region */
 	void		(*abs_rr_1)(void *, bus_space_handle_t,
 			    bus_size_t, uint8_t *, bus_size_t);
 	void		(*abs_rr_2)(void *, bus_space_handle_t,
 			    bus_size_t, uint16_t *, bus_size_t);
 	void		(*abs_rr_4)(void *, bus_space_handle_t,
 			    bus_size_t, uint32_t *, bus_size_t);
 	void		(*abs_rr_8)(void *, bus_space_handle_t,
 			    bus_size_t, uint64_t *, bus_size_t);
 	/* write (single) */
 	void		(*abs_w_1)(void *, bus_space_handle_t,
 			    bus_size_t, uint8_t);
 	void		(*abs_w_2)(void *, bus_space_handle_t,
 			    bus_size_t, uint16_t);
 	void		(*abs_w_4)(void *, bus_space_handle_t,
 			    bus_size_t, uint32_t);
 	void		(*abs_w_8)(void *, bus_space_handle_t,
 			    bus_size_t, uint64_t);
 	/* write multiple */
 	void		(*abs_wm_1)(void *, bus_space_handle_t,
 			    bus_size_t, const uint8_t *, bus_size_t);
 	void		(*abs_wm_2)(void *, bus_space_handle_t,
 			    bus_size_t, const uint16_t *, bus_size_t);
 	void		(*abs_wm_4)(void *, bus_space_handle_t,
 			    bus_size_t, const uint32_t *, bus_size_t);
 	void		(*abs_wm_8)(void *, bus_space_handle_t,
 			    bus_size_t, const uint64_t *, bus_size_t);
 	/* write region */
 	void		(*abs_wr_1)(void *, bus_space_handle_t,
 			    bus_size_t, const uint8_t *, bus_size_t);
 	void		(*abs_wr_2)(void *, bus_space_handle_t,
 			    bus_size_t, const uint16_t *, bus_size_t);
 	void		(*abs_wr_4)(void *, bus_space_handle_t,
 			    bus_size_t, const uint32_t *, bus_size_t);
 	void		(*abs_wr_8)(void *, bus_space_handle_t,
 			    bus_size_t, const uint64_t *, bus_size_t);
 	/* set multiple */
 	void		(*abs_sm_1)(void *, bus_space_handle_t,
 			    bus_size_t, uint8_t, bus_size_t);
 	void		(*abs_sm_2)(void *, bus_space_handle_t,
 			    bus_size_t, uint16_t, bus_size_t);
 	void		(*abs_sm_4)(void *, bus_space_handle_t,
 			    bus_size_t, uint32_t, bus_size_t);
 	void		(*abs_sm_8)(void *, bus_space_handle_t,
 			    bus_size_t, uint64_t, bus_size_t);
 	/* set region */
 	void		(*abs_sr_1)(void *, bus_space_handle_t,
 			    bus_size_t, uint8_t, bus_size_t);
 	void		(*abs_sr_2)(void *, bus_space_handle_t,
 			    bus_size_t, uint16_t, bus_size_t);
 	void		(*abs_sr_4)(void *, bus_space_handle_t,
 			    bus_size_t, uint32_t, bus_size_t);
 	void		(*abs_sr_8)(void *, bus_space_handle_t,
 			    bus_size_t, uint64_t, bus_size_t);
 	/* copy */
 	void		(*abs_c_1)(void *, bus_space_handle_t, bus_size_t,
 			    bus_space_handle_t, bus_size_t, bus_size_t);
 	void		(*abs_c_2)(void *, bus_space_handle_t, bus_size_t,
 			    bus_space_handle_t, bus_size_t, bus_size_t);
 	void		(*abs_c_4)(void *, bus_space_handle_t, bus_size_t,
 			    bus_space_handle_t, bus_size_t, bus_size_t);
 	void		(*abs_c_8)(void *, bus_space_handle_t, bus_size_t,
 			    bus_space_handle_t, bus_size_t, bus_size_t);
 };
 #define	BUS_SPACE_MAP_CACHEABLE		0x01
 #ifdef _KERNEL
 #define	BUS_SPACE_BARRIER_READ	0x01
 #define	BUS_SPACE_BARRIER_WRITE	0x02
 /*
  * Bus stream operations--defined in terms of non-stream counterparts
  */
 #define __BUS_SPACE_HAS_STREAM_METHODS 1
 /*
  * Flags used in various bus DMA methods.
  */
 #define	BUS_DMA_WAITOK		0x000	/* safe to sleep (pseudo-flag) */
 #define	BUS_DMA_NOWAIT		0x001	/* not safe to sleep */
 #define	BUS_DMA_ALLOCNOW	0x002	/* perform resource allocation now */
 #define	BUS_DMA_COHERENT	0x004	/* hint: map memory DMA coherent */
 #define	BUS_DMA_STREAMING	0x008	/* hint: sequential, unidirectional */
 #define	BUS_DMA_BUS1		0x010	/* placeholders for bus functions... */
 #define	BUS_DMA_BUS2		0x020
 #define	BUS_DMA_BUS3		0x040
 #define	BUS_DMA_BUS4		0x080
 #define	BUS_DMA_READ		0x100	/* mapping is device -> memory only */
 #define	BUS_DMA_WRITE		0x200	/* mapping is memory -> device only */
 #define	BUS_DMA_NOCACHE		0x400	/* hint: map non-cached memory */
 /*
  * Private flags stored in the DMA map.
  */
 #define	DMAMAP_NO_COALESCE	0x40000000	/* don't coalesce adjacent
 						   segments */
 /* Forwards needed by prototypes below. */
 struct mbuf;
 struct uio;
 struct alpha_sgmap;
 /*
  * Operations performed by bus_dmamap_sync().
  */
 #define	BUS_DMASYNC_PREREAD	0x01	/* pre-read synchronization */
 #define	BUS_DMASYNC_POSTREAD	0x02	/* post-read synchronization */
 #define	BUS_DMASYNC_PREWRITE	0x04	/* pre-write synchronization */
 #define	BUS_DMASYNC_POSTWRITE	0x08	/* post-write synchronization */
 /*
  *	alpha_bus_t
+ *
  *	Busses supported by NetBSD/alpha, used by internal
  *	utility functions.  NOT TO BE USED BY MACHINE-INDEPENDENT
  *	CODE!
  */
 typedef enum {
 	ALPHA_BUS_TURBOCHANNEL,
 	ALPHA_BUS_PCI,
 	ALPHA_BUS_EISA,
 	ALPHA_BUS_ISA,
 	ALPHA_BUS_TLSB,
 } alpha_bus_t;
 typedef struct alpha_bus_dma_tag	*bus_dma_tag_t;
 typedef struct alpha_bus_dmamap		*bus_dmamap_t;
 #define BUS_DMA_TAG_VALID(t)    ((t) != (bus_dma_tag_t)0)
 /*
  *	bus_dma_segment_t
+ *
  *	Describes a single contiguous DMA transaction.  Values
  *	are suitable for programming into DMA registers.
  */
 struct alpha_bus_dma_segment {
 	bus_addr_t	ds_addr;	/* DMA address */
 	bus_size_t	ds_len;		/* length of transfer */
 };
 typedef struct alpha_bus_dma_segment	bus_dma_segment_t;
 /*
  *	bus_dma_tag_t
+ *
  *	A machine-dependent opaque type describing the implementation of
  *	DMA for a given bus.
  */
 struct alpha_bus_dma_tag {
 	void	*_cookie;		/* cookie used in the guts */
 	bus_addr_t _wbase;		/* DMA window base */
 	/*
 	 * The following two members are used to chain DMA windows
 	 * together.  If, during the course of a map load, the
 	 * resulting physical memory address is too large to
 	 * be addressed by the window, the next window will be
 	 * attempted.  These would be chained together like so:
+	 *
 	 *	direct -> sgmap -> NULL
 	 *  or
 	 *	sgmap -> NULL
 	 *  or
 	 *	direct -> NULL
+	 *
 	 * If the window size is 0, it will not be checked (e.g.
 	 * TURBOchannel DMA).
 	 */
 	bus_size_t _wsize;
 	struct alpha_bus_dma_tag *_next_window;
 	/*
 	 * Some chipsets have a built-in boundary constraint, independent
 	 * of what the device requests.  This allows that boundary to
 	 * be specified.  If the device has a more restrictive constraint,
 	 * the map will use that, otherwise this boundary will be used.
 	 * This value is ignored if 0.
 	 */
 	bus_size_t _boundary;
 	/*
 	 * A chipset may have more than one SGMAP window, so SGMAP
 	 * windows also get a pointer to their SGMAP state.
 	 */
 	struct alpha_sgmap *_sgmap;
 	/*
 	 * Some chipsets may want to enforce a minimum alignment
 	 * constraint for SGMAP DMA addresses.
 	 */
 	bus_size_t _sgmap_minalign;
 	/*
 	 * The SGMAP MMU implements a prefetch FIFO to keep data
 	 * moving down the pipe, when doing host->bus DMA writes.
 	 * The threshold (distance until the next page) used to
 	 * trigger the prefetch is differnet on different chipsets,
 	 * and we need to know what it is in order to know whether
 	 * or not to allocate a spill page.
 	 */
 	bus_size_t _pfthresh;
 	/*
 	 * Internal-use only utility methods.  NOT TO BE USED BY
 	 * MACHINE-INDEPENDENT CODE!
 	 */
 	bus_dma_tag_t (*_get_tag)(bus_dma_tag_t, alpha_bus_t);
 	/*
 	 * DMA mapping methods.
 	 */
 	int	(*_dmamap_create)(bus_dma_tag_t, bus_size_t, int,
 		    bus_size_t, bus_size_t, int, bus_dmamap_t *);
 	void	(*_dmamap_destroy)(bus_dma_tag_t, bus_dmamap_t);
 	int	(*_dmamap_load)(bus_dma_tag_t, bus_dmamap_t, void *,
 		    bus_size_t, struct proc *, int);
 	int	(*_dmamap_load_mbuf)(bus_dma_tag_t, bus_dmamap_t,
 		    struct mbuf *, int);
 	int	(*_dmamap_load_uio)(bus_dma_tag_t, bus_dmamap_t,
 		    struct uio *, int);
 	int	(*_dmamap_load_raw)(bus_dma_tag_t, bus_dmamap_t,
 		    bus_dma_segment_t *, int, bus_size_t, int);
 	void	(*_dmamap_unload)(bus_dma_tag_t, bus_dmamap_t);
 	void	(*_dmamap_sync)(bus_dma_tag_t, bus_dmamap_t,
 		    bus_addr_t, bus_size_t, int);
 	/*
 	 * DMA memory utility functions.
 	 */
 	int	(*_dmamem_alloc)(bus_dma_tag_t, bus_size_t, bus_size_t,
 		    bus_size_t, bus_dma_segment_t *, int, int *, int);
 	void	(*_dmamem_free)(bus_dma_tag_t,
 		    bus_dma_segment_t *, int);
 	int	(*_dmamem_map)(bus_dma_tag_t, bus_dma_segment_t *,
 		    int, size_t, void **, int);
 	void	(*_dmamem_unmap)(bus_dma_tag_t, void *, size_t);
 	paddr_t	(*_dmamem_mmap)(bus_dma_tag_t, bus_dma_segment_t *,
 		    int, off_t, int, int);
 };
 #define	alphabus_dma_get_tag(t, b)				\
 	(*(t)->_get_tag)(t, b)
 /*
  *	bus_dmamap_t
+ *
  *	Describes a DMA mapping.
  */
 struct alpha_bus_dmamap {
 	/*
 	 * PRIVATE MEMBERS: not for use my machine-independent code.
 	 */
 	bus_size_t	_dm_size;	/* largest DMA transfer mappable */
 	int		_dm_segcnt;	/* number of segs this map can map */
 	bus_size_t	_dm_maxmaxsegsz; /* fixed largest possible segment */
 	bus_size_t	_dm_boundary;	/* don't cross this */
 	int		_dm_flags;	/* misc. flags */
 	/*
 	 * Private cookie to be used by the DMA back-end.
 	 */
 	void		*_dm_cookie;
 	/*
 	 * The DMA window that we ended up being mapped in.
 	 */
 	bus_dma_tag_t	_dm_window;
 	/*
 	 * PUBLIC MEMBERS: these are used by machine-independent code.
 	 */
 	bus_size_t	dm_maxsegsz;	/* largest possible segment */
 	bus_size_t	dm_mapsize;	/* size of the mapping */
 	int		dm_nsegs;	/* # valid segments in mapping */
 	bus_dma_segment_t dm_segs[1];	/* segments; variable length */
 };
 #endif /* _KERNEL */
 #endif /* _ALPHA_BUS_DEFS_H_ */

 @@ -1,210 +1,211 @@
-/* $NetBSD: tc_dma_3000_500.c,v 1.23 2020/11/18 02:04:30 thorpej Exp $ */
+/* $NetBSD: tc_dma_3000_500.c,v 1.24 2021/07/18 05:12:27 thorpej Exp $ */
 /*-
  * Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * 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
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``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>			/* RCS ID & Copyright macro defns */
-__KERNEL_RCSID(0, "$NetBSD: tc_dma_3000_500.c,v 1.23 2020/11/18 02:04:30 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: tc_dma_3000_500.c,v 1.24 2021/07/18 05:12:27 thorpej Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #define _ALPHA_BUS_DMA_PRIVATE
 #include <sys/bus.h>
 #include <dev/tc/tcvar.h>
 #include <alpha/tc/tc_sgmap.h>
 #include <alpha/tc/tc_dma_3000_500.h>
 struct alpha_bus_dma_tag tc_dmat_sgmap = {
 	NULL,				/* _cookie */
 ,				/* _wbase */
 ,				/* _wsize */
 	NULL,				/* _next_window */
 ,				/* _boundary */
 	NULL,				/* _sgmap */
 	PAGE_SIZE,			/* _sgmap_minalign */
 ,				/* _pfthresh */
 	NULL,				/* _get_tag */
 	tc_bus_dmamap_create_sgmap,
 	tc_bus_dmamap_destroy_sgmap,
 	tc_bus_dmamap_load_sgmap,
 	tc_bus_dmamap_load_mbuf_sgmap,
 	tc_bus_dmamap_load_uio_sgmap,
 	tc_bus_dmamap_load_raw_sgmap,
 	tc_bus_dmamap_unload_sgmap,
 	_bus_dmamap_sync,
 	_bus_dmamem_alloc,
 	_bus_dmamem_free,
 	_bus_dmamem_map,
 	_bus_dmamem_unmap,
 	_bus_dmamem_mmap,
 };
 struct tc_dma_slot_info {
 	struct alpha_sgmap tdsi_sgmap;		/* sgmap for slot */
 	struct alpha_bus_dma_tag tdsi_dmat;	/* dma tag for slot */
 };
 struct tc_dma_slot_info *tc_dma_slot_info;
 void
 tc_dma_init_3000_500(int nslots)
+{
 	extern struct alpha_bus_dma_tag tc_dmat_direct;
 	size_t sisize;
 	int i;
 	/* Allocate per-slot DMA info. */
 	sisize = nslots * sizeof(struct tc_dma_slot_info);
 	tc_dma_slot_info = kmem_zalloc(sisize, KM_SLEEP);
 	/* Default all slots to direct-mapped. */
 	for (i = 0; i < nslots; i++)
 		memcpy(&tc_dma_slot_info[i].tdsi_dmat, &tc_dmat_direct,
 		    sizeof(tc_dma_slot_info[i].tdsi_dmat));
+}
 /*
  * Return the DMA tag for the given slot.
  */
 bus_dma_tag_t
 tc_dma_get_tag_3000_500(int slot)
+{
 	return (&tc_dma_slot_info[slot].tdsi_dmat);
+}
 /*
  * Create a TURBOchannel SGMAP-mapped DMA map.
  */
 int
 tc_bus_dmamap_create_sgmap(
 	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)
+{
 	int error;
 	error = _bus_dmamap_create(t, size, nsegments, maxsegsz,
 	    boundary, flags, dmamp);
 	if (error)
 		return (error);
 	(void)*dmamp;
 	/* XXX BUS_DMA_ALLOCNOW */
 	return (error);
+}
 /*
  * Destroy a TURBOchannel SGMAP-mapped DMA map.
  */
 void
 tc_bus_dmamap_destroy_sgmap(bus_dma_tag_t t, bus_dmamap_t map)
+{
 	KASSERT(map->dm_mapsize == 0);
 	_bus_dmamap_destroy(t, map);
+}
 /*
  * Load a TURBOchannel SGMAP-mapped DMA map with a linear buffer.
  */
 int
 tc_bus_dmamap_load_sgmap(bus_dma_tag_t t, bus_dmamap_t map, void *buf, bus_size_t buflen, struct proc *p, int flags)
+{
 	struct tc_dma_slot_info *tdsi = t->_cookie;
 	return (tc_sgmap_load(t, map, buf, buflen, p, flags,
 	    &tdsi->tdsi_sgmap));
+}
 /*
  * Load a TURBOchannel SGMAP-mapped DMA map with an mbuf chain.
  */
 int
 tc_bus_dmamap_load_mbuf_sgmap(bus_dma_tag_t t, bus_dmamap_t map, struct mbuf *m, int flags)
+{
 	struct tc_dma_slot_info *tdsi = t->_cookie;
 	return (tc_sgmap_load_mbuf(t, map, m, flags, &tdsi->tdsi_sgmap));
+}
 /*
  * Load a TURBOchannel SGMAP-mapped DMA map with a uio.
  */
 int
 tc_bus_dmamap_load_uio_sgmap(bus_dma_tag_t t, bus_dmamap_t map, struct uio *uio, int flags)
+{
 	struct tc_dma_slot_info *tdsi = t->_cookie;
 	return (tc_sgmap_load_uio(t, map, uio, flags, &tdsi->tdsi_sgmap));
+}
 /*
  * Load a TURBOchannel SGMAP-mapped DMA map with raw memory.
  */
 int
 tc_bus_dmamap_load_raw_sgmap(bus_dma_tag_t t, bus_dmamap_t map, bus_dma_segment_t *segs, int nsegs, bus_size_t size, int flags)
+{
 	struct tc_dma_slot_info *tdsi = t->_cookie;
 	return (tc_sgmap_load_raw(t, map, segs, nsegs, size, flags,
 	    &tdsi->tdsi_sgmap));
+}
 /*
  * Unload a TURBOchannel SGMAP-mapped DMA map.
  */
 void
 tc_bus_dmamap_unload_sgmap(bus_dma_tag_t t, bus_dmamap_t map)
+{
 	struct tc_dma_slot_info *tdsi = t->_cookie;
 	/*
 	 * Invalidate any SGMAP page table entries used by this
 	 * mapping.
 	 */
 	tc_sgmap_unload(t, map, &tdsi->tdsi_sgmap);
 	/*
 	 * Do the generic bits of the unload.
 	 */
 	_bus_dmamap_unload_common(t, map);
+}