sys/arch/alpha/pci/dwlpx_dma.c

   1 /* $NetBSD: dwlpx_dma.c,v 1.18 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: dwlpx_dma.c,v 1.18 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/tlsb/tlsbreg.h>
  51 #include <alpha/tlsb/kftxxvar.h>
  52 #include <alpha/tlsb/kftxxreg.h>
  53 #include <alpha/pci/dwlpxreg.h>
  54 #include <alpha/pci/dwlpxvar.h>
  55 #include <alpha/pci/pci_kn8ae.h>
  56
  57 bus_dma_tag_t dwlpx_dma_get_tag(bus_dma_tag_t, alpha_bus_t);
  58
  59 int     dwlpx_bus_dmamap_load_sgmap(bus_dma_tag_t, bus_dmamap_t, void *,
  60             bus_size_t, struct proc *, int);
  61
  62 int     dwlpx_bus_dmamap_load_mbuf_sgmap(bus_dma_tag_t, bus_dmamap_t,
  63             struct mbuf *, int);
  64
  65 int     dwlpx_bus_dmamap_load_uio_sgmap(bus_dma_tag_t, bus_dmamap_t,
  66             struct uio *, int);
  67
  68 int     dwlpx_bus_dmamap_load_raw_sgmap(bus_dma_tag_t, bus_dmamap_t,
  69             bus_dma_segment_t *, int, bus_size_t, int);
  70
  71 void    dwlpx_bus_dmamap_unload_sgmap(bus_dma_tag_t, bus_dmamap_t);
  72
  73 /*
  74  * Direct-mapped window: 2G at 2G
  75  */
  76 #define DWLPx_DIRECT_MAPPED_BASE        (2UL*1024UL*1024UL*1024UL)
  77 #define DWLPx_DIRECT_MAPPED_SIZE        (2UL*1024UL*1024UL*1024UL)
  78
  79 /*
  80  * SGMAP window A: 256M or 1G at 1G
  81  */
  82 #define DWLPx_SG_MAPPED_BASE            (1*1024*1024*1024)
  83 #define DWLPx_SG_MAPPED_SIZE(x)         ((x) * PAGE_SIZE)
  84
  85 /* DWLPx has a 256-byte out-bound DMA prefetch threshold. */
  86 #define DWLPx_SG_MAPPED_PFTHRESH        256
  87
  88 /*
  89  * Set this to always use SGMAPs.
  90  */
  91 #ifdef DWLPX_ALWAYS_USE_SGMAP
  92 int     dwlpx_always_use_sgmap = 1;
  93 #else
  94 int     dwlpx_always_use_sgmap = 0;
  95 #endif
  96
  97 void
  98 dwlpx_dma_init(struct dwlpx_config *ccp)
  99 {
 100         char *exname;
 101         bus_dma_tag_t t;
 102         u_int32_t *page_table;
 103         int i, lim, wmask;
 104
 105         /*
 106          * Determine size of Window C based on the amount of SGMAP
 107          * page table SRAM available.
 108          */
 109         if (ccp->cc_sc->dwlpx_sgmapsz == DWLPX_SG128K) {
 110                 lim = 128 * 1024;
 111                 wmask = PCIA_WMASK_1G;
 112         } else {
 113                 lim = 32 * 1024;
 114                 wmask = PCIA_WMASK_256M;
 115         }
 116
 117         /*
 118          * Initialize the DMA tag used for direct-mapped DMA.  Chain
 119          * this window to the SGMAP window, because we might have
 120          * a lot of memory in the machine.
 121          */
 122         t = &ccp->cc_dmat_direct;
 123         t->_cookie = ccp;
 124         t->_wbase = DWLPx_DIRECT_MAPPED_BASE;
 125         t->_wsize = DWLPx_DIRECT_MAPPED_SIZE;
 126         t->_next_window = &ccp->cc_dmat_sgmap;
 127         t->_boundary = 0;
 128         t->_sgmap = NULL;
 129         t->_get_tag = dwlpx_dma_get_tag;
 130         t->_dmamap_create = _bus_dmamap_create;
 131         t->_dmamap_destroy = _bus_dmamap_destroy;
 132         t->_dmamap_load = _bus_dmamap_load_direct;
 133         t->_dmamap_load_mbuf = _bus_dmamap_load_mbuf_direct;
 134         t->_dmamap_load_uio = _bus_dmamap_load_uio_direct;
 135         t->_dmamap_load_raw = _bus_dmamap_load_raw_direct;
 136         t->_dmamap_unload = _bus_dmamap_unload;
 137         t->_dmamap_sync = _bus_dmamap_sync;
 138
 139         t->_dmamem_alloc = _bus_dmamem_alloc;
 140         t->_dmamem_free = _bus_dmamem_free;
 141         t->_dmamem_map = _bus_dmamem_map;
 142         t->_dmamem_unmap = _bus_dmamem_unmap;
 143         t->_dmamem_mmap = _bus_dmamem_mmap;
 144
 145         /*
 146          * Initialize the DMA tag used for sgmap-mapped DMA.
 147          */
 148         t = &ccp->cc_dmat_sgmap;
 149         t->_cookie = ccp;
 150         t->_wbase = DWLPx_SG_MAPPED_BASE;
 151         t->_wsize = DWLPx_SG_MAPPED_SIZE(lim);
 152         t->_next_window = NULL;
 153         t->_boundary = 0;
 154         t->_sgmap = &ccp->cc_sgmap;
 155         t->_pfthresh = DWLPx_SG_MAPPED_PFTHRESH;
 156         t->_get_tag = dwlpx_dma_get_tag;
 157         t->_dmamap_create = alpha_sgmap_dmamap_create;
 158         t->_dmamap_destroy = alpha_sgmap_dmamap_destroy;
 159         t->_dmamap_load = dwlpx_bus_dmamap_load_sgmap;
 160         t->_dmamap_load_mbuf = dwlpx_bus_dmamap_load_mbuf_sgmap;
 161         t->_dmamap_load_uio = dwlpx_bus_dmamap_load_uio_sgmap;
 162         t->_dmamap_load_raw = dwlpx_bus_dmamap_load_raw_sgmap;
 163         t->_dmamap_unload = dwlpx_bus_dmamap_unload_sgmap;
 164         t->_dmamap_sync = _bus_dmamap_sync;
 165
 166         t->_dmamem_alloc = _bus_dmamem_alloc;
 167         t->_dmamem_free = _bus_dmamem_free;
 168         t->_dmamem_map = _bus_dmamem_map;
 169         t->_dmamem_unmap = _bus_dmamem_unmap;
 170         t->_dmamem_mmap = _bus_dmamem_mmap;
 171
 172         /*
 173          * A few notes about SGMAP-mapped DMA on the DWLPx:
 174          *
 175          * The DWLPx has PCIA-resident SRAM that is used for
 176          * the SGMAP page table; there is no TLB.  The DWLPA
 177          * has room for 32K entries, yielding a total of 256M
 178          * of sgva space.  The DWLPB has 32K entries or 128K
 179          * entries, depending on TBIT, yielding either 256M or
 180          * 1G of sgva space.
 181          *
 182          * This sgva space must be shared across all windows
 183          * that wish to use SGMAP-mapped DMA; make sure to
 184          * adjust the "sgvabase" argument to alpha_sgmap_init()
 185          * accordingly if you create more than one SGMAP-mapped
 186          * window.  Note that sgvabase != window base.  The former
 187          * is used to compute indexes into the page table only.
 188          *
 189          * In the current implementation the first window is a
 190          * 2G window direct-mapped mapped at 2G and the second
 191          * window is disabled and the third window is a 256M
 192          * or 1GB scatter/gather map at 1GB.
 193          *
 194          * We just punt on trying to support ISA DMA.  If you want
 195          * try that on a TurboLaser, well, you just lose.
 196          */
 197
 198         /*
 199          * Initialize the page table.
 200          */
 201         page_table =
 202             (u_int32_t *)ALPHA_PHYS_TO_K0SEG(PCIA_SGMAP_PT + ccp->cc_sysbase);
 203         for (i = 0; i < lim; i++)
 204                 page_table[i * SGMAP_PTE_SPACING] = 0;
 205         alpha_mb();
 206
 207         /*
 208          * Initialize the SGMAP for window C:
 209          *
 210          *      Size: 256M or 1GB
 211          *      Window base: 1GB
 212          *      SGVA base: 0
 213          */
 214         exname = malloc(16, M_DEVBUF, M_NOWAIT);
 215         if (exname == NULL)
 216                 panic("dwlpx_dma_init");
 217         sprintf(exname, "%s_sgmap_a", ccp->cc_sc->dwlpx_dev.dv_xname);
 218         alpha_sgmap_init(t, &ccp->cc_sgmap, exname, DWLPx_SG_MAPPED_BASE,
 219             0, DWLPx_SG_MAPPED_SIZE(lim), sizeof(u_int32_t),
 220             (void *)page_table, 0);
 221
 222         /*
 223          * Set up DMA windows for this DWLPx.
 224          *
 225          * Do this even for all HPCs- even for the nonexistent
 226          * one on hose zero of a KFTIA.
 227          */
 228         for (i = 0; i < NHPC; i++) {
 229                 REGVAL(PCIA_WMASK_A(i) + ccp->cc_sysbase) = PCIA_WMASK_2G;
 230                 REGVAL(PCIA_TBASE_A(i) + ccp->cc_sysbase) = 0;
 231                 REGVAL(PCIA_WBASE_A(i) + ccp->cc_sysbase) =
 232                     DWLPx_DIRECT_MAPPED_BASE | PCIA_WBASE_W_EN;
 233
 234                 REGVAL(PCIA_WMASK_B(i) + ccp->cc_sysbase) = 0;
 235                 REGVAL(PCIA_TBASE_B(i) + ccp->cc_sysbase) = 0;
 236                 REGVAL(PCIA_WBASE_B(i) + ccp->cc_sysbase) = 0;
 237
 238                 REGVAL(PCIA_WMASK_C(i) + ccp->cc_sysbase) = wmask;
 239                 REGVAL(PCIA_TBASE_C(i) + ccp->cc_sysbase) = 0;
 240                 REGVAL(PCIA_WBASE_C(i) + ccp->cc_sysbase) =
 241                     DWLPx_SG_MAPPED_BASE | PCIA_WBASE_W_EN | PCIA_WBASE_SG_EN;
 242                 alpha_mb();
 243         }
 244
 245         /* XXX XXX BEGIN XXX XXX */
 246         {                                                       /* XXX */
 247                 extern paddr_t alpha_XXX_dmamap_or;             /* XXX */
 248                 alpha_XXX_dmamap_or = DWLPx_DIRECT_MAPPED_BASE; /* XXX */
 249         }                                                       /* XXX */
 250         /* XXX XXX END XXX XXX */
 251 }
 252
 253 /*
 254  * Return the bus dma tag to be used for the specified bus type.
 255  * INTERNAL USE ONLY!
 256  */
 257 bus_dma_tag_t
 258 dwlpx_dma_get_tag(bus_dma_tag_t t, alpha_bus_t bustype)
 259 {
 260         struct dwlpx_config *ccp = t->_cookie;
 261
 262         switch (bustype) {
 263         case ALPHA_BUS_PCI:
 264         case ALPHA_BUS_EISA:
 265                 if (dwlpx_always_use_sgmap) {
 266                         /*
 267                          * Always use SGMAPs (for testing purposes?)
 268                          */
 269                         return (&ccp->cc_dmat_sgmap);
 270                 }
 271                 /*
 272                  * Give these busses the direct-mapped window; if the
 273                  * address crosses the threshold, it will fall back
 274                  * onto the SGMAP window.
 275                  */
 276                 return (&ccp->cc_dmat_direct);
 277
 278         case ALPHA_BUS_ISA:
 279                 /*
 280                  * Don't even bother; it's not easy, given how the
 281                  * page table is arranged, and it's not really worth
 282                  * the trouble.
 283                  */
 284                 panic("dwlpx_dma_get_tag: ISA DMA?  Forget it...");
 285                 /* NOTREACHED */
 286
 287         default:
 288                 panic("dwlpx_dma_get_tag: shouldn't be here, really...");
 289         }
 290 }
 291
 292 /*
 293  * Load a DWLPx SGMAP-mapped DMA map with a linear buffer.
 294  */
 295 int
 296 dwlpx_bus_dmamap_load_sgmap(bus_dma_tag_t t, bus_dmamap_t map, void *buf, bus_size_t buflen, struct proc *p, int flags)
 297 {
 298
 299         return (pci_sgmap_pte32_load(t, map, buf, buflen, p, flags,
 300             t->_sgmap));
 301 }
 302
 303 /*
 304  * Load a DWLPx SGMAP-mapped DMA map with an mbuf chain.
 305  */
 306 int
 307 dwlpx_bus_dmamap_load_mbuf_sgmap(bus_dma_tag_t t, bus_dmamap_t map, struct mbuf *m, int flags)
 308 {
 309
 310         return (pci_sgmap_pte32_load_mbuf(t, map, m, flags, t->_sgmap));
 311 }
 312
 313 /*
 314  * Load a DWLPx SGMAP-mapped DMA map with a uio.
 315  */
 316 int
 317 dwlpx_bus_dmamap_load_uio_sgmap(bus_dma_tag_t t, bus_dmamap_t map, struct uio *uio, int flags)
 318 {
 319
 320         return (pci_sgmap_pte32_load_uio(t, map, uio, flags, t->_sgmap));
 321 }
 322
 323 /*
 324  * Load a DWLPx SGMAP-mapped DMA map with raw memory.
 325  */
 326 int
 327 dwlpx_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)
 328 {
 329
 330         return (pci_sgmap_pte32_load_raw(t, map, segs, nsegs, size, flags,
 331             t->_sgmap));
 332 }
 333
 334 /*
 335  * Unload a DWLPx DMA map.
 336  */
 337 void
 338 dwlpx_bus_dmamap_unload_sgmap(bus_dma_tag_t t, bus_dmamap_t map)
 339 {
 340
 341         /*
 342          * Invalidate any SGMAP page table entries used by this
 343          * mapping.
 344          */
 345         pci_sgmap_pte32_unload(t, map, t->_sgmap);
 346
 347         /*
 348          * Do the generic bits of the unload.
 349          */
 350         _bus_dmamap_unload(t, map);
 351 }