tools/bus_space/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  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/ioctl.h>
  31 #include <sys/mman.h>
  32 #include <assert.h>
  33 #include <errno.h>
  34 #include <fcntl.h>
  35 #include <limits.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <unistd.h>
  40
  41 #include "busdma.h"
  42
  43 #include "../../sys/dev/proto/proto_dev.h"
  44
  45 struct obj {
  46         int     oid;
  47         u_int   type;
  48 #define OBJ_TYPE_NONE   0
  49 #define OBJ_TYPE_TAG    1
  50 #define OBJ_TYPE_MD     2
  51 #define OBJ_TYPE_SEG    3
  52         u_int   refcnt;
  53         int     fd;
  54         struct obj *parent;
  55         u_long  key;
  56         union {
  57                 struct {
  58                         unsigned long   align;
  59                         unsigned long   bndry;
  60                         unsigned long   maxaddr;
  61                         unsigned long   maxsz;
  62                         unsigned long   maxsegsz;
  63                         unsigned long   nsegs;
  64                         unsigned long   datarate;
  65                 } tag;
  66                 struct {
  67                         struct obj      *seg[3];
  68                         int             nsegs[3];
  69 #define BUSDMA_MD_BUS   0
  70 #define BUSDMA_MD_PHYS  1
  71 #define BUSDMA_MD_VIRT  2
  72                 } md;
  73                 struct {
  74                         struct obj      *next;
  75                         unsigned long   address;
  76                         unsigned long   size;
  77                 } seg;
  78         } u;
  79 };
  80
  81 static struct obj **oidtbl = NULL;
  82 static int noids = 0;
  83
  84 static struct obj *
  85 obj_alloc(u_int type)
  86 {
  87         struct obj **newtbl, *obj;
  88         int oid;
  89
  90         obj = calloc(1, sizeof(struct obj));
  91         obj->type = type;
  92
  93         for (oid = 0; oid < noids; oid++) {
  94                 if (oidtbl[oid] == 0)
  95                         break;
  96         }
  97         if (oid == noids) {
  98                 newtbl = realloc(oidtbl, sizeof(struct obj *) * (noids + 1));
  99                 if (newtbl == NULL) {
 100                         free(obj);
 101                         return (NULL);
 102                 }
 103                 oidtbl = newtbl;
 104                 noids++;
 105         }
 106         oidtbl[oid] = obj;
 107         obj->oid = oid;
 108         return (obj);
 109 }
 110
 111 static int
 112 obj_free(struct obj *obj)
 113 {
 114
 115         oidtbl[obj->oid] = NULL;
 116         free(obj);
 117         return (0);
 118 }
 119
 120 static struct obj *
 121 obj_lookup(int oid, u_int type)
 122 {
 123         struct obj *obj;
 124
 125         if (oid < 0 || oid >= noids) {
 126                 errno = EINVAL;
 127                 return (NULL);
 128         }
 129         obj = oidtbl[oid];
 130         if (obj->refcnt == 0) {
 131                 errno = ENXIO;
 132                 return (NULL);
 133         }
 134         if (type != OBJ_TYPE_NONE && obj->type != type) {
 135                 errno = ENODEV;
 136                 return (NULL);
 137         }
 138         return (obj);
 139 }
 140
 141 static struct obj *
 142 bd_tag_new(struct obj *ptag, int fd, u_long align, u_long bndry,
 143     u_long maxaddr, u_long maxsz, u_int nsegs, u_long maxsegsz,
 144     u_int datarate, u_int flags)
 145 {
 146         struct proto_ioc_busdma ioc;
 147         struct obj *tag;
 148
 149         tag = obj_alloc(OBJ_TYPE_TAG);
 150         if (tag == NULL)
 151                 return (NULL);
 152
 153         memset(&ioc, 0, sizeof(ioc));
 154         ioc.request = (ptag != NULL) ? PROTO_IOC_BUSDMA_TAG_DERIVE :
 155             PROTO_IOC_BUSDMA_TAG_CREATE;
 156         ioc.key = (ptag != NULL) ? ptag->key : 0;
 157         ioc.u.tag.align = align;
 158         ioc.u.tag.bndry = bndry;
 159         ioc.u.tag.maxaddr = maxaddr;
 160         ioc.u.tag.maxsz = maxsz;
 161         ioc.u.tag.nsegs = nsegs;
 162         ioc.u.tag.maxsegsz = maxsegsz;
 163         ioc.u.tag.datarate = datarate;
 164         ioc.u.tag.flags = flags;
 165         if (ioctl(fd, PROTO_IOC_BUSDMA, &ioc) == -1) {
 166                 obj_free(tag);
 167                 return (NULL);
 168         }
 169         tag->refcnt = 1;
 170         tag->fd = fd;
 171         tag->parent = ptag;
 172         tag->key = ioc.result;
 173         tag->u.tag.align = ioc.u.tag.align;
 174         tag->u.tag.bndry = ioc.u.tag.bndry;
 175         tag->u.tag.maxaddr = ioc.u.tag.maxaddr;
 176         tag->u.tag.maxsz = ioc.u.tag.maxsz;
 177         tag->u.tag.maxsegsz = ioc.u.tag.maxsegsz;
 178         tag->u.tag.nsegs = ioc.u.tag.nsegs;
 179         tag->u.tag.datarate = ioc.u.tag.datarate;
 180         return (tag);
 181 }
 182
 183 int
 184 bd_tag_create(const char *dev, u_long align, u_long bndry, u_long maxaddr,
 185     u_long maxsz, u_int nsegs, u_long maxsegsz, u_int datarate, u_int flags)
 186 {
 187         char path[PATH_MAX];
 188         struct obj *tag;
 189         int fd, len;
 190
 191         len = snprintf(path, PATH_MAX, "/dev/proto/%s/busdma", dev);
 192         if (len >= PATH_MAX) {
 193                 errno = EINVAL;
 194                 return (-1);
 195         }
 196         fd = open(path, O_RDWR);
 197         if (fd == -1)
 198                 return (-1);
 199
 200         tag = bd_tag_new(NULL, fd, align, bndry, maxaddr, maxsz, nsegs,
 201             maxsegsz, datarate, flags);
 202         if (tag == NULL) {
 203                 close(fd);
 204                 return (-1);
 205         }
 206         return (tag->oid);
 207 }
 208
 209 int
 210 bd_tag_derive(int ptid, u_long align, u_long bndry, u_long maxaddr,
 211     u_long maxsz, u_int nsegs, u_long maxsegsz, u_int datarate, u_int flags)
 212 {
 213         struct obj *ptag, *tag;
 214
 215         ptag = obj_lookup(ptid, OBJ_TYPE_TAG);
 216         if (ptag == NULL)
 217                 return (-1);
 218
 219         tag = bd_tag_new(ptag, ptag->fd, align, bndry, maxaddr, maxsz, nsegs,
 220             maxsegsz, datarate, flags);
 221         if (tag == NULL)
 222                 return (-1);
 223         ptag->refcnt++;
 224         return (tag->oid);
 225 }
 226
 227 int
 228 bd_tag_destroy(int tid)
 229 {
 230         struct proto_ioc_busdma ioc;
 231         struct obj *ptag, *tag;
 232
 233         tag = obj_lookup(tid, OBJ_TYPE_TAG);
 234         if (tag == NULL)
 235                 return (errno);
 236         if (tag->refcnt > 1)
 237                 return (EBUSY);
 238
 239         memset(&ioc, 0, sizeof(ioc));
 240         ioc.request = PROTO_IOC_BUSDMA_TAG_DESTROY;
 241         ioc.key = tag->key;
 242         if (ioctl(tag->fd, PROTO_IOC_BUSDMA, &ioc) == -1)
 243                 return (errno);
 244
 245         if (tag->parent != NULL)
 246                 tag->parent->refcnt--;
 247         else
 248                 close(tag->fd);
 249         obj_free(tag);
 250         return (0);
 251 }
 252
 253 static int
 254 bd_md_add_seg(struct obj *md, int type, u_long addr, u_long size)
 255 {
 256         struct obj *seg;
 257
 258         seg = obj_alloc(OBJ_TYPE_SEG);
 259         if (seg == NULL)
 260                 return (errno);
 261         seg->refcnt = 1;
 262         seg->parent = md;
 263         seg->u.seg.address = addr;
 264         seg->u.seg.size = size;
 265
 266         md->u.md.seg[type] = seg;
 267         md->u.md.nsegs[type] = 1;
 268         return (0);
 269 }
 270
 271 static int
 272 bd_md_del_segs(struct obj *md, int type, int unmap)
 273 {
 274         struct obj *seg, *seg0;
 275
 276         for (seg = md->u.md.seg[type]; seg != NULL; seg = seg0) {
 277                 if (unmap)
 278                         munmap((void *)seg->u.seg.address, seg->u.seg.size);
 279                 seg0 = seg->u.seg.next;
 280                 obj_free(seg);
 281         }
 282         return (0);
 283 }
 284
 285 int
 286 bd_md_create(int tid, u_int flags)
 287 {
 288         struct proto_ioc_busdma ioc;
 289         struct obj *md, *tag;
 290
 291         tag = obj_lookup(tid, OBJ_TYPE_TAG);
 292         if (tag == NULL)
 293                 return (-1);
 294
 295         md = obj_alloc(OBJ_TYPE_MD);
 296         if (md == NULL)
 297                 return (-1);
 298
 299         memset(&ioc, 0, sizeof(ioc));
 300         ioc.request = PROTO_IOC_BUSDMA_MD_CREATE;
 301         ioc.u.md.tag = tag->key;
 302         ioc.u.md.flags = flags;
 303         if (ioctl(tag->fd, PROTO_IOC_BUSDMA, &ioc) == -1) {
 304                 obj_free(md);
 305                 return (-1);
 306         }
 307
 308         md->refcnt = 1;
 309         md->fd = tag->fd;
 310         md->parent = tag;
 311         tag->refcnt++;
 312         md->key = ioc.result;
 313         return (md->oid);
 314 }
 315
 316 int
 317 bd_md_destroy(int mdid)
 318 {
 319         struct proto_ioc_busdma ioc;
 320         struct obj *md;
 321
 322         md = obj_lookup(mdid, OBJ_TYPE_MD);
 323         if (md == NULL)
 324                 return (errno);
 325
 326         memset(&ioc, 0, sizeof(ioc));
 327         ioc.request = PROTO_IOC_BUSDMA_MD_DESTROY;
 328         ioc.key = md->key;
 329         if (ioctl(md->fd, PROTO_IOC_BUSDMA, &ioc) == -1)
 330                 return (errno);
 331
 332         md->parent->refcnt--;
 333         obj_free(md);
 334         return (0);
 335 }
 336
 337 int
 338 bd_md_load(int mdid, void *buf, u_long len, u_int flags)
 339 {
 340         struct proto_ioc_busdma ioc;
 341         struct obj *md;
 342         int error;
 343
 344         md = obj_lookup(mdid, OBJ_TYPE_MD);
 345         if (md == NULL)
 346                 return (errno);
 347
 348         memset(&ioc, 0, sizeof(ioc));
 349         ioc.request = PROTO_IOC_BUSDMA_MD_LOAD;
 350         ioc.key = md->key;
 351         ioc.u.md.flags = flags;
 352         ioc.u.md.virt_addr = (uintptr_t)buf;
 353         ioc.u.md.virt_size = len;
 354         if (ioctl(md->fd, PROTO_IOC_BUSDMA, &ioc) == -1)
 355                 return (errno);
 356
 357         error = bd_md_add_seg(md, BUSDMA_MD_VIRT, ioc.u.md.virt_addr, len);
 358         error = bd_md_add_seg(md, BUSDMA_MD_PHYS, ioc.u.md.phys_addr, len);
 359         error = bd_md_add_seg(md, BUSDMA_MD_BUS, ioc.u.md.bus_addr, len);
 360         return (error);
 361 }
 362
 363 int
 364 bd_md_unload(int mdid)
 365 {
 366         struct proto_ioc_busdma ioc;
 367         struct obj *md;
 368         int error;
 369
 370         md = obj_lookup(mdid, OBJ_TYPE_MD);
 371         if (md == NULL)
 372                 return (errno);
 373
 374         memset(&ioc, 0, sizeof(ioc));
 375         ioc.request = PROTO_IOC_BUSDMA_MD_UNLOAD;
 376         ioc.key = md->key;
 377         if (ioctl(md->fd, PROTO_IOC_BUSDMA, &ioc) == -1)
 378                 return (errno);
 379
 380         bd_md_del_segs(md, BUSDMA_MD_VIRT, 0);
 381         bd_md_del_segs(md, BUSDMA_MD_PHYS, 0);
 382         bd_md_del_segs(md, BUSDMA_MD_BUS, 0);
 383         return (0);
 384 }
 385
 386 int
 387 bd_mem_alloc(int tid, u_int flags)
 388 {
 389         struct proto_ioc_busdma ioc;
 390         struct obj *md, *tag;
 391         uintptr_t addr;
 392         int error;
 393
 394         tag = obj_lookup(tid, OBJ_TYPE_TAG);
 395         if (tag == NULL)
 396                 return (-1);
 397
 398         md = obj_alloc(OBJ_TYPE_MD);
 399         if (md == NULL)
 400                 return (-1);
 401
 402         memset(&ioc, 0, sizeof(ioc));
 403         ioc.request = PROTO_IOC_BUSDMA_MEM_ALLOC;
 404         ioc.u.md.tag = tag->key;
 405         ioc.u.md.flags = flags;
 406         if (ioctl(tag->fd, PROTO_IOC_BUSDMA, &ioc) == -1) {
 407                 obj_free(md);
 408                 return (-1);
 409         }
 410
 411         md->refcnt = 1;
 412         md->fd = tag->fd;
 413         md->parent = tag;
 414         tag->refcnt++;
 415         md->key = ioc.result;
 416
 417         /* XXX we need to support multiple segments */
 418         assert(ioc.u.md.phys_nsegs == 1);
 419         assert(ioc.u.md.bus_nsegs == 1);
 420         error = bd_md_add_seg(md, BUSDMA_MD_PHYS, ioc.u.md.phys_addr,
 421             tag->u.tag.maxsz);
 422         error = bd_md_add_seg(md, BUSDMA_MD_BUS, ioc.u.md.bus_addr,
 423             tag->u.tag.maxsz);
 424
 425         addr = (uintptr_t)mmap(NULL, tag->u.tag.maxsz, PROT_READ | PROT_WRITE,
 426             MAP_NOCORE | MAP_SHARED, md->fd, ioc.u.md.phys_addr);
 427         if (addr == (uintptr_t)MAP_FAILED)
 428                 goto fail;
 429         error = bd_md_add_seg(md, BUSDMA_MD_VIRT, addr, tag->u.tag.maxsz);
 430
 431         return (md->oid);
 432
 433  fail:
 434         memset(&ioc, 0, sizeof(ioc));
 435         ioc.request = PROTO_IOC_BUSDMA_MEM_FREE;
 436         ioc.key = md->key;
 437         ioctl(md->fd, PROTO_IOC_BUSDMA, &ioc);
 438         md->parent->refcnt--;
 439         obj_free(md);
 440         return (-1);
 441 }
 442
 443 int
 444 bd_mem_free(int mdid)
 445 {
 446         struct proto_ioc_busdma ioc;
 447         struct obj *md;
 448
 449         md = obj_lookup(mdid, OBJ_TYPE_MD);
 450         if (md == NULL)
 451                 return (errno);
 452
 453         memset(&ioc, 0, sizeof(ioc));
 454         ioc.request = PROTO_IOC_BUSDMA_MEM_FREE;
 455         ioc.key = md->key;
 456         if (ioctl(md->fd, PROTO_IOC_BUSDMA, &ioc) == -1)
 457                 return (errno);
 458
 459         bd_md_del_segs(md, BUSDMA_MD_VIRT, 1);
 460         bd_md_del_segs(md, BUSDMA_MD_PHYS, 0);
 461         bd_md_del_segs(md, BUSDMA_MD_BUS, 0);
 462         md->parent->refcnt--;
 463         obj_free(md);
 464         return (0);
 465 }
 466
 467 int
 468 bd_md_first_seg(int mdid, int space)
 469 {
 470         struct obj *md, *seg;
 471
 472         md = obj_lookup(mdid, OBJ_TYPE_MD);
 473         if (md == NULL)
 474                 return (-1);
 475
 476         if (space != BUSDMA_MD_BUS && space != BUSDMA_MD_PHYS &&
 477             space != BUSDMA_MD_VIRT) {
 478                 errno = EINVAL;
 479                 return (-1);
 480         }
 481         seg = md->u.md.seg[space];
 482         if (seg == NULL) {
 483                 errno = ENXIO;
 484                 return (-1);
 485         }
 486         return (seg->oid);
 487 }
 488
 489 int
 490 bd_md_next_seg(int mdid, int sid)
 491 {
 492         struct obj *seg;
 493
 494         seg = obj_lookup(sid, OBJ_TYPE_SEG);
 495         if (seg == NULL)
 496                 return (-1);
 497
 498         seg = seg->u.seg.next;
 499         if (seg == NULL) {
 500                 errno = ENXIO;
 501                 return (-1);
 502         }
 503         return (seg->oid);
 504 }
 505
 506 int
 507 bd_seg_get_addr(int sid, u_long *addr_p)
 508 {
 509         struct obj *seg;
 510
 511         if (addr_p == NULL)
 512                 return (EINVAL);
 513
 514         seg = obj_lookup(sid, OBJ_TYPE_SEG);
 515         if (seg == NULL)
 516                 return (errno);
 517
 518         *addr_p = seg->u.seg.address;
 519         return (0);
 520 }
 521
 522 int
 523 bd_seg_get_size(int sid, u_long *size_p)
 524 {
 525         struct obj *seg;
 526
 527         if (size_p == NULL)
 528                 return (EINVAL);
 529
 530         seg = obj_lookup(sid, OBJ_TYPE_SEG);
 531         if (seg == NULL)
 532                 return (errno);
 533
 534         *size_p = seg->u.seg.size;
 535         return (0);
 536 }
 537
 538 int
 539 bd_sync(int mdid, u_int op, u_long ofs, u_long len)
 540 {
 541         struct proto_ioc_busdma ioc;
 542         struct obj *md;
 543
 544         md = obj_lookup(mdid, OBJ_TYPE_MD);
 545         if (md == NULL)
 546                 return (errno);
 547
 548         memset(&ioc, 0, sizeof(ioc));
 549         ioc.request = PROTO_IOC_BUSDMA_SYNC;
 550         ioc.key = md->key;
 551         ioc.u.sync.op = op;
 552         ioc.u.sync.base = ofs;
 553         ioc.u.sync.size = len;
 554         if (ioctl(md->fd, PROTO_IOC_BUSDMA, &ioc) == -1)
 555                 return (errno);
 556
 557         return (0);
 558 }