sys/x86/iommu/busdma_dmar.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2013 The FreeBSD Foundation
   5  * All rights reserved.
   6  *
   7  * This software was developed by Konstantin Belousov <kib@FreeBSD.org>
   8  * under sponsorship from the FreeBSD Foundation.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/domainset.h>
  38 #include <sys/malloc.h>
  39 #include <sys/bus.h>
  40 #include <sys/conf.h>
  41 #include <sys/interrupt.h>
  42 #include <sys/kernel.h>
  43 #include <sys/ktr.h>
  44 #include <sys/lock.h>
  45 #include <sys/proc.h>
  46 #include <sys/memdesc.h>
  47 #include <sys/mutex.h>
  48 #include <sys/sysctl.h>
  49 #include <sys/rman.h>
  50 #include <sys/taskqueue.h>
  51 #include <sys/tree.h>
  52 #include <sys/uio.h>
  53 #include <sys/vmem.h>
  54 #include <dev/pci/pcireg.h>
  55 #include <dev/pci/pcivar.h>
  56 #include <vm/vm.h>
  57 #include <vm/vm_extern.h>
  58 #include <vm/vm_kern.h>
  59 #include <vm/vm_object.h>
  60 #include <vm/vm_page.h>
  61 #include <vm/vm_map.h>
  62 #include <machine/atomic.h>
  63 #include <machine/bus.h>
  64 #include <machine/md_var.h>
  65 #include <machine/specialreg.h>
  66 #include <x86/include/busdma_impl.h>
  67 #include <x86/iommu/intel_reg.h>
  68 #include <x86/iommu/busdma_dmar.h>
  69 #include <x86/iommu/intel_dmar.h>
  70
  71 /*
  72  * busdma_dmar.c, the implementation of the busdma(9) interface using
  73  * DMAR units from Intel VT-d.
  74  */
  75
  76 static bool
  77 dmar_bus_dma_is_dev_disabled(int domain, int bus, int slot, int func)
  78 {
  79         char str[128], *env;
  80         int default_bounce;
  81         bool ret;
  82         static const char bounce_str[] = "bounce";
  83         static const char dmar_str[] = "dmar";
  84
  85         default_bounce = 0;
  86         env = kern_getenv("hw.busdma.default");
  87         if (env != NULL) {
  88                 if (strcmp(env, bounce_str) == 0)
  89                         default_bounce = 1;
  90                 else if (strcmp(env, dmar_str) == 0)
  91                         default_bounce = 0;
  92                 freeenv(env);
  93         }
  94
  95         snprintf(str, sizeof(str), "hw.busdma.pci%d.%d.%d.%d",
  96             domain, bus, slot, func);
  97         env = kern_getenv(str);
  98         if (env == NULL)
  99                 return (default_bounce != 0);
 100         if (strcmp(env, bounce_str) == 0)
 101                 ret = true;
 102         else if (strcmp(env, dmar_str) == 0)
 103                 ret = false;
 104         else
 105                 ret = default_bounce != 0;
 106         freeenv(env);
 107         return (ret);
 108 }
 109
 110 /*
 111  * Given original device, find the requester ID that will be seen by
 112  * the DMAR unit and used for page table lookup.  PCI bridges may take
 113  * ownership of transactions from downstream devices, so it may not be
 114  * the same as the BSF of the target device.  In those cases, all
 115  * devices downstream of the bridge must share a single mapping
 116  * domain, and must collectively be assigned to use either DMAR or
 117  * bounce mapping.
 118  */
 119 device_t
 120 dmar_get_requester(device_t dev, uint16_t *rid)
 121 {
 122         devclass_t pci_class;
 123         device_t l, pci, pcib, pcip, pcibp, requester;
 124         int cap_offset;
 125         uint16_t pcie_flags;
 126         bool bridge_is_pcie;
 127
 128         pci_class = devclass_find("pci");
 129         l = requester = dev;
 130
 131         *rid = pci_get_rid(dev);
 132
 133         /*
 134          * Walk the bridge hierarchy from the target device to the
 135          * host port to find the translating bridge nearest the DMAR
 136          * unit.
 137          */
 138         for (;;) {
 139                 pci = device_get_parent(l);
 140                 KASSERT(pci != NULL, ("dmar_get_requester(%s): NULL parent "
 141                     "for %s", device_get_name(dev), device_get_name(l)));
 142                 KASSERT(device_get_devclass(pci) == pci_class,
 143                     ("dmar_get_requester(%s): non-pci parent %s for %s",
 144                     device_get_name(dev), device_get_name(pci),
 145                     device_get_name(l)));
 146
 147                 pcib = device_get_parent(pci);
 148                 KASSERT(pcib != NULL, ("dmar_get_requester(%s): NULL bridge "
 149                     "for %s", device_get_name(dev), device_get_name(pci)));
 150
 151                 /*
 152                  * The parent of our "bridge" isn't another PCI bus,
 153                  * so pcib isn't a PCI->PCI bridge but rather a host
 154                  * port, and the requester ID won't be translated
 155                  * further.
 156                  */
 157                 pcip = device_get_parent(pcib);
 158                 if (device_get_devclass(pcip) != pci_class)
 159                         break;
 160                 pcibp = device_get_parent(pcip);
 161
 162                 if (pci_find_cap(l, PCIY_EXPRESS, &cap_offset) == 0) {
 163                         /*
 164                          * Do not stop the loop even if the target
 165                          * device is PCIe, because it is possible (but
 166                          * unlikely) to have a PCI->PCIe bridge
 167                          * somewhere in the hierarchy.
 168                          */
 169                         l = pcib;
 170                 } else {
 171                         /*
 172                          * Device is not PCIe, it cannot be seen as a
 173                          * requester by DMAR unit.  Check whether the
 174                          * bridge is PCIe.
 175                          */
 176                         bridge_is_pcie = pci_find_cap(pcib, PCIY_EXPRESS,
 177                             &cap_offset) == 0;
 178                         requester = pcib;
 179
 180                         /*
 181                          * Check for a buggy PCIe/PCI bridge that
 182                          * doesn't report the express capability.  If
 183                          * the bridge above it is express but isn't a
 184                          * PCI bridge, then we know pcib is actually a
 185                          * PCIe/PCI bridge.
 186                          */
 187                         if (!bridge_is_pcie && pci_find_cap(pcibp,
 188                             PCIY_EXPRESS, &cap_offset) == 0) {
 189                                 pcie_flags = pci_read_config(pcibp,
 190                                     cap_offset + PCIER_FLAGS, 2);
 191                                 if ((pcie_flags & PCIEM_FLAGS_TYPE) !=
 192                                     PCIEM_TYPE_PCI_BRIDGE)
 193                                         bridge_is_pcie = true;
 194                         }
 195
 196                         if (bridge_is_pcie) {
 197                                 /*
 198                                  * The current device is not PCIe, but
 199                                  * the bridge above it is.  This is a
 200                                  * PCIe->PCI bridge.  Assume that the
 201                                  * requester ID will be the secondary
 202                                  * bus number with slot and function
 203                                  * set to zero.
 204                                  *
 205                                  * XXX: Doesn't handle the case where
 206                                  * the bridge is PCIe->PCI-X, and the
 207                                  * bridge will only take ownership of
 208                                  * requests in some cases.  We should
 209                                  * provide context entries with the
 210                                  * same page tables for taken and
 211                                  * non-taken transactions.
 212                                  */
 213                                 *rid = PCI_RID(pci_get_bus(l), 0, 0);
 214                                 l = pcibp;
 215                         } else {
 216                                 /*
 217                                  * Neither the device nor the bridge
 218                                  * above it are PCIe.  This is a
 219                                  * conventional PCI->PCI bridge, which
 220                                  * will use the bridge's BSF as the
 221                                  * requester ID.
 222                                  */
 223                                 *rid = pci_get_rid(pcib);
 224                                 l = pcib;
 225                         }
 226                 }
 227         }
 228         return (requester);
 229 }
 230
 231 struct dmar_ctx *
 232 dmar_instantiate_ctx(struct dmar_unit *dmar, device_t dev, bool rmrr)
 233 {
 234         device_t requester;
 235         struct dmar_ctx *ctx;
 236         bool disabled;
 237         uint16_t rid;
 238
 239         requester = dmar_get_requester(dev, &rid);
 240
 241         /*
 242          * If the user requested the IOMMU disabled for the device, we
 243          * cannot disable the DMAR, due to possibility of other
 244          * devices on the same DMAR still requiring translation.
 245          * Instead provide the identity mapping for the device
 246          * context.
 247          */
 248         disabled = dmar_bus_dma_is_dev_disabled(pci_get_domain(requester),
 249             pci_get_bus(requester), pci_get_slot(requester),
 250             pci_get_function(requester));
 251         ctx = dmar_get_ctx_for_dev(dmar, requester, rid, disabled, rmrr);
 252         if (ctx == NULL)
 253                 return (NULL);
 254         if (disabled) {
 255                 /*
 256                  * Keep the first reference on context, release the
 257                  * later refs.
 258                  */
 259                 DMAR_LOCK(dmar);
 260                 if ((ctx->flags & DMAR_CTX_DISABLED) == 0) {
 261                         ctx->flags |= DMAR_CTX_DISABLED;
 262                         DMAR_UNLOCK(dmar);
 263                 } else {
 264                         dmar_free_ctx_locked(dmar, ctx);
 265                 }
 266                 ctx = NULL;
 267         }
 268         return (ctx);
 269 }
 270
 271 bus_dma_tag_t
 272 dmar_get_dma_tag(device_t dev, device_t child)
 273 {
 274         struct dmar_unit *dmar;
 275         struct dmar_ctx *ctx;
 276         bus_dma_tag_t res;
 277
 278         dmar = dmar_find(child, bootverbose);
 279         /* Not in scope of any DMAR ? */
 280         if (dmar == NULL)
 281                 return (NULL);
 282         if (!dmar->dma_enabled)
 283                 return (NULL);
 284         dmar_quirks_pre_use(dmar);
 285         dmar_instantiate_rmrr_ctxs(dmar);
 286
 287         ctx = dmar_instantiate_ctx(dmar, child, false);
 288         res = ctx == NULL ? NULL : (bus_dma_tag_t)&ctx->ctx_tag;
 289         return (res);
 290 }
 291
 292 static MALLOC_DEFINE(M_DMAR_DMAMAP, "dmar_dmamap", "Intel DMAR DMA Map");
 293
 294 static void dmar_bus_schedule_dmamap(struct dmar_unit *unit,
 295     struct bus_dmamap_dmar *map);
 296
 297 static int
 298 dmar_bus_dma_tag_create(bus_dma_tag_t parent, bus_size_t alignment,
 299     bus_addr_t boundary, bus_addr_t lowaddr, bus_addr_t highaddr,
 300     bus_dma_filter_t *filter, void *filterarg, bus_size_t maxsize,
 301     int nsegments, bus_size_t maxsegsz, int flags, bus_dma_lock_t *lockfunc,
 302     void *lockfuncarg, bus_dma_tag_t *dmat)
 303 {
 304         struct bus_dma_tag_dmar *newtag, *oldtag;
 305         int error;
 306
 307         *dmat = NULL;
 308         error = common_bus_dma_tag_create(parent != NULL ?
 309             &((struct bus_dma_tag_dmar *)parent)->common : NULL, alignment,
 310             boundary, lowaddr, highaddr, filter, filterarg, maxsize,
 311             nsegments, maxsegsz, flags, lockfunc, lockfuncarg,
 312             sizeof(struct bus_dma_tag_dmar), (void **)&newtag);
 313         if (error != 0)
 314                 goto out;
 315
 316         oldtag = (struct bus_dma_tag_dmar *)parent;
 317         newtag->common.impl = &bus_dma_dmar_impl;
 318         newtag->ctx = oldtag->ctx;
 319         newtag->owner = oldtag->owner;
 320
 321         *dmat = (bus_dma_tag_t)newtag;
 322 out:
 323         CTR4(KTR_BUSDMA, "%s returned tag %p tag flags 0x%x error %d",
 324             __func__, newtag, (newtag != NULL ? newtag->common.flags : 0),
 325             error);
 326         return (error);
 327 }
 328
 329 static int
 330 dmar_bus_dma_tag_set_domain(bus_dma_tag_t dmat)
 331 {
 332
 333         return (0);
 334 }
 335
 336 static int
 337 dmar_bus_dma_tag_destroy(bus_dma_tag_t dmat1)
 338 {
 339         struct bus_dma_tag_dmar *dmat, *dmat_copy, *parent;
 340         int error;
 341
 342         error = 0;
 343         dmat_copy = dmat = (struct bus_dma_tag_dmar *)dmat1;
 344
 345         if (dmat != NULL) {
 346                 if (dmat->map_count != 0) {
 347                         error = EBUSY;
 348                         goto out;
 349                 }
 350                 while (dmat != NULL) {
 351                         parent = (struct bus_dma_tag_dmar *)dmat->common.parent;
 352                         if (atomic_fetchadd_int(&dmat->common.ref_count, -1) ==
 353                             1) {
 354                                 if (dmat == &dmat->ctx->ctx_tag)
 355                                         dmar_free_ctx(dmat->ctx);
 356                                 free_domain(dmat->segments, M_DMAR_DMAMAP);
 357                                 free(dmat, M_DEVBUF);
 358                                 dmat = parent;
 359                         } else
 360                                 dmat = NULL;
 361                 }
 362         }
 363 out:
 364         CTR3(KTR_BUSDMA, "%s tag %p error %d", __func__, dmat_copy, error);
 365         return (error);
 366 }
 367
 368 static int
 369 dmar_bus_dmamap_create(bus_dma_tag_t dmat, int flags, bus_dmamap_t *mapp)
 370 {
 371         struct bus_dma_tag_dmar *tag;
 372         struct bus_dmamap_dmar *map;
 373
 374         tag = (struct bus_dma_tag_dmar *)dmat;
 375         map = malloc_domainset(sizeof(*map), M_DMAR_DMAMAP,
 376             DOMAINSET_PREF(tag->common.domain), M_NOWAIT | M_ZERO);
 377         if (map == NULL) {
 378                 *mapp = NULL;
 379                 return (ENOMEM);
 380         }
 381         if (tag->segments == NULL) {
 382                 tag->segments = malloc_domainset(sizeof(bus_dma_segment_t) *
 383                     tag->common.nsegments, M_DMAR_DMAMAP,
 384                     DOMAINSET_PREF(tag->common.domain), M_NOWAIT);
 385                 if (tag->segments == NULL) {
 386                         free_domain(map, M_DMAR_DMAMAP);
 387                         *mapp = NULL;
 388                         return (ENOMEM);
 389                 }
 390         }
 391         TAILQ_INIT(&map->map_entries);
 392         map->tag = tag;
 393         map->locked = true;
 394         map->cansleep = false;
 395         tag->map_count++;
 396         *mapp = (bus_dmamap_t)map;
 397
 398         return (0);
 399 }
 400
 401 static int
 402 dmar_bus_dmamap_destroy(bus_dma_tag_t dmat, bus_dmamap_t map1)
 403 {
 404         struct bus_dma_tag_dmar *tag;
 405         struct bus_dmamap_dmar *map;
 406         struct dmar_domain *domain;
 407
 408         tag = (struct bus_dma_tag_dmar *)dmat;
 409         map = (struct bus_dmamap_dmar *)map1;
 410         if (map != NULL) {
 411                 domain = tag->ctx->domain;
 412                 DMAR_DOMAIN_LOCK(domain);
 413                 if (!TAILQ_EMPTY(&map->map_entries)) {
 414                         DMAR_DOMAIN_UNLOCK(domain);
 415                         return (EBUSY);
 416                 }
 417                 DMAR_DOMAIN_UNLOCK(domain);
 418                 free_domain(map, M_DMAR_DMAMAP);
 419         }
 420         tag->map_count--;
 421         return (0);
 422 }
 423
 424
 425 static int
 426 dmar_bus_dmamem_alloc(bus_dma_tag_t dmat, void** vaddr, int flags,
 427     bus_dmamap_t *mapp)
 428 {
 429         struct bus_dma_tag_dmar *tag;
 430         struct bus_dmamap_dmar *map;
 431         int error, mflags;
 432         vm_memattr_t attr;
 433
 434         error = dmar_bus_dmamap_create(dmat, flags, mapp);
 435         if (error != 0)
 436                 return (error);
 437
 438         mflags = (flags & BUS_DMA_NOWAIT) != 0 ? M_NOWAIT : M_WAITOK;
 439         mflags |= (flags & BUS_DMA_ZERO) != 0 ? M_ZERO : 0;
 440         attr = (flags & BUS_DMA_NOCACHE) != 0 ? VM_MEMATTR_UNCACHEABLE :
 441             VM_MEMATTR_DEFAULT;
 442
 443         tag = (struct bus_dma_tag_dmar *)dmat;
 444         map = (struct bus_dmamap_dmar *)*mapp;
 445
 446         if (tag->common.maxsize < PAGE_SIZE &&
 447             tag->common.alignment <= tag->common.maxsize &&
 448             attr == VM_MEMATTR_DEFAULT) {
 449                 *vaddr = malloc_domainset(tag->common.maxsize, M_DEVBUF,
 450                     DOMAINSET_PREF(tag->common.domain), mflags);
 451                 map->flags |= BUS_DMAMAP_DMAR_MALLOC;
 452         } else {
 453                 *vaddr = (void *)kmem_alloc_attr_domainset(
 454                     DOMAINSET_PREF(tag->common.domain), tag->common.maxsize,
 455                     mflags, 0ul, BUS_SPACE_MAXADDR, attr);
 456                 map->flags |= BUS_DMAMAP_DMAR_KMEM_ALLOC;
 457         }
 458         if (*vaddr == NULL) {
 459                 dmar_bus_dmamap_destroy(dmat, *mapp);
 460                 *mapp = NULL;
 461                 return (ENOMEM);
 462         }
 463         return (0);
 464 }
 465
 466 static void
 467 dmar_bus_dmamem_free(bus_dma_tag_t dmat, void *vaddr, bus_dmamap_t map1)
 468 {
 469         struct bus_dma_tag_dmar *tag;
 470         struct bus_dmamap_dmar *map;
 471
 472         tag = (struct bus_dma_tag_dmar *)dmat;
 473         map = (struct bus_dmamap_dmar *)map1;
 474
 475         if ((map->flags & BUS_DMAMAP_DMAR_MALLOC) != 0) {
 476                 free_domain(vaddr, M_DEVBUF);
 477                 map->flags &= ~BUS_DMAMAP_DMAR_MALLOC;
 478         } else {
 479                 KASSERT((map->flags & BUS_DMAMAP_DMAR_KMEM_ALLOC) != 0,
 480                     ("dmar_bus_dmamem_free for non alloced map %p", map));
 481                 kmem_free((vm_offset_t)vaddr, tag->common.maxsize);
 482                 map->flags &= ~BUS_DMAMAP_DMAR_KMEM_ALLOC;
 483         }
 484
 485         dmar_bus_dmamap_destroy(dmat, map1);
 486 }
 487
 488 static int
 489 dmar_bus_dmamap_load_something1(struct bus_dma_tag_dmar *tag,
 490     struct bus_dmamap_dmar *map, vm_page_t *ma, int offset, bus_size_t buflen,
 491     int flags, bus_dma_segment_t *segs, int *segp,
 492     struct dmar_map_entries_tailq *unroll_list)
 493 {
 494         struct dmar_ctx *ctx;
 495         struct dmar_domain *domain;
 496         struct dmar_map_entry *entry;
 497         dmar_gaddr_t size;
 498         bus_size_t buflen1;
 499         int error, idx, gas_flags, seg;
 500
 501         KASSERT(offset < DMAR_PAGE_SIZE, ("offset %d", offset));
 502         if (segs == NULL)
 503                 segs = tag->segments;
 504         ctx = tag->ctx;
 505         domain = ctx->domain;
 506         seg = *segp;
 507         error = 0;
 508         idx = 0;
 509         while (buflen > 0) {
 510                 seg++;
 511                 if (seg >= tag->common.nsegments) {
 512                         error = EFBIG;
 513                         break;
 514                 }
 515                 buflen1 = buflen > tag->common.maxsegsz ?
 516                     tag->common.maxsegsz : buflen;
 517                 size = round_page(offset + buflen1);
 518
 519                 /*
 520                  * (Too) optimistically allow split if there are more
 521                  * then one segments left.
 522                  */
 523                 gas_flags = map->cansleep ? DMAR_GM_CANWAIT : 0;
 524                 if (seg + 1 < tag->common.nsegments)
 525                         gas_flags |= DMAR_GM_CANSPLIT;
 526
 527                 error = dmar_gas_map(domain, &tag->common, size, offset,
 528                     DMAR_MAP_ENTRY_READ |
 529                     ((flags & BUS_DMA_NOWRITE) == 0 ? DMAR_MAP_ENTRY_WRITE : 0),
 530                     gas_flags, ma + idx, &entry);
 531                 if (error != 0)
 532                         break;
 533                 if ((gas_flags & DMAR_GM_CANSPLIT) != 0) {
 534                         KASSERT(size >= entry->end - entry->start,
 535                             ("split increased entry size %jx %jx %jx",
 536                             (uintmax_t)size, (uintmax_t)entry->start,
 537                             (uintmax_t)entry->end));
 538                         size = entry->end - entry->start;
 539                         if (buflen1 > size)
 540                                 buflen1 = size;
 541                 } else {
 542                         KASSERT(entry->end - entry->start == size,
 543                             ("no split allowed %jx %jx %jx",
 544                             (uintmax_t)size, (uintmax_t)entry->start,
 545                             (uintmax_t)entry->end));
 546                 }
 547                 if (offset + buflen1 > size)
 548                         buflen1 = size - offset;
 549                 if (buflen1 > tag->common.maxsegsz)
 550                         buflen1 = tag->common.maxsegsz;
 551
 552                 KASSERT(((entry->start + offset) & (tag->common.alignment - 1))
 553                     == 0,
 554                     ("alignment failed: ctx %p start 0x%jx offset %x "
 555                     "align 0x%jx", ctx, (uintmax_t)entry->start, offset,
 556                     (uintmax_t)tag->common.alignment));
 557                 KASSERT(entry->end <= tag->common.lowaddr ||
 558                     entry->start >= tag->common.highaddr,
 559                     ("entry placement failed: ctx %p start 0x%jx end 0x%jx "
 560                     "lowaddr 0x%jx highaddr 0x%jx", ctx,
 561                     (uintmax_t)entry->start, (uintmax_t)entry->end,
 562                     (uintmax_t)tag->common.lowaddr,
 563                     (uintmax_t)tag->common.highaddr));
 564                 KASSERT(dmar_test_boundary(entry->start + offset, buflen1,
 565                     tag->common.boundary),
 566                     ("boundary failed: ctx %p start 0x%jx end 0x%jx "
 567                     "boundary 0x%jx", ctx, (uintmax_t)entry->start,
 568                     (uintmax_t)entry->end, (uintmax_t)tag->common.boundary));
 569                 KASSERT(buflen1 <= tag->common.maxsegsz,
 570                     ("segment too large: ctx %p start 0x%jx end 0x%jx "
 571                     "buflen1 0x%jx maxsegsz 0x%jx", ctx,
 572                     (uintmax_t)entry->start, (uintmax_t)entry->end,
 573                     (uintmax_t)buflen1, (uintmax_t)tag->common.maxsegsz));
 574
 575                 DMAR_DOMAIN_LOCK(domain);
 576                 TAILQ_INSERT_TAIL(&map->map_entries, entry, dmamap_link);
 577                 entry->flags |= DMAR_MAP_ENTRY_MAP;
 578                 DMAR_DOMAIN_UNLOCK(domain);
 579                 TAILQ_INSERT_TAIL(unroll_list, entry, unroll_link);
 580
 581                 segs[seg].ds_addr = entry->start + offset;
 582                 segs[seg].ds_len = buflen1;
 583
 584                 idx += OFF_TO_IDX(trunc_page(offset + buflen1));
 585                 offset += buflen1;
 586                 offset &= DMAR_PAGE_MASK;
 587                 buflen -= buflen1;
 588         }
 589         if (error == 0)
 590                 *segp = seg;
 591         return (error);
 592 }
 593
 594 static int
 595 dmar_bus_dmamap_load_something(struct bus_dma_tag_dmar *tag,
 596     struct bus_dmamap_dmar *map, vm_page_t *ma, int offset, bus_size_t buflen,
 597     int flags, bus_dma_segment_t *segs, int *segp)
 598 {
 599         struct dmar_ctx *ctx;
 600         struct dmar_domain *domain;
 601         struct dmar_map_entry *entry, *entry1;
 602         struct dmar_map_entries_tailq unroll_list;
 603         int error;
 604
 605         ctx = tag->ctx;
 606         domain = ctx->domain;
 607         atomic_add_long(&ctx->loads, 1);
 608
 609         TAILQ_INIT(&unroll_list);
 610         error = dmar_bus_dmamap_load_something1(tag, map, ma, offset,
 611             buflen, flags, segs, segp, &unroll_list);
 612         if (error != 0) {
 613                 /*
 614                  * The busdma interface does not allow us to report
 615                  * partial buffer load, so unfortunately we have to
 616                  * revert all work done.
 617                  */
 618                 DMAR_DOMAIN_LOCK(domain);
 619                 TAILQ_FOREACH_SAFE(entry, &unroll_list, unroll_link,
 620                     entry1) {
 621                         /*
 622                          * No entries other than what we have created
 623                          * during the failed run might have been
 624                          * inserted there in between, since we own ctx
 625                          * pglock.
 626                          */
 627                         TAILQ_REMOVE(&map->map_entries, entry, dmamap_link);
 628                         TAILQ_REMOVE(&unroll_list, entry, unroll_link);
 629                         TAILQ_INSERT_TAIL(&domain->unload_entries, entry,
 630                             dmamap_link);
 631                 }
 632                 DMAR_DOMAIN_UNLOCK(domain);
 633                 taskqueue_enqueue(domain->dmar->delayed_taskqueue,
 634                     &domain->unload_task);
 635         }
 636
 637         if (error == ENOMEM && (flags & BUS_DMA_NOWAIT) == 0 &&
 638             !map->cansleep)
 639                 error = EINPROGRESS;
 640         if (error == EINPROGRESS)
 641                 dmar_bus_schedule_dmamap(domain->dmar, map);
 642         return (error);
 643 }
 644
 645 static int
 646 dmar_bus_dmamap_load_ma(bus_dma_tag_t dmat, bus_dmamap_t map1,
 647     struct vm_page **ma, bus_size_t tlen, int ma_offs, int flags,
 648     bus_dma_segment_t *segs, int *segp)
 649 {
 650         struct bus_dma_tag_dmar *tag;
 651         struct bus_dmamap_dmar *map;
 652
 653         tag = (struct bus_dma_tag_dmar *)dmat;
 654         map = (struct bus_dmamap_dmar *)map1;
 655         return (dmar_bus_dmamap_load_something(tag, map, ma, ma_offs, tlen,
 656             flags, segs, segp));
 657 }
 658
 659 static int
 660 dmar_bus_dmamap_load_phys(bus_dma_tag_t dmat, bus_dmamap_t map1,
 661     vm_paddr_t buf, bus_size_t buflen, int flags, bus_dma_segment_t *segs,
 662     int *segp)
 663 {
 664         struct bus_dma_tag_dmar *tag;
 665         struct bus_dmamap_dmar *map;
 666         vm_page_t *ma, fma;
 667         vm_paddr_t pstart, pend, paddr;
 668         int error, i, ma_cnt, mflags, offset;
 669
 670         tag = (struct bus_dma_tag_dmar *)dmat;
 671         map = (struct bus_dmamap_dmar *)map1;
 672         pstart = trunc_page(buf);
 673         pend = round_page(buf + buflen);
 674         offset = buf & PAGE_MASK;
 675         ma_cnt = OFF_TO_IDX(pend - pstart);
 676         mflags = map->cansleep ? M_WAITOK : M_NOWAIT;
 677         ma = malloc(sizeof(vm_page_t) * ma_cnt, M_DEVBUF, mflags);
 678         if (ma == NULL)
 679                 return (ENOMEM);
 680         fma = NULL;
 681         for (i = 0; i < ma_cnt; i++) {
 682                 paddr = pstart + i * PAGE_SIZE;
 683                 ma[i] = PHYS_TO_VM_PAGE(paddr);
 684                 if (ma[i] == NULL || VM_PAGE_TO_PHYS(ma[i]) != paddr) {
 685                         /*
 686                          * If PHYS_TO_VM_PAGE() returned NULL or the
 687                          * vm_page was not initialized we'll use a
 688                          * fake page.
 689                          */
 690                         if (fma == NULL) {
 691                                 fma = malloc(sizeof(struct vm_page) * ma_cnt,
 692                                     M_DEVBUF, M_ZERO | mflags);
 693                                 if (fma == NULL) {
 694                                         free(ma, M_DEVBUF);
 695                                         return (ENOMEM);
 696                                 }
 697                         }
 698                         vm_page_initfake(&fma[i], pstart + i * PAGE_SIZE,
 699                             VM_MEMATTR_DEFAULT);
 700                         ma[i] = &fma[i];
 701                 }
 702         }
 703         error = dmar_bus_dmamap_load_something(tag, map, ma, offset, buflen,
 704             flags, segs, segp);
 705         free(fma, M_DEVBUF);
 706         free(ma, M_DEVBUF);
 707         return (error);
 708 }
 709
 710 static int
 711 dmar_bus_dmamap_load_buffer(bus_dma_tag_t dmat, bus_dmamap_t map1, void *buf,
 712     bus_size_t buflen, pmap_t pmap, int flags, bus_dma_segment_t *segs,
 713     int *segp)
 714 {
 715         struct bus_dma_tag_dmar *tag;
 716         struct bus_dmamap_dmar *map;
 717         vm_page_t *ma, fma;
 718         vm_paddr_t pstart, pend, paddr;
 719         int error, i, ma_cnt, mflags, offset;
 720
 721         tag = (struct bus_dma_tag_dmar *)dmat;
 722         map = (struct bus_dmamap_dmar *)map1;
 723         pstart = trunc_page((vm_offset_t)buf);
 724         pend = round_page((vm_offset_t)buf + buflen);
 725         offset = (vm_offset_t)buf & PAGE_MASK;
 726         ma_cnt = OFF_TO_IDX(pend - pstart);
 727         mflags = map->cansleep ? M_WAITOK : M_NOWAIT;
 728         ma = malloc(sizeof(vm_page_t) * ma_cnt, M_DEVBUF, mflags);
 729         if (ma == NULL)
 730                 return (ENOMEM);
 731         fma = NULL;
 732         for (i = 0; i < ma_cnt; i++, pstart += PAGE_SIZE) {
 733                 if (pmap == kernel_pmap)
 734                         paddr = pmap_kextract(pstart);
 735                 else
 736                         paddr = pmap_extract(pmap, pstart);
 737                 ma[i] = PHYS_TO_VM_PAGE(paddr);
 738                 if (ma[i] == NULL || VM_PAGE_TO_PHYS(ma[i]) != paddr) {
 739                         /*
 740                          * If PHYS_TO_VM_PAGE() returned NULL or the
 741                          * vm_page was not initialized we'll use a
 742                          * fake page.
 743                          */
 744                         if (fma == NULL) {
 745                                 fma = malloc(sizeof(struct vm_page) * ma_cnt,
 746                                     M_DEVBUF, M_ZERO | mflags);
 747                                 if (fma == NULL) {
 748                                         free(ma, M_DEVBUF);
 749                                         return (ENOMEM);
 750                                 }
 751                         }
 752                         vm_page_initfake(&fma[i], paddr, VM_MEMATTR_DEFAULT);
 753                         ma[i] = &fma[i];
 754                 }
 755         }
 756         error = dmar_bus_dmamap_load_something(tag, map, ma, offset, buflen,
 757             flags, segs, segp);
 758         free(ma, M_DEVBUF);
 759         free(fma, M_DEVBUF);
 760         return (error);
 761 }
 762
 763 static void
 764 dmar_bus_dmamap_waitok(bus_dma_tag_t dmat, bus_dmamap_t map1,
 765     struct memdesc *mem, bus_dmamap_callback_t *callback, void *callback_arg)
 766 {
 767         struct bus_dmamap_dmar *map;
 768
 769         if (map1 == NULL)
 770                 return;
 771         map = (struct bus_dmamap_dmar *)map1;
 772         map->mem = *mem;
 773         map->tag = (struct bus_dma_tag_dmar *)dmat;
 774         map->callback = callback;
 775         map->callback_arg = callback_arg;
 776 }
 777
 778 static bus_dma_segment_t *
 779 dmar_bus_dmamap_complete(bus_dma_tag_t dmat, bus_dmamap_t map1,
 780     bus_dma_segment_t *segs, int nsegs, int error)
 781 {
 782         struct bus_dma_tag_dmar *tag;
 783         struct bus_dmamap_dmar *map;
 784
 785         tag = (struct bus_dma_tag_dmar *)dmat;
 786         map = (struct bus_dmamap_dmar *)map1;
 787
 788         if (!map->locked) {
 789                 KASSERT(map->cansleep,
 790                     ("map not locked and not sleepable context %p", map));
 791
 792                 /*
 793                  * We are called from the delayed context.  Relock the
 794                  * driver.
 795                  */
 796                 (tag->common.lockfunc)(tag->common.lockfuncarg, BUS_DMA_LOCK);
 797                 map->locked = true;
 798         }
 799
 800         if (segs == NULL)
 801                 segs = tag->segments;
 802         return (segs);
 803 }
 804
 805 /*
 806  * The limitations of busdma KPI forces the dmar to perform the actual
 807  * unload, consisting of the unmapping of the map entries page tables,
 808  * from the delayed context on i386, since page table page mapping
 809  * might require a sleep to be successfull.  The unfortunate
 810  * consequence is that the DMA requests can be served some time after
 811  * the bus_dmamap_unload() call returned.
 812  *
 813  * On amd64, we assume that sf allocation cannot fail.
 814  */
 815 static void
 816 dmar_bus_dmamap_unload(bus_dma_tag_t dmat, bus_dmamap_t map1)
 817 {
 818         struct bus_dma_tag_dmar *tag;
 819         struct bus_dmamap_dmar *map;
 820         struct dmar_ctx *ctx;
 821         struct dmar_domain *domain;
 822 #if defined(__amd64__)
 823         struct dmar_map_entries_tailq entries;
 824 #endif
 825
 826         tag = (struct bus_dma_tag_dmar *)dmat;
 827         map = (struct bus_dmamap_dmar *)map1;
 828         ctx = tag->ctx;
 829         domain = ctx->domain;
 830         atomic_add_long(&ctx->unloads, 1);
 831
 832 #if defined(__i386__)
 833         DMAR_DOMAIN_LOCK(domain);
 834         TAILQ_CONCAT(&domain->unload_entries, &map->map_entries, dmamap_link);
 835         DMAR_DOMAIN_UNLOCK(domain);
 836         taskqueue_enqueue(domain->dmar->delayed_taskqueue,
 837             &domain->unload_task);
 838 #else /* defined(__amd64__) */
 839         TAILQ_INIT(&entries);
 840         DMAR_DOMAIN_LOCK(domain);
 841         TAILQ_CONCAT(&entries, &map->map_entries, dmamap_link);
 842         DMAR_DOMAIN_UNLOCK(domain);
 843         THREAD_NO_SLEEPING();
 844         dmar_domain_unload(domain, &entries, false);
 845         THREAD_SLEEPING_OK();
 846         KASSERT(TAILQ_EMPTY(&entries), ("lazy dmar_ctx_unload %p", ctx));
 847 #endif
 848 }
 849
 850 static void
 851 dmar_bus_dmamap_sync(bus_dma_tag_t dmat, bus_dmamap_t map,
 852     bus_dmasync_op_t op)
 853 {
 854 }
 855
 856 struct bus_dma_impl bus_dma_dmar_impl = {
 857         .tag_create = dmar_bus_dma_tag_create,
 858         .tag_destroy = dmar_bus_dma_tag_destroy,
 859         .tag_set_domain = dmar_bus_dma_tag_set_domain,
 860         .map_create = dmar_bus_dmamap_create,
 861         .map_destroy = dmar_bus_dmamap_destroy,
 862         .mem_alloc = dmar_bus_dmamem_alloc,
 863         .mem_free = dmar_bus_dmamem_free,
 864         .load_phys = dmar_bus_dmamap_load_phys,
 865         .load_buffer = dmar_bus_dmamap_load_buffer,
 866         .load_ma = dmar_bus_dmamap_load_ma,
 867         .map_waitok = dmar_bus_dmamap_waitok,
 868         .map_complete = dmar_bus_dmamap_complete,
 869         .map_unload = dmar_bus_dmamap_unload,
 870         .map_sync = dmar_bus_dmamap_sync,
 871 };
 872
 873 static void
 874 dmar_bus_task_dmamap(void *arg, int pending)
 875 {
 876         struct bus_dma_tag_dmar *tag;
 877         struct bus_dmamap_dmar *map;
 878         struct dmar_unit *unit;
 879
 880         unit = arg;
 881         DMAR_LOCK(unit);
 882         while ((map = TAILQ_FIRST(&unit->delayed_maps)) != NULL) {
 883                 TAILQ_REMOVE(&unit->delayed_maps, map, delay_link);
 884                 DMAR_UNLOCK(unit);
 885                 tag = map->tag;
 886                 map->cansleep = true;
 887                 map->locked = false;
 888                 bus_dmamap_load_mem((bus_dma_tag_t)tag, (bus_dmamap_t)map,
 889                     &map->mem, map->callback, map->callback_arg,
 890                     BUS_DMA_WAITOK);
 891                 map->cansleep = false;
 892                 if (map->locked) {
 893                         (tag->common.lockfunc)(tag->common.lockfuncarg,
 894                             BUS_DMA_UNLOCK);
 895                 } else
 896                         map->locked = true;
 897                 map->cansleep = false;
 898                 DMAR_LOCK(unit);
 899         }
 900         DMAR_UNLOCK(unit);
 901 }
 902
 903 static void
 904 dmar_bus_schedule_dmamap(struct dmar_unit *unit, struct bus_dmamap_dmar *map)
 905 {
 906
 907         map->locked = false;
 908         DMAR_LOCK(unit);
 909         TAILQ_INSERT_TAIL(&unit->delayed_maps, map, delay_link);
 910         DMAR_UNLOCK(unit);
 911         taskqueue_enqueue(unit->delayed_taskqueue, &unit->dmamap_load_task);
 912 }
 913
 914 int
 915 dmar_init_busdma(struct dmar_unit *unit)
 916 {
 917
 918         unit->dma_enabled = 1;
 919         TUNABLE_INT_FETCH("hw.dmar.dma", &unit->dma_enabled);
 920         TAILQ_INIT(&unit->delayed_maps);
 921         TASK_INIT(&unit->dmamap_load_task, 0, dmar_bus_task_dmamap, unit);
 922         unit->delayed_taskqueue = taskqueue_create("dmar", M_WAITOK,
 923             taskqueue_thread_enqueue, &unit->delayed_taskqueue);
 924         taskqueue_start_threads(&unit->delayed_taskqueue, 1, PI_DISK,
 925             "dmar%d busdma taskq", unit->unit);
 926         return (0);
 927 }
 928
 929 void
 930 dmar_fini_busdma(struct dmar_unit *unit)
 931 {
 932
 933         if (unit->delayed_taskqueue == NULL)
 934                 return;
 935
 936         taskqueue_drain(unit->delayed_taskqueue, &unit->dmamap_load_task);
 937         taskqueue_free(unit->delayed_taskqueue);
 938         unit->delayed_taskqueue = NULL;
 939 }