sys/dev/proto/proto_busdma.c

   1 /*-
   2  * Copyright (c) 2015 Marcel Moolenaar
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include <sys/cdefs.h>
  27 __FBSDID("$FreeBSD$");
  28
  29 #include <sys/param.h>
  30 #include <sys/systm.h>
  31 #include <machine/bus.h>
  32 #include <machine/bus_dma.h>
  33 #include <machine/resource.h>
  34 #include <sys/bus.h>
  35 #include <sys/conf.h>
  36 #include <sys/kernel.h>
  37 #include <sys/malloc.h>
  38 #include <sys/module.h>
  39 #include <sys/queue.h>
  40 #include <sys/rman.h>
  41 #include <sys/sbuf.h>
  42 #include <vm/vm.h>
  43 #include <vm/pmap.h>
  44
  45 #include <dev/proto/proto.h>
  46 #include <dev/proto/proto_dev.h>
  47 #include <dev/proto/proto_busdma.h>
  48
  49 MALLOC_DEFINE(M_PROTO_BUSDMA, "proto_busdma", "DMA management data");
  50
  51 static int
  52 proto_busdma_tag_create(struct proto_busdma *busdma, struct proto_tag *parent,
  53     struct proto_ioc_busdma *ioc)
  54 {
  55         struct proto_tag *tag;
  56
  57         /*
  58          * If nsegs is 1, ignore maxsegsz. What this means is that if we have
  59          * just 1 segment, then maxsz should be equal to maxsegsz. To keep it
  60          * simple for us, limit maxsegsz to maxsz in any case.
  61          */
  62         if (ioc->u.tag.maxsegsz > ioc->u.tag.maxsz || ioc->u.tag.nsegs == 1)
  63                 ioc->u.tag.maxsegsz = ioc->u.tag.maxsz;
  64
  65         /* A bndry of 0 really means ~0, or no boundary. */
  66         if (ioc->u.tag.bndry == 0)
  67                 ioc->u.tag.bndry = ~0U;
  68
  69         tag = malloc(sizeof(*tag), M_PROTO_BUSDMA, M_WAITOK | M_ZERO);
  70         if (parent != NULL) {
  71                 tag->parent = parent;
  72                 LIST_INSERT_HEAD(&parent->children, tag, peers);
  73                 tag->align = MAX(ioc->u.tag.align, parent->align);
  74                 tag->bndry = MIN(ioc->u.tag.bndry, parent->bndry);
  75                 tag->maxaddr = MIN(ioc->u.tag.maxaddr, parent->maxaddr);
  76                 tag->maxsz = MIN(ioc->u.tag.maxsz, parent->maxsz);
  77                 tag->maxsegsz = MIN(ioc->u.tag.maxsegsz, parent->maxsegsz);
  78                 tag->nsegs = MIN(ioc->u.tag.nsegs, parent->nsegs);
  79                 tag->datarate = MIN(ioc->u.tag.datarate, parent->datarate);
  80                 /* Write constraints back */
  81                 ioc->u.tag.align = tag->align;
  82                 ioc->u.tag.bndry = tag->bndry;
  83                 ioc->u.tag.maxaddr = tag->maxaddr;
  84                 ioc->u.tag.maxsz = tag->maxsz;
  85                 ioc->u.tag.maxsegsz = tag->maxsegsz;
  86                 ioc->u.tag.nsegs = tag->nsegs;
  87                 ioc->u.tag.datarate = tag->datarate;
  88         } else {
  89                 tag->align = ioc->u.tag.align;
  90                 tag->bndry = ioc->u.tag.bndry;
  91                 tag->maxaddr = ioc->u.tag.maxaddr;
  92                 tag->maxsz = ioc->u.tag.maxsz;
  93                 tag->maxsegsz = ioc->u.tag.maxsegsz;
  94                 tag->nsegs = ioc->u.tag.nsegs;
  95                 tag->datarate = ioc->u.tag.datarate;
  96         }
  97         LIST_INSERT_HEAD(&busdma->tags, tag, tags);
  98         ioc->result = (uintptr_t)(void *)tag;
  99         return (0);
 100 }
 101
 102 static int
 103 proto_busdma_tag_destroy(struct proto_busdma *busdma, struct proto_tag *tag)
 104 {
 105
 106         if (!LIST_EMPTY(&tag->mds))
 107                 return (EBUSY);
 108         if (!LIST_EMPTY(&tag->children))
 109                 return (EBUSY);
 110
 111         if (tag->parent != NULL) {
 112                 LIST_REMOVE(tag, peers);
 113                 tag->parent = NULL;
 114         }
 115         LIST_REMOVE(tag, tags);
 116         free(tag, M_PROTO_BUSDMA);
 117         return (0);
 118 }
 119
 120 static struct proto_tag *
 121 proto_busdma_tag_lookup(struct proto_busdma *busdma, u_long key)
 122 {
 123         struct proto_tag *tag;
 124
 125         LIST_FOREACH(tag, &busdma->tags, tags) {
 126                 if ((void *)tag == (void *)key)
 127                         return (tag);
 128         }
 129         return (NULL);
 130 }
 131
 132 static int
 133 proto_busdma_mem_alloc(struct proto_busdma *busdma, struct proto_tag *tag,
 134     struct proto_ioc_busdma *ioc)
 135 {
 136         struct proto_md *md;
 137         int error;
 138
 139         md = malloc(sizeof(*md), M_PROTO_BUSDMA, M_WAITOK | M_ZERO);
 140         md->tag = tag;
 141
 142         error = bus_dma_tag_create(busdma->bd_roottag, tag->align, tag->bndry,
 143             tag->maxaddr, BUS_SPACE_MAXADDR, NULL, NULL, tag->maxsz,
 144             tag->nsegs, tag->maxsegsz, 0, NULL, NULL, &md->bd_tag);
 145         if (error) {
 146                 free(md, M_PROTO_BUSDMA);
 147                 return (error);
 148         }
 149         error = bus_dmamem_alloc(md->bd_tag, &md->kva, 0, &md->bd_map);
 150         if (error) {
 151                 bus_dma_tag_destroy(md->bd_tag);
 152                 free(md, M_PROTO_BUSDMA);
 153                 return (error);
 154         }
 155         LIST_INSERT_HEAD(&tag->mds, md, peers);
 156         LIST_INSERT_HEAD(&busdma->mds, md, mds);
 157         ioc->u.mem.nsegs = 1;
 158         ioc->u.mem.physaddr = pmap_kextract((uintptr_t)(md->kva));
 159         ioc->result = (uintptr_t)(void *)md;
 160         return (0);
 161 }
 162
 163 static int
 164 proto_busdma_mem_free(struct proto_busdma *busdma, struct proto_md *md)
 165 {
 166
 167         LIST_REMOVE(md, mds);
 168         LIST_REMOVE(md, peers);
 169         bus_dmamem_free(md->bd_tag, md->kva, md->bd_map);
 170         bus_dma_tag_destroy(md->bd_tag);
 171         free(md, M_PROTO_BUSDMA);
 172         return (0);
 173 }
 174
 175 static struct proto_md *
 176 proto_busdma_md_lookup(struct proto_busdma *busdma, u_long key)
 177 {
 178         struct proto_md *md;
 179
 180         LIST_FOREACH(md, &busdma->mds, mds) {
 181                 if ((void *)md == (void *)key)
 182                         return (md);
 183         }
 184         return (NULL);
 185 }
 186
 187 struct proto_busdma *
 188 proto_busdma_attach(struct proto_softc *sc)
 189 {
 190         struct proto_busdma *busdma;
 191
 192         busdma = malloc(sizeof(*busdma), M_PROTO_BUSDMA, M_WAITOK | M_ZERO);
 193         return (busdma);
 194 }
 195
 196 int
 197 proto_busdma_detach(struct proto_softc *sc, struct proto_busdma *busdma)
 198 {
 199
 200         proto_busdma_cleanup(sc, busdma);
 201         free(busdma, M_PROTO_BUSDMA);
 202         return (0);
 203 }
 204
 205 int
 206 proto_busdma_cleanup(struct proto_softc *sc, struct proto_busdma *busdma)
 207 {
 208         struct proto_md *md, *md1;
 209         struct proto_tag *tag, *tag1;
 210
 211         LIST_FOREACH_SAFE(md, &busdma->mds, mds, md1)
 212                 proto_busdma_mem_free(busdma, md);
 213         LIST_FOREACH_SAFE(tag, &busdma->tags, tags, tag1)
 214                 proto_busdma_tag_destroy(busdma, tag);
 215         return (0);
 216 }
 217
 218 int
 219 proto_busdma_ioctl(struct proto_softc *sc, struct proto_busdma *busdma,
 220     struct proto_ioc_busdma *ioc)
 221 {
 222         struct proto_tag *tag;
 223         struct proto_md *md;
 224         int error;
 225
 226         error = 0;
 227         switch (ioc->request) {
 228         case PROTO_IOC_BUSDMA_TAG_CREATE:
 229                 busdma->bd_roottag = bus_get_dma_tag(sc->sc_dev);
 230                 error = proto_busdma_tag_create(busdma, NULL, ioc);
 231                 break;
 232         case PROTO_IOC_BUSDMA_TAG_DERIVE:
 233                 tag = proto_busdma_tag_lookup(busdma, ioc->key);
 234                 if (tag == NULL) {
 235                         error = EINVAL;
 236                         break;
 237                 }
 238                 error = proto_busdma_tag_create(busdma, tag, ioc);
 239                 break;
 240         case PROTO_IOC_BUSDMA_TAG_DESTROY:
 241                 tag = proto_busdma_tag_lookup(busdma, ioc->key);
 242                 if (tag == NULL) {
 243                         error = EINVAL;
 244                         break;
 245                 }
 246                 error = proto_busdma_tag_destroy(busdma, tag);
 247                 break;
 248         case PROTO_IOC_BUSDMA_MEM_ALLOC:
 249                 tag = proto_busdma_tag_lookup(busdma, ioc->u.mem.tag);
 250                 if (tag == NULL) {
 251                         error = EINVAL;
 252                         break;
 253                 }
 254                 error = proto_busdma_mem_alloc(busdma, tag, ioc);
 255                 break;
 256         case PROTO_IOC_BUSDMA_MEM_FREE:
 257                 md = proto_busdma_md_lookup(busdma, ioc->key);
 258                 if (md == NULL) {
 259                         error = EINVAL;
 260                         break;
 261                 }
 262                 error = proto_busdma_mem_free(busdma, md);
 263                 break;
 264         default:
 265                 error = EINVAL;
 266                 break;
 267         }
 268         return (error);
 269 }