Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

First towards use of bus.h routines on vax. Allocate DMA memory for

Browse Source 
LANCE chip on vaxstations.
This commit is contained in:
ragge 1999-04-14 23:14:45 +00:00
parent c0735a01c5
commit 797a7428d6
10 changed files with 830 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
sys/arch/vax/conf/files.vax
View File

@ -1,4 +1,4 @@
# $NetBSD: files.vax,v 1.48 1999/03/26 22:04:07 ragge Exp $
# $NetBSD: files.vax,v 1.49 1999/04/14 23:14:45 ragge Exp $
#
# new style config file for vax architecture
#
@ -333,6 +333,7 @@ file arch/vax/vax/conf.c
file arch/vax/vax/urem.s
file arch/vax/vax/udiv.s
file arch/vax/vax/trap.c
file arch/vax/vax/bus_dma.c
file arch/vax/vax/vm_machdep.c
file arch/vax/vax/autoconf.c

10
sys/arch/vax/include/bus.h
View File

@ -1,4 +1,4 @@
/* $NetBSD: bus.h,v 1.4 1999/03/23 21:29:05 drochner Exp $ */
/* $NetBSD: bus.h,v 1.5 1999/04/14 23:14:46 ragge Exp $ */
/*-
* Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
@ -1059,13 +1059,13 @@ int _bus_dmamap_create __P((bus_dma_tag_t, bus_size_t, int, bus_size_t,
bus_size_t, int, bus_dmamap_t *));
void _bus_dmamap_destroy __P((bus_dma_tag_t, bus_dmamap_t));
int _bus_dmamap_load_direct __P((bus_dma_tag_t, bus_dmamap_t,
int _bus_dmamap_load __P((bus_dma_tag_t, bus_dmamap_t,
void *, bus_size_t, struct proc *, int));
int _bus_dmamap_load_mbuf_direct __P((bus_dma_tag_t,
int _bus_dmamap_load_mbuf __P((bus_dma_tag_t,
bus_dmamap_t, struct mbuf *, int));
int _bus_dmamap_load_uio_direct __P((bus_dma_tag_t,
int _bus_dmamap_load_uio __P((bus_dma_tag_t,
bus_dmamap_t, struct uio *, int));
int _bus_dmamap_load_raw_direct __P((bus_dma_tag_t,
int _bus_dmamap_load_raw __P((bus_dma_tag_t,
bus_dmamap_t, bus_dma_segment_t *, int, bus_size_t, int));
void _bus_dmamap_unload __P((bus_dma_tag_t, bus_dmamap_t));

9
sys/arch/vax/include/vsbus.h
View File

@ -1,4 +1,4 @@
/* $NetBSD: vsbus.h,v 1.7 1999/03/13 15:16:47 ragge Exp $ */
/* $NetBSD: vsbus.h,v 1.8 1999/04/14 23:14:46 ragge Exp $ */
/*
* Copyright (c) 1996 Ludd, University of Lule}, Sweden.
* All rights reserved.
@ -37,6 +37,11 @@
* used by all VAXstations.
*/
#ifndef _VAX_VSBUS_H_
#define _VAX_VSBUS_H_
#include <machine/bus.h>
struct vsbus_attach_args {
vaddr_t va_addr; /* virtual CSR address */
paddr_t va_paddr; /* physical CSR address */
@ -44,6 +49,7 @@ struct vsbus_attach_args {
short va_br; /* Interrupt level */
short va_cvec; /* Interrupt vector address */
u_char va_maskno; /* Interrupt vector in mask */
bus_dma_tag_t va_dmat;
};
/*
@ -66,3 +72,4 @@ struct vsbus_attach_args {
u_char vsbus_setmask __P((unsigned char));
void vsbus_clrintr __P((unsigned char));
#endif /* _VAX_VSBUS_H_ */

749
sys/arch/vax/vax/bus_dma.c Normal file
View File

@ -0,0 +1,749 @@
/* $NetBSD: bus_dma.c,v 1.1 1999/04/14 23:14:46 ragge Exp $ */
/*-
* Copyright (c) 1996, 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.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the NetBSD
* Foundation, Inc. and its contributors.
* 4. Neither the name of The NetBSD Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* 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.
*/
/*
* bus_dma routines for vax. File copied from arm32/bus_dma.c.
* NetBSD: bus_dma.c,v 1.11 1998/09/21 22:53:35 thorpej Exp
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/map.h>
#include <sys/proc.h>
#include <sys/buf.h>
#include <sys/reboot.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/vnode.h>
#include <sys/device.h>
#include <vm/vm.h>
#include <vm/vm_kern.h>
#include <vm/vm_page.h>
#include <uvm/uvm_extern.h>
#define _VAX_BUS_DMA_PRIVATE
#include <machine/bus.h>
#include <machine/ka43.h>
#include <machine/sid.h>
extern vaddr_t avail_start, avail_end, virtual_avail;
int _bus_dmamap_load_buffer __P((bus_dma_tag_t, bus_dmamap_t, void *,
bus_size_t, struct proc *, int, vm_offset_t *, int *, int));
int _bus_dma_inrange __P((bus_dma_segment_t *, int, bus_addr_t));
int _bus_dmamem_alloc_range __P((bus_dma_tag_t, bus_size_t, bus_size_t,
bus_size_t, bus_dma_segment_t*, int, int *, int, vaddr_t, vaddr_t));
/*
* Common function for DMA map creation. May be called by bus-specific
* DMA map creation functions.
*/
int
_bus_dmamap_create(t, size, nsegments, maxsegsz, boundary, flags, dmamp)
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 vax_bus_dmamap *map;
void *mapstore;
size_t mapsize;
#ifdef DEBUG_DMA
printf("dmamap_create: t=%p size=%lx nseg=%x msegsz=%lx boundary=%lx flags=%x\n",
t, size, nsegments, maxsegsz, boundary, flags);
#endif /* DEBUG_DMA */
/*
* Allocate and initialize the DMA map. The end of the map
* is a variable-sized array of segments, so we allocate enough
* room for them in one shot.
*
* Note we don't preserve the WAITOK or NOWAIT flags. Preservation
* of ALLOCNOW notifies others that we've reserved these resources,
* and they are not to be freed.
*
* The bus_dmamap_t includes one bus_dma_segment_t, hence
* the (nsegments - 1).
*/
mapsize = sizeof(struct vax_bus_dmamap) +
(sizeof(bus_dma_segment_t) * (nsegments - 1));
if ((mapstore = malloc(mapsize, M_DMAMAP,
(flags & BUS_DMA_NOWAIT) ? M_NOWAIT : M_WAITOK)) == NULL)
return (ENOMEM);
bzero(mapstore, mapsize);
map = (struct vax_bus_dmamap *)mapstore;
map->_dm_size = size;
map->_dm_segcnt = nsegments;
map->_dm_maxsegsz = maxsegsz;
map->_dm_boundary = boundary;
map->_dm_flags = flags & ~(BUS_DMA_WAITOK|BUS_DMA_NOWAIT);
map->dm_mapsize = 0; /* no valid mappings */
map->dm_nsegs = 0;
*dmamp = map;
#ifdef DEBUG_DMA
printf("dmamap_create:map=%p\n", map);
#endif /* DEBUG_DMA */
return (0);
}
/*
* Common function for DMA map destruction. May be called by bus-specific
* DMA map destruction functions.
*/
void
_bus_dmamap_destroy(t, map)
bus_dma_tag_t t;
bus_dmamap_t map;
{
#ifdef DEBUG_DMA
printf("dmamap_destroy: t=%p map=%p\n", t, map);
#endif /* DEBUG_DMA */
#ifdef DIAGNOSTIC
if (map->dm_nsegs > 0)
printf("bus_dmamap_destroy() called for map with valid mappings\n");
#endif /* DIAGNOSTIC */
free(map, M_DEVBUF);
}
/*
* Common function for loading a DMA map with a linear buffer. May
* be called by bus-specific DMA map load functions.
*/
int
_bus_dmamap_load(t, map, buf, buflen, p, flags)
bus_dma_tag_t t;
bus_dmamap_t map;
void *buf;
bus_size_t buflen;
struct proc *p;
int flags;
{
vm_offset_t lastaddr;
int seg, error;
#ifdef DEBUG_DMA
printf("dmamap_load: t=%p map=%p buf=%p len=%lx p=%p f=%d\n",
t, map, buf, buflen, p, flags);
#endif /* DEBUG_DMA */
/*
* 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);
seg = 0;
error = _bus_dmamap_load_buffer(t, map, buf, buflen, p, flags,
&lastaddr, &seg, 1);
if (error == 0) {
map->dm_mapsize = buflen;
map->dm_nsegs = seg + 1;
}
#ifdef DEBUG_DMA
printf("dmamap_load: error=%d\n", error);
#endif /* DEBUG_DMA */
return (error);
}
/*
* Like _bus_dmamap_load(), but for mbufs.
*/
int
_bus_dmamap_load_mbuf(t, map, m0, flags)
bus_dma_tag_t t;
bus_dmamap_t map;
struct mbuf *m0;
int flags;
{
vm_offset_t lastaddr;
int seg, error, first;
struct mbuf *m;
#ifdef DEBUG_DMA
printf("dmamap_load_mbuf: t=%p map=%p m0=%p f=%d\n",
t, map, m0, flags);
#endif /* DEBUG_DMA */
/*
* 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("_bus_dmamap_load_mbuf: no packet header");
#endif /* DIAGNOSTIC */
if (m0->m_pkthdr.len > map->_dm_size)
return (EINVAL);
first = 1;
seg = 0;
error = 0;
for (m = m0; m != NULL && error == 0; m = m->m_next) {
error = _bus_dmamap_load_buffer(t, map, m->m_data, m->m_len,
NULL, flags, &lastaddr, &seg, first);
first = 0;
}
if (error == 0) {
map->dm_mapsize = m0->m_pkthdr.len;
map->dm_nsegs = seg + 1;
}
#ifdef DEBUG_DMA
printf("dmamap_load_mbuf: error=%d\n", error);
#endif /* DEBUG_DMA */
return (error);
}
/*
* Like _bus_dmamap_load(), but for uios.
*/
int
_bus_dmamap_load_uio(t, map, uio, flags)
bus_dma_tag_t t;
bus_dmamap_t map;
struct uio *uio;
int flags;
{
vm_offset_t lastaddr;
int seg, i, error, first;
bus_size_t minlen, resid;
struct proc *p = NULL;
struct iovec *iov;
caddr_t addr;
/*
* Make sure that on error condition we return "no valid mappings."
*/
map->dm_mapsize = 0;
map->dm_nsegs = 0;
resid = uio->uio_resid;
iov = uio->uio_iov;
if (uio->uio_segflg == UIO_USERSPACE) {
p = uio->uio_procp;
#ifdef DIAGNOSTIC
if (p == NULL)
panic("_bus_dmamap_load_uio: USERSPACE but no proc");
#endif
}
first = 1;
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 = (caddr_t)iov[i].iov_base;
error = _bus_dmamap_load_buffer(t, map, addr, minlen,
p, flags, &lastaddr, &seg, first);
first = 0;
resid -= minlen;
}
if (error == 0) {
map->dm_mapsize = uio->uio_resid;
map->dm_nsegs = seg + 1;
}
return (error);
}
/*
* Like _bus_dmamap_load(), but for raw memory allocated with
* bus_dmamem_alloc().
*/
int
_bus_dmamap_load_raw(t, map, segs, nsegs, size, flags)
bus_dma_tag_t t;
bus_dmamap_t map;
bus_dma_segment_t *segs;
int nsegs;
bus_size_t size;
int flags;
{
panic("_bus_dmamap_load_raw: not implemented");
}
/*
* Common function for unloading a DMA map. May be called by
* bus-specific DMA map unload functions.
*/
void
_bus_dmamap_unload(t, map)
bus_dma_tag_t t;
bus_dmamap_t map;
{
#ifdef DEBUG_DMA
printf("dmamap_unload: t=%p map=%p\n", t, map);
#endif /* DEBUG_DMA */
/*
* No resources to free; just mark the mappings as
* invalid.
*/
map->dm_mapsize = 0;
map->dm_nsegs = 0;
}
/*
* Common function for DMA map synchronization. May be called
* by bus-specific DMA map synchronization functions.
*/
void
_bus_dmamap_sync(t, map, offset, len, ops)
bus_dma_tag_t t;
bus_dmamap_t map;
bus_addr_t offset;
bus_size_t len;
int ops;
{
#ifdef DEBUG_DMA
printf("dmamap_sync: t=%p map=%p offset=%lx len=%lx ops=%x\n",
t, map, offset, len, ops);
#endif /* DEBUG_DMA */
/*
* A vax only has snoop-cache, so this routine is a no-op.
*/
return;
}
/*
* Common function for DMA-safe memory allocation. May be called
* by bus-specific DMA memory allocation functions.
*/
int
_bus_dmamem_alloc(t, size, alignment, boundary, segs, nsegs, rsegs, flags)
bus_dma_tag_t t;
bus_size_t size, alignment, boundary;
bus_dma_segment_t *segs;
int nsegs;
int *rsegs;
int flags;
{
int error;
error = (_bus_dmamem_alloc_range(t, size, alignment, boundary,
segs, nsegs, rsegs, flags, round_page(avail_start),
trunc_page(avail_end)));
return(error);
}
/*
* Common function for freeing DMA-safe memory. May be called by
* bus-specific DMA memory free functions.
*/
void
_bus_dmamem_free(t, segs, nsegs)
bus_dma_tag_t t;
bus_dma_segment_t *segs;
int nsegs;
{
vm_page_t m;
bus_addr_t addr;
struct pglist mlist;
int curseg;
#ifdef DEBUG_DMA
printf("dmamem_free: t=%p segs=%p nsegs=%x\n", t, segs, nsegs);
#endif /* DEBUG_DMA */
/*
* Build a list of pages to free back to the VM system.
*/
TAILQ_INIT(&mlist);
for (curseg = 0; curseg < nsegs; curseg++) {
for (addr = segs[curseg].ds_addr;
addr < (segs[curseg].ds_addr + segs[curseg].ds_len);
addr += PAGE_SIZE) {
m = PHYS_TO_VM_PAGE(addr);
TAILQ_INSERT_TAIL(&mlist, m, pageq);
}
}
uvm_pglistfree(&mlist);
}
/*
* Common function for mapping DMA-safe memory. May be called by
* bus-specific DMA memory map functions.
*/
int
_bus_dmamem_map(t, segs, nsegs, size, kvap, flags)
bus_dma_tag_t t;
bus_dma_segment_t *segs;
int nsegs;
size_t size;
caddr_t *kvap;
int flags;
{
vm_offset_t va;
bus_addr_t addr;
int curseg;
/*
* Special case (but common):
* If there is only one physical segment then the already-mapped
* virtual address is returned, since all physical memory is already
* in the beginning of kernel virtual memory.
*/
if (nsegs == 1) {
*kvap = (caddr_t)(segs[0].ds_addr | KERNBASE);
/*
* KA43 (3100/m76) must have its DMA-safe memory accessed
* through DIAGMEM. Remap it here.
*/
if (vax_boardtype == VAX_BTYP_43) {
pmap_map((vaddr_t)*kvap, segs[0].ds_addr|KA43_DIAGMEM,
(segs[0].ds_addr|KA43_DIAGMEM) + size,
VM_PROT_READ|VM_PROT_WRITE);
}
return 0;
}
size = round_page(size);
va = uvm_km_valloc(kernel_map, size);
if (va == 0)
return (ENOMEM);
*kvap = (caddr_t)va;
for (curseg = 0; curseg < nsegs; curseg++) {
for (addr = segs[curseg].ds_addr;
addr < (segs[curseg].ds_addr + segs[curseg].ds_len);
addr += NBPG, va += NBPG, size -= NBPG) {
if (size == 0)
panic("_bus_dmamem_map: size botch");
if (vax_boardtype == VAX_BTYP_43)
addr |= KA43_DIAGMEM;
pmap_kenter_pa(va, addr, VM_PROT_READ | VM_PROT_WRITE);
}
}
return (0);
}
/*
* Common function for unmapping DMA-safe memory. May be called by
* bus-specific DMA memory unmapping functions.
*/
void
_bus_dmamem_unmap(t, kva, size)
bus_dma_tag_t t;
caddr_t kva;
size_t size;
{
#ifdef DEBUG_DMA
printf("dmamem_unmap: t=%p kva=%p size=%x\n", t, kva, size);
#endif /* DEBUG_DMA */
#ifdef DIAGNOSTIC
if ((u_long)kva & PGOFSET)
panic("_bus_dmamem_unmap");
#endif /* DIAGNOSTIC */
/* Avoid free'ing if not mapped */
if (kva >= (caddr_t)virtual_avail)
uvm_km_free(kernel_map, (vm_offset_t)kva, round_page(size));
}
/*
* Common functin for mmap(2)'ing DMA-safe memory. May be called by
* bus-specific DMA mmap(2)'ing functions.
*/
int
_bus_dmamem_mmap(t, segs, nsegs, off, prot, flags)
bus_dma_tag_t t;
bus_dma_segment_t *segs;
int nsegs, off, prot, flags;
{
int i;
for (i = 0; i < nsegs; i++) {
#ifdef DIAGNOSTIC
if (off & PGOFSET)
panic("_bus_dmamem_mmap: offset unaligned");
if (segs[i].ds_addr & PGOFSET)
panic("_bus_dmamem_mmap: segment unaligned");
if (segs[i].ds_len & PGOFSET)
panic("_bus_dmamem_mmap: segment size not multiple"
" of page size");
#endif /* DIAGNOSTIC */
if (off >= segs[i].ds_len) {
off -= segs[i].ds_len;
continue;
}
return (btop((u_long)segs[i].ds_addr + off));
}
/* Page not found. */
return (-1);
}
/**********************************************************************
* DMA utility functions
**********************************************************************/
/*
* Utility function to load a linear buffer. lastaddrp holds state
* between invocations (for multiple-buffer loads). segp contains
* the starting segment on entrace, and the ending segment on exit.
* first indicates if this is the first invocation of this function.
*/
int
_bus_dmamap_load_buffer(t, map, buf, buflen, p, flags, lastaddrp, segp, first)
bus_dma_tag_t t;
bus_dmamap_t map;
void *buf;
bus_size_t buflen;
struct proc *p;
int flags;
vm_offset_t *lastaddrp;
int *segp;
int first;
{
bus_size_t sgsize;
bus_addr_t curaddr, lastaddr, baddr, bmask;
vm_offset_t vaddr = (vm_offset_t)buf;
int seg;
pmap_t pmap;
#ifdef DEBUG_DMA
printf("_bus_dmamem_load_buffer(buf=%p, len=%lx, flags=%d, 1st=%d)\n",
buf, buflen, flags, first);
#endif /* DEBUG_DMA */
if (p != NULL)
pmap = p->p_vmspace->vm_map.pmap;
else
pmap = pmap_kernel();
lastaddr = *lastaddrp;
bmask = ~(map->_dm_boundary - 1);
for (seg = *segp; buflen > 0; ) {
/*
* Get the physical address for this segment.
*/
curaddr = pmap_extract(pmap, (vm_offset_t)vaddr);
#if 0
/*
* Make sure we're in an allowed DMA range.
*/
if (t->_ranges != NULL &&
_bus_dma_inrange(t->_ranges, t->_nranges, curaddr) == 0)
return (EINVAL);
#endif
/*
* Compute the segment size, and adjust counts.
*/
sgsize = NBPG - ((u_long)vaddr & PGOFSET);
if (buflen < sgsize)
sgsize = buflen;
/*
* Make sure we don't cross any boundaries.
*/
if (map->_dm_boundary > 0) {
baddr = (curaddr + map->_dm_boundary) & bmask;
if (sgsize > (baddr - curaddr))
sgsize = (baddr - curaddr);
}
/*
* Insert chunk into a segment, coalescing with
* previous segment if possible.
*/
if (first) {
map->dm_segs[seg].ds_addr = curaddr;
map->dm_segs[seg].ds_len = sgsize;
first = 0;
} else {
if (curaddr == lastaddr &&
(map->dm_segs[seg].ds_len + sgsize) <=
map->_dm_maxsegsz &&
(map->_dm_boundary == 0 ||
(map->dm_segs[seg].ds_addr & bmask) ==
(curaddr & bmask)))
map->dm_segs[seg].ds_len += sgsize;
else {
if (++seg >= map->_dm_segcnt)
break;
map->dm_segs[seg].ds_addr = curaddr;
map->dm_segs[seg].ds_len = sgsize;
}
}
lastaddr = curaddr + sgsize;
vaddr += sgsize;
buflen -= sgsize;
}
*segp = seg;
*lastaddrp = lastaddr;
/*
* Did we fit?
*/
if (buflen != 0)
return (EFBIG); /* XXX better return value here? */
return (0);
}
/*
* Check to see if the specified page is in an allowed DMA range.
*/
int
_bus_dma_inrange(ranges, nranges, curaddr)
bus_dma_segment_t *ranges;
int nranges;
bus_addr_t curaddr;
{
bus_dma_segment_t *ds;
int i;
for (i = 0, ds = ranges; i < nranges; i++, ds++) {
if (curaddr >= ds->ds_addr &&
round_page(curaddr) <= (ds->ds_addr + ds->ds_len))
return (1);
}
return (0);
}
/*
* Allocate physical memory from the given physical address range.
* Called by DMA-safe memory allocation methods.
*/
int
_bus_dmamem_alloc_range(t, size, alignment, boundary, segs, nsegs, rsegs,
flags, low, high)
bus_dma_tag_t t;
bus_size_t size, alignment, boundary;
bus_dma_segment_t *segs;
int nsegs;
int *rsegs;
int flags;
vm_offset_t low;
vm_offset_t high;
{
vm_offset_t curaddr, lastaddr;
vm_page_t m;
struct pglist mlist;
int curseg, error;
#ifdef DEBUG_DMA
printf("alloc_range: t=%p size=%lx align=%lx boundary=%lx segs=%p nsegs=%x rsegs=%p flags=%x lo=%lx hi=%lx\n",
t, size, alignment, boundary, segs, nsegs, rsegs, flags, low, high);
#endif /* DEBUG_DMA */
/* Always round the size. */
size = round_page(size);
/*
* Allocate pages from the VM system.
*/
TAILQ_INIT(&mlist);
error = uvm_pglistalloc(size, low, high, alignment, boundary,
&mlist, nsegs, (flags & BUS_DMA_NOWAIT) == 0);
if (error)
return (error);
/*
* Compute the location, size, and number of segments actually
* returned by the VM code.
*/
m = mlist.tqh_first;
curseg = 0;
lastaddr = segs[curseg].ds_addr = VM_PAGE_TO_PHYS(m);
segs[curseg].ds_len = PAGE_SIZE;
#ifdef DEBUG_DMA
printf("alloc: page %lx\n", lastaddr);
#endif /* DEBUG_DMA */
m = m->pageq.tqe_next;
for (; m != NULL; m = m->pageq.tqe_next) {
curaddr = VM_PAGE_TO_PHYS(m);
#ifdef DIAGNOSTIC
if (curaddr < low || curaddr >= high) {
printf("vm_page_alloc_memory returned non-sensical"
" address 0x%lx\n", curaddr);
panic("_bus_dmamem_alloc_range");
}
#endif /* DIAGNOSTIC */
#ifdef DEBUG_DMA
printf("alloc: page %lx\n", curaddr);
#endif /* DEBUG_DMA */
if (curaddr == (lastaddr + PAGE_SIZE))
segs[curseg].ds_len += PAGE_SIZE;
else {
curseg++;
segs[curseg].ds_addr = curaddr;
segs[curseg].ds_len = PAGE_SIZE;
}
lastaddr = curaddr;
}
*rsegs = curseg + 1;
return (0);
}

