sys/arch/arc/jazz/jazzdmatlb.c

   1 /*      $NetBSD: jazzdmatlb.c,v 1.13 2005/12/11 12:16:39 christos Exp $ */
   2 /*      $OpenBSD: dma.c,v 1.5 1998/03/01 16:49:57 niklas Exp $  */
   3
   4 /*-
   5  * Copyright (C) 2000 Shuichiro URATA.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 /*
  31  * Jazz derived system dma driver. Handles resource allocation and
  32  * logical (virtual) address remaping.
  33  */
  34
  35 #include <sys/cdefs.h>
  36 __KERNEL_RCSID(0, "$NetBSD: jazzdmatlb.c,v 1.13 2005/12/11 12:16:39 christos Exp $");
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/malloc.h>
  41 #include <sys/extent.h>
  42 #include <sys/device.h>
  43 #include <sys/proc.h>
  44
  45 #include <uvm/uvm_extern.h>
  46
  47 #include <machine/autoconf.h>
  48 #include <machine/bus.h>
  49
  50 #include <arc/jazz/jazzdmatlbreg.h>
  51 #include <arc/jazz/jazzdmatlbvar.h>
  52
  53 #include <mips/cache.h>
  54
  55 extern paddr_t  kvtophys(vaddr_t);      /* XXX */
  56
  57 /*
  58  * Currently, only NET and BIO devices use DMA, and splnet > splbio.
  59  */
  60 #define spldma()        splnet()
  61
  62 #define NDMATLB         (JAZZ_DMATLB_SIZE / sizeof(jazz_dma_pte_t))
  63
  64 static bus_space_tag_t dmatlb_iot;
  65 static bus_space_handle_t dmatlb_ioh;
  66
  67 static struct extent *dmatlbmap;
  68 static jazz_dma_pte_t *dma_tlb;
  69
  70 /*
  71  *  Initialize the dma mapping register area and pool.
  72  */
  73 void
  74 jazz_dmatlb_init(bus_space_tag_t iot, bus_addr_t ioaddr)
  75 {
  76         int err;
  77
  78         dmatlb_iot = iot;
  79         err = bus_space_map(iot, ioaddr, JAZZ_DMATLB_REGSIZE, 0, &dmatlb_ioh);
  80         if (err != 0)
  81                 panic("jazz_dmatlb_init: cannot map 0x%lx", ioaddr);
  82
  83         dma_tlb = (jazz_dma_pte_t *)PICA_TL_BASE;
  84
  85         mips_dcache_wbinv_all();/* Make sure no map entries are cached */
  86         memset((char *)dma_tlb, 0, JAZZ_DMATLB_SIZE);
  87
  88         dmatlbmap = extent_create("dmatlb", 0, NDMATLB, M_DEVBUF, NULL, 0,
  89             EX_NOWAIT);
  90         if (dmatlbmap == NULL)
  91                 panic("jazz_dmatlb_init: cannot create extent map");
  92
  93         bus_space_write_4(dmatlb_iot, dmatlb_ioh, JAZZ_DMATLBREG_MAP,
  94             MIPS_KSEG1_TO_PHYS(dma_tlb));
  95         bus_space_write_4(dmatlb_iot, dmatlb_ioh, JAZZ_DMATLBREG_LIMIT,
  96             JAZZ_DMATLB_SIZE);
  97         jazz_dmatlb_flush();
  98 }
  99
 100 /*
 101  *  Allocate an array of 'size' DMA PTEs.
 102  *  Return address to first pte.
 103  */
 104 jazz_dma_pte_t *
 105 jazz_dmatlb_alloc(int npte, bus_size_t boundary, int flags, bus_addr_t *addr)
 106 {
 107         u_long start;
 108         int err;
 109         int s;
 110
 111         s = spldma();
 112         err = extent_alloc(dmatlbmap, npte, 1, boundary / JAZZ_DMA_PAGE_SIZE,
 113             (flags & BUS_DMA_WAITOK) ? (EX_WAITSPACE | EX_WAITOK) : EX_NOWAIT,
 114             &start);
 115         splx(s);
 116
 117         if (err)
 118                 return NULL;
 119
 120         *addr = start * JAZZ_DMA_PAGE_SIZE;
 121
 122         return dma_tlb + start;
 123 }
 124
 125 /*
 126  *  Free an array of DMA PTEs.
 127  */
 128 void
 129 jazz_dmatlb_free(bus_addr_t addr, int npte)
 130 {
 131         u_long start;
 132         int s;
 133
 134         start = addr / JAZZ_DMA_PAGE_SIZE;
 135         s = spldma();
 136         extent_free(dmatlbmap, start, npte, EX_NOWAIT);
 137         splx(s);
 138 }
 139
 140 /*
 141  *  Map up a virtual address space in dma space given by
 142  *  the dma control structure.
 143  */
 144 void
 145 jazz_dmatlb_map_va(struct vmspace *vm, vaddr_t va, vsize_t size,
 146     jazz_dma_pte_t *dma_pte)
 147 {
 148         paddr_t pa;
 149
 150         size = jazz_dma_page_round(size + jazz_dma_page_offs(va));
 151         va &= JAZZ_DMA_PAGE_NUM;
 152         while (size > 0) {
 153                 if (!VMSPACE_IS_KERNEL_P(vm))
 154                         (void)pmap_extract(vm_map_pmap(&vm->vm_map), va, &pa);
 155                 else
 156                         pa = kvtophys(va);
 157
 158                 pa &= JAZZ_DMA_PAGE_NUM;
 159                 dma_pte->lo_addr = pa;
 160                 dma_pte->hi_addr = 0;
 161                 dma_pte++;
 162                 va += JAZZ_DMA_PAGE_SIZE;
 163                 size -= JAZZ_DMA_PAGE_SIZE;
 164         }
 165 }
 166
 167 /*
 168  *  Map up a physical address space in dma space given by
 169  *  the dma control structure.
 170  */
 171 void
 172 jazz_dmatlb_map_pa(paddr_t pa, psize_t size, jazz_dma_pte_t *dma_pte)
 173 {
 174
 175         size = jazz_dma_page_round(size + jazz_dma_page_offs(pa));
 176         pa &= JAZZ_DMA_PAGE_NUM;
 177         while (size > 0) {
 178                 dma_pte->lo_addr = pa;
 179                 dma_pte->hi_addr = 0;
 180                 dma_pte++;
 181                 pa += JAZZ_DMA_PAGE_SIZE;
 182                 size -= JAZZ_DMA_PAGE_SIZE;
 183         }
 184 }
 185
 186 /*
 187  *  Prepare for new dma by flushing
 188  */
 189 void
 190 jazz_dmatlb_flush(void)
 191 {
 192
 193         bus_space_write_4(dmatlb_iot, dmatlb_ioh, JAZZ_DMATLBREG_IVALID, 0);
 194 }