sys/arch/alpha/pci/lca_dma.c

   1 /* $NetBSD: lca_dma.c,v 1.19 2009/03/14 14:45:53 dsl Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
   9  * NASA Ames Research Center.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <sys/cdefs.h>                  /* RCS ID & Copyright macro defns */
  34
  35 __KERNEL_RCSID(0, "$NetBSD: lca_dma.c,v 1.19 2009/03/14 14:45:53 dsl Exp $");
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/kernel.h>
  40 #include <sys/device.h>
  41 #include <sys/malloc.h>
  42
  43 #include <uvm/uvm_extern.h>
  44
  45 #define _ALPHA_BUS_DMA_PRIVATE
  46 #include <machine/bus.h>
  47
  48 #include <dev/pci/pcireg.h>
  49 #include <dev/pci/pcivar.h>
  50 #include <alpha/pci/lcareg.h>
  51 #include <alpha/pci/lcavar.h>
  52
  53 bus_dma_tag_t lca_dma_get_tag(bus_dma_tag_t, alpha_bus_t);
  54
  55 int     lca_bus_dmamap_load_sgmap(bus_dma_tag_t, bus_dmamap_t, void *,
  56             bus_size_t, struct proc *, int);
  57
  58 int     lca_bus_dmamap_load_mbuf_sgmap(bus_dma_tag_t, bus_dmamap_t,
  59             struct mbuf *, int);
  60
  61 int     lca_bus_dmamap_load_uio_sgmap(bus_dma_tag_t, bus_dmamap_t,
  62             struct uio *, int);
  63
  64 int     lca_bus_dmamap_load_raw_sgmap(bus_dma_tag_t, bus_dmamap_t,
  65             bus_dma_segment_t *, int, bus_size_t, int);
  66
  67 void    lca_bus_dmamap_unload_sgmap(bus_dma_tag_t, bus_dmamap_t);
  68
  69 /*
  70  * Direct-mapped window: 1G at 1G
  71  */
  72 #define LCA_DIRECT_MAPPED_BASE  (1*1024*1024*1024)
  73 #define LCA_DIRECT_MAPPED_SIZE  (1*1024*1024*1024)
  74
  75 /*
  76  * SGMAP window: 8M at 8M
  77  */
  78 #define LCA_SGMAP_MAPPED_BASE   (8*1024*1024)
  79 #define LCA_SGMAP_MAPPED_SIZE   (8*1024*1024)
  80
  81 /*
  82  * The LCA doesn't have a DMA prefetch threshold.  However, it is known
  83  * to lose if we don't allocate a spill page.  So initialize it to 256.
  84  */
  85 #define LCA_SGMAP_PFTHRESH      256
  86
  87 /*
  88  * Macro to flush LCA scatter/gather TLB.
  89  */
  90 #define LCA_TLB_INVALIDATE() \
  91 do { \
  92         alpha_mb(); \
  93         REGVAL64(LCA_IOC_TBIA) = 0; \
  94         alpha_mb(); \
  95 } while (0)
  96
  97 void
  98 lca_dma_init(struct lca_config *lcp)
  99 {
 100         bus_dma_tag_t t;
 101
 102         /*
 103          * Initialize the DMA tag used for direct-mapped DMA.
 104          */
 105         t = &lcp->lc_dmat_direct;
 106         t->_cookie = lcp;
 107         t->_wbase = LCA_DIRECT_MAPPED_BASE;
 108         t->_wsize = LCA_DIRECT_MAPPED_SIZE;
 109         t->_next_window = NULL;
 110         t->_boundary = 0;
 111         t->_sgmap = NULL;
 112         t->_get_tag = lca_dma_get_tag;
 113         t->_dmamap_create = _bus_dmamap_create;
 114         t->_dmamap_destroy = _bus_dmamap_destroy;
 115         t->_dmamap_load = _bus_dmamap_load_direct;
 116         t->_dmamap_load_mbuf = _bus_dmamap_load_mbuf_direct;
 117         t->_dmamap_load_uio = _bus_dmamap_load_uio_direct;
 118         t->_dmamap_load_raw = _bus_dmamap_load_raw_direct;
 119         t->_dmamap_unload = _bus_dmamap_unload;
 120         t->_dmamap_sync = _bus_dmamap_sync;
 121
 122         t->_dmamem_alloc = _bus_dmamem_alloc;
 123         t->_dmamem_free = _bus_dmamem_free;
 124         t->_dmamem_map = _bus_dmamem_map;
 125         t->_dmamem_unmap = _bus_dmamem_unmap;
 126         t->_dmamem_mmap = _bus_dmamem_mmap;
 127
 128         /*
 129          * Initialize the DMA tag used for sgmap-mapped DMA.
 130          */
 131         t = &lcp->lc_dmat_sgmap;
 132         t->_cookie = lcp;
 133         t->_wbase = LCA_SGMAP_MAPPED_BASE;
 134         t->_wsize = LCA_SGMAP_MAPPED_SIZE;
 135         t->_next_window = NULL;
 136         t->_boundary = 0;
 137         t->_sgmap = &lcp->lc_sgmap;
 138         t->_pfthresh = LCA_SGMAP_PFTHRESH;
 139         t->_get_tag = lca_dma_get_tag;
 140         t->_dmamap_create = alpha_sgmap_dmamap_create;
 141         t->_dmamap_destroy = alpha_sgmap_dmamap_destroy;
 142         t->_dmamap_load = lca_bus_dmamap_load_sgmap;
 143         t->_dmamap_load_mbuf = lca_bus_dmamap_load_mbuf_sgmap;
 144         t->_dmamap_load_uio = lca_bus_dmamap_load_uio_sgmap;
 145         t->_dmamap_load_raw = lca_bus_dmamap_load_raw_sgmap;
 146         t->_dmamap_unload = lca_bus_dmamap_unload_sgmap;
 147         t->_dmamap_sync = _bus_dmamap_sync;
 148
 149         t->_dmamem_alloc = _bus_dmamem_alloc;
 150         t->_dmamem_free = _bus_dmamem_free;
 151         t->_dmamem_map = _bus_dmamem_map;
 152         t->_dmamem_unmap = _bus_dmamem_unmap;
 153         t->_dmamem_mmap = _bus_dmamem_mmap;
 154
 155         /* Initialize window 1 as a direct-mapped window. */
 156         REGVAL64(LCA_IOC_W_BASE1) = LCA_DIRECT_MAPPED_BASE | IOC_W_BASE_WEN;
 157         REGVAL64(LCA_IOC_W_MASK1) = IOC_W_MASK_1G;
 158         alpha_mb();
 159
 160         /* Disable window 0 while we set it up. */
 161         REGVAL64(LCA_IOC_W_BASE0) = 0;
 162         alpha_mb();
 163
 164         /*
 165          * Initialize the SGMAP.
 166          */
 167         alpha_sgmap_init(t, &lcp->lc_sgmap, "lca_sgmap",
 168             LCA_SGMAP_MAPPED_BASE, 0, LCA_SGMAP_MAPPED_SIZE,
 169             sizeof(u_int64_t), NULL, 0);
 170
 171         /*
 172          * Set up window 0 as an 8MB SGMAP-mapped window
 173          * starting at 8MB.
 174          */
 175         REGVAL64(LCA_IOC_W_BASE0) = LCA_SGMAP_MAPPED_BASE |
 176             IOC_W_BASE_SG | IOC_W_BASE_WEN;
 177         REGVAL64(LCA_IOC_W_MASK0) = IOC_W_MASK_8M;
 178         alpha_mb();
 179
 180         if ((lcp->lc_sgmap.aps_ptpa & IOC_W_T_BASE) !=
 181             lcp->lc_sgmap.aps_ptpa)
 182                 panic("lca_dma_init: bad page table address");
 183         REGVAL64(LCA_IOC_W_T_BASE0) = lcp->lc_sgmap.aps_ptpa;
 184         alpha_mb();
 185
 186         /* Enble the scatter/gather TLB. */
 187         REGVAL64(LCA_IOC_TB_ENA) = IOC_TB_ENA_TEN;
 188         alpha_mb();
 189
 190         LCA_TLB_INVALIDATE();
 191
 192         /* XXX XXX BEGIN XXX XXX */
 193         {                                                       /* XXX */
 194                 extern paddr_t alpha_XXX_dmamap_or;             /* XXX */
 195                 alpha_XXX_dmamap_or = LCA_DIRECT_MAPPED_BASE;   /* XXX */
 196         }                                                       /* XXX */
 197         /* XXX XXX END XXX XXX */
 198 }
 199
 200 /*
 201  * Return the bus dma tag to be used for the specified bus type.
 202  * INTERNAL USE ONLY!
 203  */
 204 bus_dma_tag_t
 205 lca_dma_get_tag(bus_dma_tag_t t, alpha_bus_t bustype)
 206 {
 207         struct lca_config *lcp = t->_cookie;
 208
 209         switch (bustype) {
 210         case ALPHA_BUS_PCI:
 211         case ALPHA_BUS_EISA:
 212                 /*
 213                  * Systems with an LCA can only support 1G
 214                  * of memory, so we use the direct-mapped window
 215                  * on busses that have 32-bit DMA.
 216                  */
 217                 return (&lcp->lc_dmat_direct);
 218
 219         case ALPHA_BUS_ISA:
 220                 /*
 221                  * ISA doesn't have enough address bits to use
 222                  * the direct-mapped DMA window, so we must use
 223                  * SGMAPs.
 224                  */
 225                 return (&lcp->lc_dmat_sgmap);
 226
 227         default:
 228                 panic("lca_dma_get_tag: shouldn't be here, really...");
 229         }
 230 }
 231
 232 /*
 233  * Load an LCA SGMAP-mapped DMA map with a linear buffer.
 234  */
 235 int
 236 lca_bus_dmamap_load_sgmap(bus_dma_tag_t t, bus_dmamap_t map, void *buf, bus_size_t buflen, struct proc *p, int flags)
 237 {
 238         int error;
 239
 240         error = pci_sgmap_pte64_load(t, map, buf, buflen, p, flags,
 241             t->_sgmap);
 242         if (error == 0)
 243                 LCA_TLB_INVALIDATE();
 244
 245         return (error);
 246 }
 247
 248 /*
 249  * Load an LCA SGMAP-mapped DMA map with an mbuf chain.
 250  */
 251 int
 252 lca_bus_dmamap_load_mbuf_sgmap(bus_dma_tag_t t, bus_dmamap_t map, struct mbuf *m, int flags)
 253 {
 254         int error;
 255
 256         error = pci_sgmap_pte64_load_mbuf(t, map, m, flags, t->_sgmap);
 257         if (error == 0)
 258                 LCA_TLB_INVALIDATE();
 259
 260         return (error);
 261 }
 262
 263 /*
 264  * Load an LCA SGMAP-mapped DMA map with a uio.
 265  */
 266 int
 267 lca_bus_dmamap_load_uio_sgmap(bus_dma_tag_t t, bus_dmamap_t map, struct uio *uio, int flags)
 268 {
 269         int error;
 270
 271         error = pci_sgmap_pte64_load_uio(t, map, uio, flags, t->_sgmap);
 272         if (error == 0)
 273                 LCA_TLB_INVALIDATE();
 274
 275         return (error);
 276 }
 277
 278 /*
 279  * Load an LCA SGMAP-mapped DMA map with raw memory.
 280  */
 281 int
 282 lca_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)
 283 {
 284         int error;
 285
 286         error = pci_sgmap_pte64_load_raw(t, map, segs, nsegs, size, flags,
 287             t->_sgmap);
 288         if (error == 0)
 289                 LCA_TLB_INVALIDATE();
 290
 291         return (error);
 292 }
 293
 294 /*
 295  * Unload an LCA DMA map.
 296  */
 297 void
 298 lca_bus_dmamap_unload_sgmap(bus_dma_tag_t t, bus_dmamap_t map)
 299 {
 300
 301         /*
 302          * Invalidate any SGMAP page table entries used by this
 303          * mapping.
 304          */
 305         pci_sgmap_pte64_unload(t, map, t->_sgmap);
 306         LCA_TLB_INVALIDATE();
 307
 308         /*
 309          * Do the generic bits of the unload.
 310          */
 311         _bus_dmamap_unload(t, map);
 312 }