15
sys/arch/vax/vax/ka410.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: ka410.c,v 1.17 1999/03/13 15:16:48 ragge Exp $ */
/* $NetBSD: ka410.c,v 1.18 1999/04/14 23:14:46 ragge Exp $ */
/*
* Copyright (c) 1996 Ludd, University of Lule}, Sweden.
* All rights reserved.
@ -54,7 +54,6 @@
#include <machine/vsbus.h>
static void ka410_conf __P((struct device*, struct device*, void*));
static void ka410_steal_pages __P((void));
static void ka410_memerr __P((void));
static int ka410_mchk __P((caddr_t));
static void ka410_halt __P((void));
@ -71,7 +70,7 @@ extern short *clk_page;
* Declaration of 410-specific calls.
*/
struct cpu_dep ka410_calls = {
ka410_steal_pages,
0,
no_nicr_clock,
ka410_mchk,
ka410_memerr,
@ -149,16 +148,6 @@ ka410_mchk(addr)
return 0;
}
extern caddr_t le_iomem;
void
ka410_steal_pages()
{
extern vaddr_t avail_start;
MAPPHYS(le_iomem, (NI_IOSIZE/VAX_NBPG), VM_PROT_READ|VM_PROT_WRITE);
}
static void
ka410_halt()
{

34
sys/arch/vax/vax/ka43.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: ka43.c,v 1.15 1999/03/13 15:16:48 ragge Exp $ */
/* $NetBSD: ka43.c,v 1.16 1999/04/14 23:14:46 ragge Exp $ */
/*
* Copyright (c) 1996 Ludd, University of Lule}, Sweden.
* All rights reserved.
@ -90,11 +90,11 @@ struct cpu_dep ka43_calls = {
* enabled. Thus we initialize these four pointers with physical addresses,
* but before leving ka43_steal_pages() we reset them to virtual addresses.
*/
struct ka43_cpu *ka43_cpu = (void*)KA43_CPU_BASE;
static volatile struct ka43_cpu *ka43_cpu = (void*)KA43_CPU_BASE;
extern short *clk_page;
u_int *ka43_creg = (void*)KA43_CH2_CREG;
u_int *ka43_ctag = (void*)KA43_CT2_BASE;
static volatile u_int *ka43_creg = (void*)KA43_CH2_CREG;
static volatile u_int *ka43_ctag = (void*)KA43_CT2_BASE;
#define KA43_MC_RESTART 0x00008000 /* Restart possible*/
#define KA43_PSL_FPDONE 0x00010000 /* First Part Done */
@ -327,7 +327,6 @@ ka43_conf(parent, self, aux)
}
extern caddr_t le_iomem;
/*
* The interface for communication with the LANCE ethernet controller
* is setup in the xxx_steal_pages() routine. We decrease highest
@ -337,24 +336,9 @@ extern caddr_t le_iomem;
void
ka43_steal_pages()
{
extern vaddr_t avail_start;
int val;
/*
* Oh holy shit! It took me over one year(!) to find out that
* the 3100/76 has to use diag-mem instead of physical memory
* for communication with LANCE (using phys-mem results in
* parity errors and mchk exceptions with code 17 (0x11)).
*
* Many thanks to Matt Thomas, without his help it could have
* been some more years... ;-)
*/
#define LEMEM (((int)le_iomem & ~KERNBASE)|KA43_DIAGMEM)
MAPPHYS(le_iomem, (NI_IOSIZE/VAX_NBPG), VM_PROT_READ|VM_PROT_WRITE);
pmap_map((vm_offset_t)le_iomem, LEMEM, LEMEM + NI_IOSIZE,
VM_PROT_READ|VM_PROT_WRITE);
/*
* if LANCE\'s io-buffer is above 16 MB, then the appropriate flag
* in the parity control register has to be set (it works as an
@ -363,17 +347,7 @@ ka43_steal_pages()
* by the RIGEL chip itself!?!
*/
val = ka43_cpu->parctl & 0x03; /* read the old value */
if (((int)le_iomem & ~KERNBASE) > 0xffffff)
val |= KA43_PCTL_DMA;
ka43_cpu->parctl = val; /* and write new value */
#if 0
/*
* Clear all error flags, not really neccessary here, this will
* be done by ka43_cache_init() anyway...
*/
ka43_clear_errors();
#endif
}
static void

8
sys/arch/vax/vax/ka46.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: ka46.c,v 1.6 1999/03/13 15:16:48 ragge Exp $ */
/* $NetBSD: ka46.c,v 1.7 1999/04/14 23:14:46 ragge Exp $ */
/*
* Copyright (c) 1998 Ludd, University of Lule}, Sweden.
* All rights reserved.
@ -148,16 +148,12 @@ ka46_mchk(addr)
return 0;
}
extern caddr_t le_iomem;
void
ka46_steal_pages()
{
extern vm_offset_t avail_start, virtual_avail, avail_end;
extern vm_offset_t virtual_avail, avail_end;
int i;
MAPPHYS(le_iomem, (NI_IOSIZE/VAX_NBPG), VM_PROT_READ|VM_PROT_WRITE);
/* Turn on caches (to speed up execution a bit) */
ka46_cache_enable();
/*

6
sys/arch/vax/vax/ka48.c
View File

@ -150,16 +150,12 @@ ka48_mchk(addr)
return 0;
}
extern caddr_t le_iomem;
void
ka48_steal_pages()
{
extern vm_offset_t avail_start, virtual_avail, avail_end;
extern vm_offset_t virtual_avail, avail_end;
int i;
MAPPHYS(le_iomem, (NI_IOSIZE/VAX_NBPG), VM_PROT_READ|VM_PROT_WRITE);
/* Turn on caches (to speed up execution a bit) */
ka48_cache_enable();
/*

36
sys/arch/vax/vsa/if_ln.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: if_ln.c,v 1.11 1999/03/13 15:16:48 ragge Exp $ */
/* $NetBSD: if_ln.c,v 1.12 1999/04/14 23:14:46 ragge Exp $ */
/*-
* Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
@ -129,6 +129,8 @@
#include <dev/ic/lancereg.h>
#include <dev/ic/am7990reg.h>
#include <machine/bus.h>
#include <machine/cpu.h>
#include <machine/rpb.h>
#include <machine/vsbus.h>
@ -193,6 +195,9 @@ struct ln_softc {
struct ethercom sc_ethercom; /* Ethernet common part */
struct initblock *sc_ib; /* LANCE initblock */
caddr_t sc_memblk; /* Memory descr/buffer block */
bus_dma_tag_t sc_dmat;
bus_dmamap_t sc_dmamap;
struct buffdesc *sc_rdesc;
struct buffdesc *sc_tdesc;
int sc_first_td, sc_last_td, sc_no_td;
@ -218,8 +223,6 @@ void ln_reset __P((struct ln_softc *));
static short *lance_csr; /* LANCE CSR virtual address */
static int *lance_addr; /* Ethernet address */
caddr_t le_iomem;
struct cfattach ln_ca = {
sizeof(struct ln_softc), lnmatch, lnattach
};
@ -256,15 +259,38 @@ lnattach(parent, self, aux)
struct device *parent, *self;
void *aux;
{
struct vsbus_attach_args *va = aux;
struct ln_softc *sc = (void *)self;
u_int highmark;
int i;
bus_dma_segment_t seg;
int i, err, rseg;
/* Allocate the needed virtual space */
if (lance_csr == 0)
lance_csr = (short *)vax_map_physmem(NI_BASE, 1);
if (lance_addr == 0)
lance_addr = (int *)vax_map_physmem(NI_ADDR, 1);
/*
* Allocate a (DMA-safe) block for all descriptors and buffers.
*/
sc->sc_dmat = va->va_dmat;
#define ALLOCSIZ ((sizeof(struct buffdesc) + BUFSIZE) * (NRBUF + NTBUF))
err = bus_dmamem_alloc(sc->sc_dmat, ALLOCSIZ, NBPG, 0,
&seg, 1, &rseg, BUS_DMA_NOWAIT);
if (err) {
printf(": unable to alloc buffer block: err %d\n", err);
return;
}
err = bus_dmamem_map(sc->sc_dmat, &seg, rseg, ALLOCSIZ,
&sc->sc_memblk, BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
if (err) {
printf(": unable to map buffer block: err %d\n", err);
bus_dmamem_free(sc->sc_dmat, &seg, rseg);
return;
}
/*
* Get the ethernet address out of rom
*/
@ -292,7 +318,7 @@ lnattach(parent, self, aux)
printf("\n%s: address %s\n", self->dv_xname,
ether_sprintf(sc->sc_enaddr));
highmark = (u_int)le_iomem;
highmark = (u_int)sc->sc_memblk;
sc->sc_ib = (void *)ALLOC(sizeof(struct initblock));
bcopy(sc->sc_enaddr, sc->sc_ib->ib_padr, 6);
sc->sc_rdesc = (void *)ALLOC(sizeof(struct buffdesc) * NRBUF);

27
sys/arch/vax/vsa/vsbus.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: vsbus.c,v 1.16 1999/03/13 15:16:48 ragge Exp $ */
/* $NetBSD: vsbus.c,v 1.17 1999/04/14 23:14:46 ragge Exp $ */
/*
* Copyright (c) 1996 Ludd, University of Lule}, Sweden.
* All rights reserved.
@ -47,6 +47,8 @@
#include <sys/syslog.h>
#include <sys/stat.h>
#define _VAX_BUS_DMA_PRIVATE
#include <machine/bus.h>
#include <machine/pte.h>
#include <machine/sid.h>
#include <machine/scb.h>
@ -71,6 +73,28 @@ int vsbus_search __P((struct device *, struct cfdata *, void *));
void ka410_attach __P((struct device *, struct device *, void *));
void ka43_attach __P((struct device *, struct device *, void *));
struct vax_bus_dma_tag vsbus_bus_dma_tag = {
0,
0,
0,
0,
0,
0,
_bus_dmamap_create,
_bus_dmamap_destroy,
_bus_dmamap_load,
_bus_dmamap_load_mbuf,
_bus_dmamap_load_uio,
_bus_dmamap_load_raw,
_bus_dmamap_unload,
_bus_dmamap_sync,
_bus_dmamem_alloc,
_bus_dmamem_free,
_bus_dmamem_map,
_bus_dmamem_unmap,
_bus_dmamem_mmap,
};
struct vsbus_softc {
struct device sc_dev;
volatile struct vs_cpu *sc_cpu;
@ -156,6 +180,7 @@ vsbus_search(parent, cf, aux)
va.va_paddr = cf->cf_loc[0];
va.va_addr = vax_map_physmem(va.va_paddr, 1);
va.va_dmat = &vsbus_bus_dma_tag;
sc->sc_cpu->vc_intmsk = 0;
sc->sc_cpu->vc_intclr = 0xff;