LCOV - code coverage report
Current view: top level - drivers/iommu - dma-iommu.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 2 386 0.5 %
Date: 2022-04-01 14:35:51 Functions: 1 34 2.9 %
Branches: 0 220 0.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * A fairly generic DMA-API to IOMMU-API glue layer.
       4                 :            :  *
       5                 :            :  * Copyright (C) 2014-2015 ARM Ltd.
       6                 :            :  *
       7                 :            :  * based in part on arch/arm/mm/dma-mapping.c:
       8                 :            :  * Copyright (C) 2000-2004 Russell King
       9                 :            :  */
      10                 :            : 
      11                 :            : #include <linux/acpi_iort.h>
      12                 :            : #include <linux/device.h>
      13                 :            : #include <linux/dma-contiguous.h>
      14                 :            : #include <linux/dma-iommu.h>
      15                 :            : #include <linux/dma-noncoherent.h>
      16                 :            : #include <linux/gfp.h>
      17                 :            : #include <linux/huge_mm.h>
      18                 :            : #include <linux/iommu.h>
      19                 :            : #include <linux/iova.h>
      20                 :            : #include <linux/irq.h>
      21                 :            : #include <linux/mm.h>
      22                 :            : #include <linux/mutex.h>
      23                 :            : #include <linux/pci.h>
      24                 :            : #include <linux/scatterlist.h>
      25                 :            : #include <linux/vmalloc.h>
      26                 :            : #include <linux/crash_dump.h>
      27                 :            : 
      28                 :            : struct iommu_dma_msi_page {
      29                 :            :         struct list_head        list;
      30                 :            :         dma_addr_t              iova;
      31                 :            :         phys_addr_t             phys;
      32                 :            : };
      33                 :            : 
      34                 :            : enum iommu_dma_cookie_type {
      35                 :            :         IOMMU_DMA_IOVA_COOKIE,
      36                 :            :         IOMMU_DMA_MSI_COOKIE,
      37                 :            : };
      38                 :            : 
      39                 :            : struct iommu_dma_cookie {
      40                 :            :         enum iommu_dma_cookie_type      type;
      41                 :            :         union {
      42                 :            :                 /* Full allocator for IOMMU_DMA_IOVA_COOKIE */
      43                 :            :                 struct iova_domain      iovad;
      44                 :            :                 /* Trivial linear page allocator for IOMMU_DMA_MSI_COOKIE */
      45                 :            :                 dma_addr_t              msi_iova;
      46                 :            :         };
      47                 :            :         struct list_head                msi_page_list;
      48                 :            : 
      49                 :            :         /* Domain for flush queue callback; NULL if flush queue not in use */
      50                 :            :         struct iommu_domain             *fq_domain;
      51                 :            : };
      52                 :            : 
      53                 :          0 : static inline size_t cookie_msi_granule(struct iommu_dma_cookie *cookie)
      54                 :            : {
      55                 :          0 :         if (cookie->type == IOMMU_DMA_IOVA_COOKIE)
      56                 :          0 :                 return cookie->iovad.granule;
      57                 :            :         return PAGE_SIZE;
      58                 :            : }
      59                 :            : 
      60                 :          0 : static struct iommu_dma_cookie *cookie_alloc(enum iommu_dma_cookie_type type)
      61                 :            : {
      62                 :          0 :         struct iommu_dma_cookie *cookie;
      63                 :            : 
      64                 :          0 :         cookie = kzalloc(sizeof(*cookie), GFP_KERNEL);
      65   [ #  #  #  # ]:          0 :         if (cookie) {
      66                 :          0 :                 INIT_LIST_HEAD(&cookie->msi_page_list);
      67                 :          0 :                 cookie->type = type;
      68                 :            :         }
      69                 :          0 :         return cookie;
      70                 :            : }
      71                 :            : 
      72                 :            : /**
      73                 :            :  * iommu_get_dma_cookie - Acquire DMA-API resources for a domain
      74                 :            :  * @domain: IOMMU domain to prepare for DMA-API usage
      75                 :            :  *
      76                 :            :  * IOMMU drivers should normally call this from their domain_alloc
      77                 :            :  * callback when domain->type == IOMMU_DOMAIN_DMA.
      78                 :            :  */
      79                 :          0 : int iommu_get_dma_cookie(struct iommu_domain *domain)
      80                 :            : {
      81         [ #  # ]:          0 :         if (domain->iova_cookie)
      82                 :            :                 return -EEXIST;
      83                 :            : 
      84                 :          0 :         domain->iova_cookie = cookie_alloc(IOMMU_DMA_IOVA_COOKIE);
      85         [ #  # ]:          0 :         if (!domain->iova_cookie)
      86                 :          0 :                 return -ENOMEM;
      87                 :            : 
      88                 :            :         return 0;
      89                 :            : }
      90                 :            : EXPORT_SYMBOL(iommu_get_dma_cookie);
      91                 :            : 
      92                 :            : /**
      93                 :            :  * iommu_get_msi_cookie - Acquire just MSI remapping resources
      94                 :            :  * @domain: IOMMU domain to prepare
      95                 :            :  * @base: Start address of IOVA region for MSI mappings
      96                 :            :  *
      97                 :            :  * Users who manage their own IOVA allocation and do not want DMA API support,
      98                 :            :  * but would still like to take advantage of automatic MSI remapping, can use
      99                 :            :  * this to initialise their own domain appropriately. Users should reserve a
     100                 :            :  * contiguous IOVA region, starting at @base, large enough to accommodate the
     101                 :            :  * number of PAGE_SIZE mappings necessary to cover every MSI doorbell address
     102                 :            :  * used by the devices attached to @domain.
     103                 :            :  */
     104                 :          0 : int iommu_get_msi_cookie(struct iommu_domain *domain, dma_addr_t base)
     105                 :            : {
     106                 :          0 :         struct iommu_dma_cookie *cookie;
     107                 :            : 
     108         [ #  # ]:          0 :         if (domain->type != IOMMU_DOMAIN_UNMANAGED)
     109                 :            :                 return -EINVAL;
     110                 :            : 
     111         [ #  # ]:          0 :         if (domain->iova_cookie)
     112                 :            :                 return -EEXIST;
     113                 :            : 
     114                 :          0 :         cookie = cookie_alloc(IOMMU_DMA_MSI_COOKIE);
     115         [ #  # ]:          0 :         if (!cookie)
     116                 :            :                 return -ENOMEM;
     117                 :            : 
     118                 :          0 :         cookie->msi_iova = base;
     119                 :          0 :         domain->iova_cookie = cookie;
     120                 :          0 :         return 0;
     121                 :            : }
     122                 :            : EXPORT_SYMBOL(iommu_get_msi_cookie);
     123                 :            : 
     124                 :            : /**
     125                 :            :  * iommu_put_dma_cookie - Release a domain's DMA mapping resources
     126                 :            :  * @domain: IOMMU domain previously prepared by iommu_get_dma_cookie() or
     127                 :            :  *          iommu_get_msi_cookie()
     128                 :            :  *
     129                 :            :  * IOMMU drivers should normally call this from their domain_free callback.
     130                 :            :  */
     131                 :          0 : void iommu_put_dma_cookie(struct iommu_domain *domain)
     132                 :            : {
     133                 :          0 :         struct iommu_dma_cookie *cookie = domain->iova_cookie;
     134                 :          0 :         struct iommu_dma_msi_page *msi, *tmp;
     135                 :            : 
     136         [ #  # ]:          0 :         if (!cookie)
     137                 :            :                 return;
     138                 :            : 
     139   [ #  #  #  # ]:          0 :         if (cookie->type == IOMMU_DMA_IOVA_COOKIE && cookie->iovad.granule)
     140                 :          0 :                 put_iova_domain(&cookie->iovad);
     141                 :            : 
     142         [ #  # ]:          0 :         list_for_each_entry_safe(msi, tmp, &cookie->msi_page_list, list) {
     143                 :          0 :                 list_del(&msi->list);
     144                 :          0 :                 kfree(msi);
     145                 :            :         }
     146                 :          0 :         kfree(cookie);
     147                 :          0 :         domain->iova_cookie = NULL;
     148                 :            : }
     149                 :            : EXPORT_SYMBOL(iommu_put_dma_cookie);
     150                 :            : 
     151                 :            : /**
     152                 :            :  * iommu_dma_get_resv_regions - Reserved region driver helper
     153                 :            :  * @dev: Device from iommu_get_resv_regions()
     154                 :            :  * @list: Reserved region list from iommu_get_resv_regions()
     155                 :            :  *
     156                 :            :  * IOMMU drivers can use this to implement their .get_resv_regions callback
     157                 :            :  * for general non-IOMMU-specific reservations. Currently, this covers GICv3
     158                 :            :  * ITS region reservation on ACPI based ARM platforms that may require HW MSI
     159                 :            :  * reservation.
     160                 :            :  */
     161                 :          0 : void iommu_dma_get_resv_regions(struct device *dev, struct list_head *list)
     162                 :            : {
     163                 :            : 
     164                 :          0 :         if (!is_of_node(dev_iommu_fwspec_get(dev)->iommu_fwnode))
     165                 :          0 :                 iort_iommu_msi_get_resv_regions(dev, list);
     166                 :            : 
     167                 :          0 : }
     168                 :            : EXPORT_SYMBOL(iommu_dma_get_resv_regions);
     169                 :            : 
     170                 :          0 : static int cookie_init_hw_msi_region(struct iommu_dma_cookie *cookie,
     171                 :            :                 phys_addr_t start, phys_addr_t end)
     172                 :            : {
     173                 :          0 :         struct iova_domain *iovad = &cookie->iovad;
     174                 :          0 :         struct iommu_dma_msi_page *msi_page;
     175                 :          0 :         int i, num_pages;
     176                 :            : 
     177                 :          0 :         start -= iova_offset(iovad, start);
     178                 :          0 :         num_pages = iova_align(iovad, end - start) >> iova_shift(iovad);
     179                 :            : 
     180         [ #  # ]:          0 :         for (i = 0; i < num_pages; i++) {
     181                 :          0 :                 msi_page = kmalloc(sizeof(*msi_page), GFP_KERNEL);
     182         [ #  # ]:          0 :                 if (!msi_page)
     183                 :            :                         return -ENOMEM;
     184                 :            : 
     185                 :          0 :                 msi_page->phys = start;
     186                 :          0 :                 msi_page->iova = start;
     187                 :          0 :                 INIT_LIST_HEAD(&msi_page->list);
     188                 :          0 :                 list_add(&msi_page->list, &cookie->msi_page_list);
     189                 :          0 :                 start += iovad->granule;
     190                 :            :         }
     191                 :            : 
     192                 :            :         return 0;
     193                 :            : }
     194                 :            : 
     195                 :          0 : static int iova_reserve_pci_windows(struct pci_dev *dev,
     196                 :            :                 struct iova_domain *iovad)
     197                 :            : {
     198                 :          0 :         struct pci_host_bridge *bridge = pci_find_host_bridge(dev->bus);
     199                 :          0 :         struct resource_entry *window;
     200                 :          0 :         unsigned long lo, hi;
     201                 :          0 :         phys_addr_t start = 0, end;
     202                 :            : 
     203         [ #  # ]:          0 :         resource_list_for_each_entry(window, &bridge->windows) {
     204         [ #  # ]:          0 :                 if (resource_type(window->res) != IORESOURCE_MEM)
     205                 :          0 :                         continue;
     206                 :            : 
     207                 :          0 :                 lo = iova_pfn(iovad, window->res->start - window->offset);
     208                 :          0 :                 hi = iova_pfn(iovad, window->res->end - window->offset);
     209                 :          0 :                 reserve_iova(iovad, lo, hi);
     210                 :            :         }
     211                 :            : 
     212                 :            :         /* Get reserved DMA windows from host bridge */
     213         [ #  # ]:          0 :         resource_list_for_each_entry(window, &bridge->dma_ranges) {
     214                 :          0 :                 end = window->res->start - window->offset;
     215                 :          0 : resv_iova:
     216         [ #  # ]:          0 :                 if (end > start) {
     217                 :          0 :                         lo = iova_pfn(iovad, start);
     218                 :          0 :                         hi = iova_pfn(iovad, end);
     219                 :          0 :                         reserve_iova(iovad, lo, hi);
     220                 :            :                 } else {
     221                 :            :                         /* dma_ranges list should be sorted */
     222                 :          0 :                         dev_err(&dev->dev, "Failed to reserve IOVA\n");
     223                 :          0 :                         return -EINVAL;
     224                 :            :                 }
     225                 :            : 
     226                 :          0 :                 start = window->res->end - window->offset + 1;
     227                 :            :                 /* If window is last entry */
     228   [ #  #  #  # ]:          0 :                 if (window->node.next == &bridge->dma_ranges &&
     229                 :            :                     end != ~(phys_addr_t)0) {
     230                 :          0 :                         end = ~(phys_addr_t)0;
     231                 :          0 :                         goto resv_iova;
     232                 :            :                 }
     233                 :            :         }
     234                 :            : 
     235                 :            :         return 0;
     236                 :            : }
     237                 :            : 
     238                 :            : static int iova_reserve_iommu_regions(struct device *dev,
     239                 :            :                 struct iommu_domain *domain)
     240                 :            : {
     241                 :            :         struct iommu_dma_cookie *cookie = domain->iova_cookie;
     242                 :            :         struct iova_domain *iovad = &cookie->iovad;
     243                 :            :         struct iommu_resv_region *region;
     244                 :            :         LIST_HEAD(resv_regions);
     245                 :            :         int ret = 0;
     246                 :            : 
     247                 :            :         if (dev_is_pci(dev)) {
     248                 :            :                 ret = iova_reserve_pci_windows(to_pci_dev(dev), iovad);
     249                 :            :                 if (ret)
     250                 :            :                         return ret;
     251                 :            :         }
     252                 :            : 
     253                 :            :         iommu_get_resv_regions(dev, &resv_regions);
     254                 :            :         list_for_each_entry(region, &resv_regions, list) {
     255                 :            :                 unsigned long lo, hi;
     256                 :            : 
     257                 :            :                 /* We ARE the software that manages these! */
     258                 :            :                 if (region->type == IOMMU_RESV_SW_MSI)
     259                 :            :                         continue;
     260                 :            : 
     261                 :            :                 lo = iova_pfn(iovad, region->start);
     262                 :            :                 hi = iova_pfn(iovad, region->start + region->length - 1);
     263                 :            :                 reserve_iova(iovad, lo, hi);
     264                 :            : 
     265                 :            :                 if (region->type == IOMMU_RESV_MSI)
     266                 :            :                         ret = cookie_init_hw_msi_region(cookie, region->start,
     267                 :            :                                         region->start + region->length);
     268                 :            :                 if (ret)
     269                 :            :                         break;
     270                 :            :         }
     271                 :            :         iommu_put_resv_regions(dev, &resv_regions);
     272                 :            : 
     273                 :            :         return ret;
     274                 :            : }
     275                 :            : 
     276                 :          0 : static void iommu_dma_flush_iotlb_all(struct iova_domain *iovad)
     277                 :            : {
     278                 :          0 :         struct iommu_dma_cookie *cookie;
     279                 :          0 :         struct iommu_domain *domain;
     280                 :            : 
     281                 :          0 :         cookie = container_of(iovad, struct iommu_dma_cookie, iovad);
     282                 :          0 :         domain = cookie->fq_domain;
     283                 :            :         /*
     284                 :            :          * The IOMMU driver supporting DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE
     285                 :            :          * implies that ops->flush_iotlb_all must be non-NULL.
     286                 :            :          */
     287                 :          0 :         domain->ops->flush_iotlb_all(domain);
     288                 :          0 : }
     289                 :            : 
     290                 :            : /**
     291                 :            :  * iommu_dma_init_domain - Initialise a DMA mapping domain
     292                 :            :  * @domain: IOMMU domain previously prepared by iommu_get_dma_cookie()
     293                 :            :  * @base: IOVA at which the mappable address space starts
     294                 :            :  * @size: Size of IOVA space
     295                 :            :  * @dev: Device the domain is being initialised for
     296                 :            :  *
     297                 :            :  * @base and @size should be exact multiples of IOMMU page granularity to
     298                 :            :  * avoid rounding surprises. If necessary, we reserve the page at address 0
     299                 :            :  * to ensure it is an invalid IOVA. It is safe to reinitialise a domain, but
     300                 :            :  * any change which could make prior IOVAs invalid will fail.
     301                 :            :  */
     302                 :          0 : static int iommu_dma_init_domain(struct iommu_domain *domain, dma_addr_t base,
     303                 :            :                 u64 size, struct device *dev)
     304                 :            : {
     305                 :          0 :         struct iommu_dma_cookie *cookie = domain->iova_cookie;
     306                 :          0 :         unsigned long order, base_pfn;
     307                 :          0 :         struct iova_domain *iovad;
     308                 :          0 :         int attr;
     309                 :            : 
     310   [ #  #  #  # ]:          0 :         if (!cookie || cookie->type != IOMMU_DMA_IOVA_COOKIE)
     311                 :            :                 return -EINVAL;
     312                 :            : 
     313                 :          0 :         iovad = &cookie->iovad;
     314                 :            : 
     315                 :            :         /* Use the smallest supported page size for IOVA granularity */
     316         [ #  # ]:          0 :         order = __ffs(domain->pgsize_bitmap);
     317                 :          0 :         base_pfn = max_t(unsigned long, 1, base >> order);
     318                 :            : 
     319                 :            :         /* Check the domain allows at least some access to the device... */
     320         [ #  # ]:          0 :         if (domain->geometry.force_aperture) {
     321         [ #  # ]:          0 :                 if (base > domain->geometry.aperture_end ||
     322         [ #  # ]:          0 :                     base + size <= domain->geometry.aperture_start) {
     323                 :          0 :                         pr_warn("specified DMA range outside IOMMU capability\n");
     324                 :          0 :                         return -EFAULT;
     325                 :            :                 }
     326                 :            :                 /* ...then finally give it a kicking to make sure it fits */
     327                 :          0 :                 base_pfn = max_t(unsigned long, base_pfn,
     328                 :            :                                 domain->geometry.aperture_start >> order);
     329                 :            :         }
     330                 :            : 
     331                 :            :         /* start_pfn is always nonzero for an already-initialised domain */
     332         [ #  # ]:          0 :         if (iovad->start_pfn) {
     333   [ #  #  #  # ]:          0 :                 if (1UL << order != iovad->granule ||
     334                 :            :                     base_pfn != iovad->start_pfn) {
     335                 :          0 :                         pr_warn("Incompatible range for DMA domain\n");
     336                 :          0 :                         return -EFAULT;
     337                 :            :                 }
     338                 :            : 
     339                 :            :                 return 0;
     340                 :            :         }
     341                 :            : 
     342                 :          0 :         init_iova_domain(iovad, 1UL << order, base_pfn);
     343                 :            : 
     344   [ #  #  #  # ]:          0 :         if (!cookie->fq_domain && !iommu_domain_get_attr(domain,
     345         [ #  # ]:          0 :                         DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE, &attr) && attr) {
     346                 :          0 :                 cookie->fq_domain = domain;
     347                 :          0 :                 init_iova_flush_queue(iovad, iommu_dma_flush_iotlb_all, NULL);
     348                 :            :         }
     349                 :            : 
     350         [ #  # ]:          0 :         if (!dev)
     351                 :            :                 return 0;
     352                 :            : 
     353                 :          0 :         return iova_reserve_iommu_regions(dev, domain);
     354                 :            : }
     355                 :            : 
     356                 :          0 : static int iommu_dma_deferred_attach(struct device *dev,
     357                 :            :                 struct iommu_domain *domain)
     358                 :            : {
     359                 :          0 :         const struct iommu_ops *ops = domain->ops;
     360                 :            : 
     361         [ #  # ]:          0 :         if (!is_kdump_kernel())
     362                 :            :                 return 0;
     363                 :            : 
     364   [ #  #  #  # ]:          0 :         if (unlikely(ops->is_attach_deferred &&
     365                 :            :                         ops->is_attach_deferred(domain, dev)))
     366                 :          0 :                 return iommu_attach_device(domain, dev);
     367                 :            : 
     368                 :            :         return 0;
     369                 :            : }
     370                 :            : 
     371                 :            : /**
     372                 :            :  * dma_info_to_prot - Translate DMA API directions and attributes to IOMMU API
     373                 :            :  *                    page flags.
     374                 :            :  * @dir: Direction of DMA transfer
     375                 :            :  * @coherent: Is the DMA master cache-coherent?
     376                 :            :  * @attrs: DMA attributes for the mapping
     377                 :            :  *
     378                 :            :  * Return: corresponding IOMMU API page protection flags
     379                 :            :  */
     380                 :          0 : static int dma_info_to_prot(enum dma_data_direction dir, bool coherent,
     381                 :            :                      unsigned long attrs)
     382                 :            : {
     383                 :          0 :         int prot = coherent ? IOMMU_CACHE : 0;
     384                 :            : 
     385   [ #  #  #  # ]:          0 :         if (attrs & DMA_ATTR_PRIVILEGED)
     386                 :          0 :                 prot |= IOMMU_PRIV;
     387                 :            : 
     388   [ #  #  #  #  :          0 :         switch (dir) {
          #  #  #  #  #  
                #  #  # ]
     389                 :          0 :         case DMA_BIDIRECTIONAL:
     390                 :          0 :                 return prot | IOMMU_READ | IOMMU_WRITE;
     391                 :          0 :         case DMA_TO_DEVICE:
     392                 :          0 :                 return prot | IOMMU_READ;
     393                 :          0 :         case DMA_FROM_DEVICE:
     394                 :          0 :                 return prot | IOMMU_WRITE;
     395                 :            :         default:
     396                 :            :                 return 0;
     397                 :            :         }
     398                 :            : }
     399                 :            : 
     400                 :            : static dma_addr_t iommu_dma_alloc_iova(struct iommu_domain *domain,
     401                 :            :                 size_t size, u64 dma_limit, struct device *dev)
     402                 :            : {
     403                 :            :         struct iommu_dma_cookie *cookie = domain->iova_cookie;
     404                 :            :         struct iova_domain *iovad = &cookie->iovad;
     405                 :            :         unsigned long shift, iova_len, iova = 0;
     406                 :            : 
     407                 :            :         if (cookie->type == IOMMU_DMA_MSI_COOKIE) {
     408                 :            :                 cookie->msi_iova += size;
     409                 :            :                 return cookie->msi_iova - size;
     410                 :            :         }
     411                 :            : 
     412                 :            :         shift = iova_shift(iovad);
     413                 :            :         iova_len = size >> shift;
     414                 :            :         /*
     415                 :            :          * Freeing non-power-of-two-sized allocations back into the IOVA caches
     416                 :            :          * will come back to bite us badly, so we have to waste a bit of space
     417                 :            :          * rounding up anything cacheable to make sure that can't happen. The
     418                 :            :          * order of the unadjusted size will still match upon freeing.
     419                 :            :          */
     420                 :            :         if (iova_len < (1 << (IOVA_RANGE_CACHE_MAX_SIZE - 1)))
     421                 :            :                 iova_len = roundup_pow_of_two(iova_len);
     422                 :            : 
     423                 :            :         dma_limit = min_not_zero(dma_limit, dev->bus_dma_limit);
     424                 :            : 
     425                 :            :         if (domain->geometry.force_aperture)
     426                 :            :                 dma_limit = min(dma_limit, (u64)domain->geometry.aperture_end);
     427                 :            : 
     428                 :            :         /* Try to get PCI devices a SAC address */
     429                 :            :         if (dma_limit > DMA_BIT_MASK(32) && dev_is_pci(dev))
     430                 :            :                 iova = alloc_iova_fast(iovad, iova_len,
     431                 :            :                                        DMA_BIT_MASK(32) >> shift, false);
     432                 :            : 
     433                 :            :         if (!iova)
     434                 :            :                 iova = alloc_iova_fast(iovad, iova_len, dma_limit >> shift,
     435                 :            :                                        true);
     436                 :            : 
     437                 :            :         return (dma_addr_t)iova << shift;
     438                 :            : }
     439                 :            : 
     440                 :          0 : static void iommu_dma_free_iova(struct iommu_dma_cookie *cookie,
     441                 :            :                 dma_addr_t iova, size_t size)
     442                 :            : {
     443                 :          0 :         struct iova_domain *iovad = &cookie->iovad;
     444                 :            : 
     445                 :            :         /* The MSI case is only ever cleaning up its most recent allocation */
     446         [ #  # ]:          0 :         if (cookie->type == IOMMU_DMA_MSI_COOKIE)
     447                 :          0 :                 cookie->msi_iova -= size;
     448         [ #  # ]:          0 :         else if (cookie->fq_domain)  /* non-strict mode */
     449                 :          0 :                 queue_iova(iovad, iova_pfn(iovad, iova),
     450                 :          0 :                                 size >> iova_shift(iovad), 0);
     451                 :            :         else
     452                 :          0 :                 free_iova_fast(iovad, iova_pfn(iovad, iova),
     453                 :          0 :                                 size >> iova_shift(iovad));
     454                 :          0 : }
     455                 :            : 
     456                 :          0 : static void __iommu_dma_unmap(struct device *dev, dma_addr_t dma_addr,
     457                 :            :                 size_t size)
     458                 :            : {
     459                 :          0 :         struct iommu_domain *domain = iommu_get_dma_domain(dev);
     460                 :          0 :         struct iommu_dma_cookie *cookie = domain->iova_cookie;
     461                 :          0 :         struct iova_domain *iovad = &cookie->iovad;
     462                 :          0 :         size_t iova_off = iova_offset(iovad, dma_addr);
     463                 :          0 :         struct iommu_iotlb_gather iotlb_gather;
     464                 :          0 :         size_t unmapped;
     465                 :            : 
     466                 :          0 :         dma_addr -= iova_off;
     467                 :          0 :         size = iova_align(iovad, size + iova_off);
     468                 :          0 :         iommu_iotlb_gather_init(&iotlb_gather);
     469                 :            : 
     470                 :          0 :         unmapped = iommu_unmap_fast(domain, dma_addr, size, &iotlb_gather);
     471         [ #  # ]:          0 :         WARN_ON(unmapped != size);
     472                 :            : 
     473         [ #  # ]:          0 :         if (!cookie->fq_domain)
     474         [ #  # ]:          0 :                 iommu_tlb_sync(domain, &iotlb_gather);
     475                 :          0 :         iommu_dma_free_iova(cookie, dma_addr, size);
     476                 :          0 : }
     477                 :            : 
     478                 :          0 : static dma_addr_t __iommu_dma_map(struct device *dev, phys_addr_t phys,
     479                 :            :                 size_t size, int prot, u64 dma_mask)
     480                 :            : {
     481                 :          0 :         struct iommu_domain *domain = iommu_get_dma_domain(dev);
     482                 :          0 :         struct iommu_dma_cookie *cookie = domain->iova_cookie;
     483                 :          0 :         struct iova_domain *iovad = &cookie->iovad;
     484                 :          0 :         size_t iova_off = iova_offset(iovad, phys);
     485                 :          0 :         dma_addr_t iova;
     486                 :            : 
     487         [ #  # ]:          0 :         if (unlikely(iommu_dma_deferred_attach(dev, domain)))
     488                 :            :                 return DMA_MAPPING_ERROR;
     489                 :            : 
     490                 :          0 :         size = iova_align(iovad, size + iova_off);
     491                 :            : 
     492                 :          0 :         iova = iommu_dma_alloc_iova(domain, size, dma_mask, dev);
     493         [ #  # ]:          0 :         if (!iova)
     494                 :            :                 return DMA_MAPPING_ERROR;
     495                 :            : 
     496         [ #  # ]:          0 :         if (iommu_map_atomic(domain, iova, phys - iova_off, size, prot)) {
     497                 :          0 :                 iommu_dma_free_iova(cookie, iova, size);
     498                 :          0 :                 return DMA_MAPPING_ERROR;
     499                 :            :         }
     500                 :          0 :         return iova + iova_off;
     501                 :            : }
     502                 :            : 
     503                 :            : static void __iommu_dma_free_pages(struct page **pages, int count)
     504                 :            : {
     505                 :            :         while (count--)
     506                 :            :                 __free_page(pages[count]);
     507                 :            :         kvfree(pages);
     508                 :            : }
     509                 :            : 
     510                 :            : static struct page **__iommu_dma_alloc_pages(struct device *dev,
     511                 :            :                 unsigned int count, unsigned long order_mask, gfp_t gfp)
     512                 :            : {
     513                 :            :         struct page **pages;
     514                 :            :         unsigned int i = 0, nid = dev_to_node(dev);
     515                 :            : 
     516                 :            :         order_mask &= (2U << MAX_ORDER) - 1;
     517                 :            :         if (!order_mask)
     518                 :            :                 return NULL;
     519                 :            : 
     520                 :            :         pages = kvzalloc(count * sizeof(*pages), GFP_KERNEL);
     521                 :            :         if (!pages)
     522                 :            :                 return NULL;
     523                 :            : 
     524                 :            :         /* IOMMU can map any pages, so himem can also be used here */
     525                 :            :         gfp |= __GFP_NOWARN | __GFP_HIGHMEM;
     526                 :            : 
     527                 :            :         while (count) {
     528                 :            :                 struct page *page = NULL;
     529                 :            :                 unsigned int order_size;
     530                 :            : 
     531                 :            :                 /*
     532                 :            :                  * Higher-order allocations are a convenience rather
     533                 :            :                  * than a necessity, hence using __GFP_NORETRY until
     534                 :            :                  * falling back to minimum-order allocations.
     535                 :            :                  */
     536                 :            :                 for (order_mask &= (2U << __fls(count)) - 1;
     537                 :            :                      order_mask; order_mask &= ~order_size) {
     538                 :            :                         unsigned int order = __fls(order_mask);
     539                 :            :                         gfp_t alloc_flags = gfp;
     540                 :            : 
     541                 :            :                         order_size = 1U << order;
     542                 :            :                         if (order_mask > order_size)
     543                 :            :                                 alloc_flags |= __GFP_NORETRY;
     544                 :            :                         page = alloc_pages_node(nid, alloc_flags, order);
     545                 :            :                         if (!page)
     546                 :            :                                 continue;
     547                 :            :                         if (!order)
     548                 :            :                                 break;
     549                 :            :                         if (!PageCompound(page)) {
     550                 :            :                                 split_page(page, order);
     551                 :            :                                 break;
     552                 :            :                         } else if (!split_huge_page(page)) {
     553                 :            :                                 break;
     554                 :            :                         }
     555                 :            :                         __free_pages(page, order);
     556                 :            :                 }
     557                 :            :                 if (!page) {
     558                 :            :                         __iommu_dma_free_pages(pages, i);
     559                 :            :                         return NULL;
     560                 :            :                 }
     561                 :            :                 count -= order_size;
     562                 :            :                 while (order_size--)
     563                 :            :                         pages[i++] = page++;
     564                 :            :         }
     565                 :            :         return pages;
     566                 :            : }
     567                 :            : 
     568                 :            : /**
     569                 :            :  * iommu_dma_alloc_remap - Allocate and map a buffer contiguous in IOVA space
     570                 :            :  * @dev: Device to allocate memory for. Must be a real device
     571                 :            :  *       attached to an iommu_dma_domain
     572                 :            :  * @size: Size of buffer in bytes
     573                 :            :  * @dma_handle: Out argument for allocated DMA handle
     574                 :            :  * @gfp: Allocation flags
     575                 :            :  * @attrs: DMA attributes for this allocation
     576                 :            :  *
     577                 :            :  * If @size is less than PAGE_SIZE, then a full CPU page will be allocated,
     578                 :            :  * but an IOMMU which supports smaller pages might not map the whole thing.
     579                 :            :  *
     580                 :            :  * Return: Mapped virtual address, or NULL on failure.
     581                 :            :  */
     582                 :            : static void *iommu_dma_alloc_remap(struct device *dev, size_t size,
     583                 :            :                 dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
     584                 :            : {
     585                 :            :         struct iommu_domain *domain = iommu_get_dma_domain(dev);
     586                 :            :         struct iommu_dma_cookie *cookie = domain->iova_cookie;
     587                 :            :         struct iova_domain *iovad = &cookie->iovad;
     588                 :            :         bool coherent = dev_is_dma_coherent(dev);
     589                 :            :         int ioprot = dma_info_to_prot(DMA_BIDIRECTIONAL, coherent, attrs);
     590                 :            :         pgprot_t prot = dma_pgprot(dev, PAGE_KERNEL, attrs);
     591                 :            :         unsigned int count, min_size, alloc_sizes = domain->pgsize_bitmap;
     592                 :            :         struct page **pages;
     593                 :            :         struct sg_table sgt;
     594                 :            :         dma_addr_t iova;
     595                 :            :         void *vaddr;
     596                 :            : 
     597                 :            :         *dma_handle = DMA_MAPPING_ERROR;
     598                 :            : 
     599                 :            :         if (unlikely(iommu_dma_deferred_attach(dev, domain)))
     600                 :            :                 return NULL;
     601                 :            : 
     602                 :            :         min_size = alloc_sizes & -alloc_sizes;
     603                 :            :         if (min_size < PAGE_SIZE) {
     604                 :            :                 min_size = PAGE_SIZE;
     605                 :            :                 alloc_sizes |= PAGE_SIZE;
     606                 :            :         } else {
     607                 :            :                 size = ALIGN(size, min_size);
     608                 :            :         }
     609                 :            :         if (attrs & DMA_ATTR_ALLOC_SINGLE_PAGES)
     610                 :            :                 alloc_sizes = min_size;
     611                 :            : 
     612                 :            :         count = PAGE_ALIGN(size) >> PAGE_SHIFT;
     613                 :            :         pages = __iommu_dma_alloc_pages(dev, count, alloc_sizes >> PAGE_SHIFT,
     614                 :            :                                         gfp);
     615                 :            :         if (!pages)
     616                 :            :                 return NULL;
     617                 :            : 
     618                 :            :         size = iova_align(iovad, size);
     619                 :            :         iova = iommu_dma_alloc_iova(domain, size, dev->coherent_dma_mask, dev);
     620                 :            :         if (!iova)
     621                 :            :                 goto out_free_pages;
     622                 :            : 
     623                 :            :         if (sg_alloc_table_from_pages(&sgt, pages, count, 0, size, GFP_KERNEL))
     624                 :            :                 goto out_free_iova;
     625                 :            : 
     626                 :            :         if (!(ioprot & IOMMU_CACHE)) {
     627                 :            :                 struct scatterlist *sg;
     628                 :            :                 int i;
     629                 :            : 
     630                 :            :                 for_each_sg(sgt.sgl, sg, sgt.orig_nents, i)
     631                 :            :                         arch_dma_prep_coherent(sg_page(sg), sg->length);
     632                 :            :         }
     633                 :            : 
     634                 :            :         if (iommu_map_sg_atomic(domain, iova, sgt.sgl, sgt.orig_nents, ioprot)
     635                 :            :                         < size)
     636                 :            :                 goto out_free_sg;
     637                 :            : 
     638                 :            :         vaddr = dma_common_pages_remap(pages, size, prot,
     639                 :            :                         __builtin_return_address(0));
     640                 :            :         if (!vaddr)
     641                 :            :                 goto out_unmap;
     642                 :            : 
     643                 :            :         *dma_handle = iova;
     644                 :            :         sg_free_table(&sgt);
     645                 :            :         return vaddr;
     646                 :            : 
     647                 :            : out_unmap:
     648                 :            :         __iommu_dma_unmap(dev, iova, size);
     649                 :            : out_free_sg:
     650                 :            :         sg_free_table(&sgt);
     651                 :            : out_free_iova:
     652                 :            :         iommu_dma_free_iova(cookie, iova, size);
     653                 :            : out_free_pages:
     654                 :            :         __iommu_dma_free_pages(pages, count);
     655                 :            :         return NULL;
     656                 :            : }
     657                 :            : 
     658                 :            : /**
     659                 :            :  * __iommu_dma_mmap - Map a buffer into provided user VMA
     660                 :            :  * @pages: Array representing buffer from __iommu_dma_alloc()
     661                 :            :  * @size: Size of buffer in bytes
     662                 :            :  * @vma: VMA describing requested userspace mapping
     663                 :            :  *
     664                 :            :  * Maps the pages of the buffer in @pages into @vma. The caller is responsible
     665                 :            :  * for verifying the correct size and protection of @vma beforehand.
     666                 :            :  */
     667                 :            : static int __iommu_dma_mmap(struct page **pages, size_t size,
     668                 :            :                 struct vm_area_struct *vma)
     669                 :            : {
     670                 :            :         return vm_map_pages(vma, pages, PAGE_ALIGN(size) >> PAGE_SHIFT);
     671                 :            : }
     672                 :            : 
     673                 :          0 : static void iommu_dma_sync_single_for_cpu(struct device *dev,
     674                 :            :                 dma_addr_t dma_handle, size_t size, enum dma_data_direction dir)
     675                 :            : {
     676                 :          0 :         phys_addr_t phys;
     677                 :            : 
     678                 :          0 :         if (dev_is_dma_coherent(dev))
     679                 :          0 :                 return;
     680                 :            : 
     681                 :            :         phys = iommu_iova_to_phys(iommu_get_dma_domain(dev), dma_handle);
     682                 :            :         arch_sync_dma_for_cpu(phys, size, dir);
     683                 :            : }
     684                 :            : 
     685                 :          0 : static void iommu_dma_sync_single_for_device(struct device *dev,
     686                 :            :                 dma_addr_t dma_handle, size_t size, enum dma_data_direction dir)
     687                 :            : {
     688                 :          0 :         phys_addr_t phys;
     689                 :            : 
     690                 :          0 :         if (dev_is_dma_coherent(dev))
     691                 :          0 :                 return;
     692                 :            : 
     693                 :            :         phys = iommu_iova_to_phys(iommu_get_dma_domain(dev), dma_handle);
     694                 :            :         arch_sync_dma_for_device(phys, size, dir);
     695                 :            : }
     696                 :            : 
     697                 :          0 : static void iommu_dma_sync_sg_for_cpu(struct device *dev,
     698                 :            :                 struct scatterlist *sgl, int nelems,
     699                 :            :                 enum dma_data_direction dir)
     700                 :            : {
     701                 :          0 :         struct scatterlist *sg;
     702                 :          0 :         int i;
     703                 :            : 
     704                 :          0 :         if (dev_is_dma_coherent(dev))
     705                 :          0 :                 return;
     706                 :            : 
     707                 :            :         for_each_sg(sgl, sg, nelems, i)
     708                 :            :                 arch_sync_dma_for_cpu(sg_phys(sg), sg->length, dir);
     709                 :            : }
     710                 :            : 
     711                 :          0 : static void iommu_dma_sync_sg_for_device(struct device *dev,
     712                 :            :                 struct scatterlist *sgl, int nelems,
     713                 :            :                 enum dma_data_direction dir)
     714                 :            : {
     715                 :          0 :         struct scatterlist *sg;
     716                 :          0 :         int i;
     717                 :            : 
     718                 :          0 :         if (dev_is_dma_coherent(dev))
     719                 :          0 :                 return;
     720                 :            : 
     721                 :            :         for_each_sg(sgl, sg, nelems, i)
     722                 :            :                 arch_sync_dma_for_device(sg_phys(sg), sg->length, dir);
     723                 :            : }
     724                 :            : 
     725                 :          0 : static dma_addr_t iommu_dma_map_page(struct device *dev, struct page *page,
     726                 :            :                 unsigned long offset, size_t size, enum dma_data_direction dir,
     727                 :            :                 unsigned long attrs)
     728                 :            : {
     729                 :          0 :         phys_addr_t phys = page_to_phys(page) + offset;
     730         [ #  # ]:          0 :         bool coherent = dev_is_dma_coherent(dev);
     731         [ #  # ]:          0 :         int prot = dma_info_to_prot(dir, coherent, attrs);
     732                 :          0 :         dma_addr_t dma_handle;
     733                 :            : 
     734         [ #  # ]:          0 :         dma_handle = __iommu_dma_map(dev, phys, size, prot, dma_get_mask(dev));
     735                 :          0 :         if (!coherent && !(attrs & DMA_ATTR_SKIP_CPU_SYNC) &&
     736                 :            :             dma_handle != DMA_MAPPING_ERROR)
     737                 :            :                 arch_sync_dma_for_device(phys, size, dir);
     738                 :          0 :         return dma_handle;
     739                 :            : }
     740                 :            : 
     741                 :          0 : static void iommu_dma_unmap_page(struct device *dev, dma_addr_t dma_handle,
     742                 :            :                 size_t size, enum dma_data_direction dir, unsigned long attrs)
     743                 :            : {
     744                 :          0 :         if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
     745                 :            :                 iommu_dma_sync_single_for_cpu(dev, dma_handle, size, dir);
     746                 :          0 :         __iommu_dma_unmap(dev, dma_handle, size);
     747                 :          0 : }
     748                 :            : 
     749                 :            : /*
     750                 :            :  * Prepare a successfully-mapped scatterlist to give back to the caller.
     751                 :            :  *
     752                 :            :  * At this point the segments are already laid out by iommu_dma_map_sg() to
     753                 :            :  * avoid individually crossing any boundaries, so we merely need to check a
     754                 :            :  * segment's start address to avoid concatenating across one.
     755                 :            :  */
     756                 :          0 : static int __finalise_sg(struct device *dev, struct scatterlist *sg, int nents,
     757                 :            :                 dma_addr_t dma_addr)
     758                 :            : {
     759                 :          0 :         struct scatterlist *s, *cur = sg;
     760         [ #  # ]:          0 :         unsigned long seg_mask = dma_get_seg_boundary(dev);
     761         [ #  # ]:          0 :         unsigned int cur_len = 0, max_len = dma_get_max_seg_size(dev);
     762                 :          0 :         int i, count = 0;
     763                 :            : 
     764         [ #  # ]:          0 :         for_each_sg(sg, s, nents, i) {
     765                 :            :                 /* Restore this segment's original unaligned fields first */
     766                 :          0 :                 unsigned int s_iova_off = sg_dma_address(s);
     767                 :          0 :                 unsigned int s_length = sg_dma_len(s);
     768                 :          0 :                 unsigned int s_iova_len = s->length;
     769                 :            : 
     770                 :          0 :                 s->offset += s_iova_off;
     771                 :          0 :                 s->length = s_length;
     772                 :          0 :                 sg_dma_address(s) = DMA_MAPPING_ERROR;
     773                 :          0 :                 sg_dma_len(s) = 0;
     774                 :            : 
     775                 :            :                 /*
     776                 :            :                  * Now fill in the real DMA data. If...
     777                 :            :                  * - there is a valid output segment to append to
     778                 :            :                  * - and this segment starts on an IOVA page boundary
     779                 :            :                  * - but doesn't fall at a segment boundary
     780                 :            :                  * - and wouldn't make the resulting output segment too long
     781                 :            :                  */
     782   [ #  #  #  # ]:          0 :                 if (cur_len && !s_iova_off && (dma_addr & seg_mask) &&
     783         [ #  # ]:          0 :                     (max_len - cur_len >= s_length)) {
     784                 :            :                         /* ...then concatenate it with the previous one */
     785                 :          0 :                         cur_len += s_length;
     786                 :            :                 } else {
     787                 :            :                         /* Otherwise start the next output segment */
     788         [ #  # ]:          0 :                         if (i > 0)
     789                 :          0 :                                 cur = sg_next(cur);
     790                 :          0 :                         cur_len = s_length;
     791                 :          0 :                         count++;
     792                 :            : 
     793                 :          0 :                         sg_dma_address(cur) = dma_addr + s_iova_off;
     794                 :            :                 }
     795                 :            : 
     796                 :          0 :                 sg_dma_len(cur) = cur_len;
     797                 :          0 :                 dma_addr += s_iova_len;
     798                 :            : 
     799         [ #  # ]:          0 :                 if (s_length + s_iova_off < s_iova_len)
     800                 :          0 :                         cur_len = 0;
     801                 :            :         }
     802                 :          0 :         return count;
     803                 :            : }
     804                 :            : 
     805                 :            : /*
     806                 :            :  * If mapping failed, then just restore the original list,
     807                 :            :  * but making sure the DMA fields are invalidated.
     808                 :            :  */
     809                 :          0 : static void __invalidate_sg(struct scatterlist *sg, int nents)
     810                 :            : {
     811                 :          0 :         struct scatterlist *s;
     812                 :          0 :         int i;
     813                 :            : 
     814         [ #  # ]:          0 :         for_each_sg(sg, s, nents, i) {
     815         [ #  # ]:          0 :                 if (sg_dma_address(s) != DMA_MAPPING_ERROR)
     816                 :          0 :                         s->offset += sg_dma_address(s);
     817         [ #  # ]:          0 :                 if (sg_dma_len(s))
     818                 :          0 :                         s->length = sg_dma_len(s);
     819                 :          0 :                 sg_dma_address(s) = DMA_MAPPING_ERROR;
     820                 :          0 :                 sg_dma_len(s) = 0;
     821                 :            :         }
     822                 :          0 : }
     823                 :            : 
     824                 :            : /*
     825                 :            :  * The DMA API client is passing in a scatterlist which could describe
     826                 :            :  * any old buffer layout, but the IOMMU API requires everything to be
     827                 :            :  * aligned to IOMMU pages. Hence the need for this complicated bit of
     828                 :            :  * impedance-matching, to be able to hand off a suitably-aligned list,
     829                 :            :  * but still preserve the original offsets and sizes for the caller.
     830                 :            :  */
     831                 :          0 : static int iommu_dma_map_sg(struct device *dev, struct scatterlist *sg,
     832                 :            :                 int nents, enum dma_data_direction dir, unsigned long attrs)
     833                 :            : {
     834                 :          0 :         struct iommu_domain *domain = iommu_get_dma_domain(dev);
     835                 :          0 :         struct iommu_dma_cookie *cookie = domain->iova_cookie;
     836                 :          0 :         struct iova_domain *iovad = &cookie->iovad;
     837                 :          0 :         struct scatterlist *s, *prev = NULL;
     838         [ #  # ]:          0 :         int prot = dma_info_to_prot(dir, dev_is_dma_coherent(dev), attrs);
     839                 :          0 :         dma_addr_t iova;
     840                 :          0 :         size_t iova_len = 0;
     841         [ #  # ]:          0 :         unsigned long mask = dma_get_seg_boundary(dev);
     842                 :          0 :         int i;
     843                 :            : 
     844         [ #  # ]:          0 :         if (unlikely(iommu_dma_deferred_attach(dev, domain)))
     845                 :            :                 return 0;
     846                 :            : 
     847                 :            :         if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
     848                 :            :                 iommu_dma_sync_sg_for_device(dev, sg, nents, dir);
     849                 :            : 
     850                 :            :         /*
     851                 :            :          * Work out how much IOVA space we need, and align the segments to
     852                 :            :          * IOVA granules for the IOMMU driver to handle. With some clever
     853                 :            :          * trickery we can modify the list in-place, but reversibly, by
     854                 :            :          * stashing the unaligned parts in the as-yet-unused DMA fields.
     855                 :            :          */
     856         [ #  # ]:          0 :         for_each_sg(sg, s, nents, i) {
     857         [ #  # ]:          0 :                 size_t s_iova_off = iova_offset(iovad, s->offset);
     858                 :          0 :                 size_t s_length = s->length;
     859                 :          0 :                 size_t pad_len = (mask - iova_len + 1) & mask;
     860                 :            : 
     861                 :          0 :                 sg_dma_address(s) = s_iova_off;
     862                 :          0 :                 sg_dma_len(s) = s_length;
     863                 :          0 :                 s->offset -= s_iova_off;
     864         [ #  # ]:          0 :                 s_length = iova_align(iovad, s_length + s_iova_off);
     865                 :          0 :                 s->length = s_length;
     866                 :            : 
     867                 :            :                 /*
     868                 :            :                  * Due to the alignment of our single IOVA allocation, we can
     869                 :            :                  * depend on these assumptions about the segment boundary mask:
     870                 :            :                  * - If mask size >= IOVA size, then the IOVA range cannot
     871                 :            :                  *   possibly fall across a boundary, so we don't care.
     872                 :            :                  * - If mask size < IOVA size, then the IOVA range must start
     873                 :            :                  *   exactly on a boundary, therefore we can lay things out
     874                 :            :                  *   based purely on segment lengths without needing to know
     875                 :            :                  *   the actual addresses beforehand.
     876                 :            :                  * - The mask must be a power of 2, so pad_len == 0 if
     877                 :            :                  *   iova_len == 0, thus we cannot dereference prev the first
     878                 :            :                  *   time through here (i.e. before it has a meaningful value).
     879                 :            :                  */
     880   [ #  #  #  # ]:          0 :                 if (pad_len && pad_len < s_length - 1) {
     881                 :          0 :                         prev->length += pad_len;
     882                 :          0 :                         iova_len += pad_len;
     883                 :            :                 }
     884                 :            : 
     885                 :          0 :                 iova_len += s_length;
     886                 :          0 :                 prev = s;
     887                 :            :         }
     888                 :            : 
     889         [ #  # ]:          0 :         iova = iommu_dma_alloc_iova(domain, iova_len, dma_get_mask(dev), dev);
     890         [ #  # ]:          0 :         if (!iova)
     891                 :          0 :                 goto out_restore_sg;
     892                 :            : 
     893                 :            :         /*
     894                 :            :          * We'll leave any physical concatenation to the IOMMU driver's
     895                 :            :          * implementation - it knows better than we do.
     896                 :            :          */
     897         [ #  # ]:          0 :         if (iommu_map_sg_atomic(domain, iova, sg, nents, prot) < iova_len)
     898                 :          0 :                 goto out_free_iova;
     899                 :            : 
     900                 :          0 :         return __finalise_sg(dev, sg, nents, iova);
     901                 :            : 
     902                 :            : out_free_iova:
     903                 :          0 :         iommu_dma_free_iova(cookie, iova, iova_len);
     904                 :          0 : out_restore_sg:
     905                 :          0 :         __invalidate_sg(sg, nents);
     906                 :          0 :         return 0;
     907                 :            : }
     908                 :            : 
     909                 :          0 : static void iommu_dma_unmap_sg(struct device *dev, struct scatterlist *sg,
     910                 :            :                 int nents, enum dma_data_direction dir, unsigned long attrs)
     911                 :            : {
     912                 :          0 :         dma_addr_t start, end;
     913                 :          0 :         struct scatterlist *tmp;
     914                 :          0 :         int i;
     915                 :            : 
     916                 :          0 :         if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
     917                 :            :                 iommu_dma_sync_sg_for_cpu(dev, sg, nents, dir);
     918                 :            : 
     919                 :            :         /*
     920                 :            :          * The scatterlist segments are mapped into a single
     921                 :            :          * contiguous IOVA allocation, so this is incredibly easy.
     922                 :            :          */
     923                 :          0 :         start = sg_dma_address(sg);
     924         [ #  # ]:          0 :         for_each_sg(sg_next(sg), tmp, nents - 1, i) {
     925         [ #  # ]:          0 :                 if (sg_dma_len(tmp) == 0)
     926                 :            :                         break;
     927                 :          0 :                 sg = tmp;
     928                 :            :         }
     929                 :          0 :         end = sg_dma_address(sg) + sg_dma_len(sg);
     930                 :          0 :         __iommu_dma_unmap(dev, start, end - start);
     931                 :          0 : }
     932                 :            : 
     933                 :          0 : static dma_addr_t iommu_dma_map_resource(struct device *dev, phys_addr_t phys,
     934                 :            :                 size_t size, enum dma_data_direction dir, unsigned long attrs)
     935                 :            : {
     936         [ #  # ]:          0 :         return __iommu_dma_map(dev, phys, size,
     937                 :            :                         dma_info_to_prot(dir, false, attrs) | IOMMU_MMIO,
     938                 :            :                         dma_get_mask(dev));
     939                 :            : }
     940                 :            : 
     941                 :          0 : static void iommu_dma_unmap_resource(struct device *dev, dma_addr_t handle,
     942                 :            :                 size_t size, enum dma_data_direction dir, unsigned long attrs)
     943                 :            : {
     944                 :          0 :         __iommu_dma_unmap(dev, handle, size);
     945                 :          0 : }
     946                 :            : 
     947                 :            : static void __iommu_dma_free(struct device *dev, size_t size, void *cpu_addr)
     948                 :            : {
     949                 :            :         size_t alloc_size = PAGE_ALIGN(size);
     950                 :            :         int count = alloc_size >> PAGE_SHIFT;
     951                 :            :         struct page *page = NULL, **pages = NULL;
     952                 :            : 
     953                 :            :         /* Non-coherent atomic allocation? Easy */
     954                 :            :         if (IS_ENABLED(CONFIG_DMA_DIRECT_REMAP) &&
     955                 :            :             dma_free_from_pool(cpu_addr, alloc_size))
     956                 :            :                 return;
     957                 :            : 
     958                 :            :         if (IS_ENABLED(CONFIG_DMA_REMAP) && is_vmalloc_addr(cpu_addr)) {
     959                 :            :                 /*
     960                 :            :                  * If it the address is remapped, then it's either non-coherent
     961                 :            :                  * or highmem CMA, or an iommu_dma_alloc_remap() construction.
     962                 :            :                  */
     963                 :            :                 pages = dma_common_find_pages(cpu_addr);
     964                 :            :                 if (!pages)
     965                 :            :                         page = vmalloc_to_page(cpu_addr);
     966                 :            :                 dma_common_free_remap(cpu_addr, alloc_size);
     967                 :            :         } else {
     968                 :            :                 /* Lowmem means a coherent atomic or CMA allocation */
     969                 :            :                 page = virt_to_page(cpu_addr);
     970                 :            :         }
     971                 :            : 
     972                 :            :         if (pages)
     973                 :            :                 __iommu_dma_free_pages(pages, count);
     974                 :            :         if (page)
     975                 :            :                 dma_free_contiguous(dev, page, alloc_size);
     976                 :            : }
     977                 :            : 
     978                 :          0 : static void iommu_dma_free(struct device *dev, size_t size, void *cpu_addr,
     979                 :            :                 dma_addr_t handle, unsigned long attrs)
     980                 :            : {
     981                 :          0 :         __iommu_dma_unmap(dev, handle, size);
     982                 :          0 :         __iommu_dma_free(dev, size, cpu_addr);
     983                 :          0 : }
     984                 :            : 
     985                 :            : static void *iommu_dma_alloc_pages(struct device *dev, size_t size,
     986                 :            :                 struct page **pagep, gfp_t gfp, unsigned long attrs)
     987                 :            : {
     988                 :            :         bool coherent = dev_is_dma_coherent(dev);
     989                 :            :         size_t alloc_size = PAGE_ALIGN(size);
     990                 :            :         int node = dev_to_node(dev);
     991                 :            :         struct page *page = NULL;
     992                 :            :         void *cpu_addr;
     993                 :            : 
     994                 :            :         page = dma_alloc_contiguous(dev, alloc_size, gfp);
     995                 :            :         if (!page)
     996                 :            :                 page = alloc_pages_node(node, gfp, get_order(alloc_size));
     997                 :            :         if (!page)
     998                 :            :                 return NULL;
     999                 :            : 
    1000                 :            :         if (IS_ENABLED(CONFIG_DMA_REMAP) && (!coherent || PageHighMem(page))) {
    1001                 :            :                 pgprot_t prot = dma_pgprot(dev, PAGE_KERNEL, attrs);
    1002                 :            : 
    1003                 :            :                 cpu_addr = dma_common_contiguous_remap(page, alloc_size,
    1004                 :            :                                 prot, __builtin_return_address(0));
    1005                 :            :                 if (!cpu_addr)
    1006                 :            :                         goto out_free_pages;
    1007                 :            : 
    1008                 :            :                 if (!coherent)
    1009                 :            :                         arch_dma_prep_coherent(page, size);
    1010                 :            :         } else {
    1011                 :            :                 cpu_addr = page_address(page);
    1012                 :            :         }
    1013                 :            : 
    1014                 :            :         *pagep = page;
    1015                 :            :         memset(cpu_addr, 0, alloc_size);
    1016                 :            :         return cpu_addr;
    1017                 :            : out_free_pages:
    1018                 :            :         dma_free_contiguous(dev, page, alloc_size);
    1019                 :            :         return NULL;
    1020                 :            : }
    1021                 :            : 
    1022                 :          0 : static void *iommu_dma_alloc(struct device *dev, size_t size,
    1023                 :            :                 dma_addr_t *handle, gfp_t gfp, unsigned long attrs)
    1024                 :            : {
    1025         [ #  # ]:          0 :         bool coherent = dev_is_dma_coherent(dev);
    1026         [ #  # ]:          0 :         int ioprot = dma_info_to_prot(DMA_BIDIRECTIONAL, coherent, attrs);
    1027                 :          0 :         struct page *page = NULL;
    1028                 :          0 :         void *cpu_addr;
    1029                 :            : 
    1030                 :          0 :         gfp |= __GFP_ZERO;
    1031                 :            : 
    1032                 :          0 :         if (IS_ENABLED(CONFIG_DMA_REMAP) && gfpflags_allow_blocking(gfp) &&
    1033                 :            :             !(attrs & DMA_ATTR_FORCE_CONTIGUOUS))
    1034                 :            :                 return iommu_dma_alloc_remap(dev, size, handle, gfp, attrs);
    1035                 :            : 
    1036                 :          0 :         if (IS_ENABLED(CONFIG_DMA_DIRECT_REMAP) &&
    1037                 :            :             !gfpflags_allow_blocking(gfp) && !coherent)
    1038                 :            :                 cpu_addr = dma_alloc_from_pool(PAGE_ALIGN(size), &page, gfp);
    1039                 :            :         else
    1040                 :          0 :                 cpu_addr = iommu_dma_alloc_pages(dev, size, &page, gfp, attrs);
    1041         [ #  # ]:          0 :         if (!cpu_addr)
    1042                 :            :                 return NULL;
    1043                 :            : 
    1044                 :          0 :         *handle = __iommu_dma_map(dev, page_to_phys(page), size, ioprot,
    1045                 :            :                         dev->coherent_dma_mask);
    1046         [ #  # ]:          0 :         if (*handle == DMA_MAPPING_ERROR) {
    1047                 :          0 :                 __iommu_dma_free(dev, size, cpu_addr);
    1048                 :          0 :                 return NULL;
    1049                 :            :         }
    1050                 :            : 
    1051                 :            :         return cpu_addr;
    1052                 :            : }
    1053                 :            : 
    1054                 :          0 : static int iommu_dma_mmap(struct device *dev, struct vm_area_struct *vma,
    1055                 :            :                 void *cpu_addr, dma_addr_t dma_addr, size_t size,
    1056                 :            :                 unsigned long attrs)
    1057                 :            : {
    1058                 :          0 :         unsigned long nr_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
    1059                 :          0 :         unsigned long pfn, off = vma->vm_pgoff;
    1060                 :          0 :         int ret;
    1061                 :            : 
    1062                 :          0 :         vma->vm_page_prot = dma_pgprot(dev, vma->vm_page_prot, attrs);
    1063                 :            : 
    1064                 :          0 :         if (dma_mmap_from_dev_coherent(dev, vma, cpu_addr, size, &ret))
    1065                 :            :                 return ret;
    1066                 :            : 
    1067   [ #  #  #  # ]:          0 :         if (off >= nr_pages || vma_pages(vma) > nr_pages - off)
    1068                 :            :                 return -ENXIO;
    1069                 :            : 
    1070                 :          0 :         if (IS_ENABLED(CONFIG_DMA_REMAP) && is_vmalloc_addr(cpu_addr)) {
    1071                 :            :                 struct page **pages = dma_common_find_pages(cpu_addr);
    1072                 :            : 
    1073                 :            :                 if (pages)
    1074                 :            :                         return __iommu_dma_mmap(pages, size, vma);
    1075                 :            :                 pfn = vmalloc_to_pfn(cpu_addr);
    1076                 :            :         } else {
    1077         [ #  # ]:          0 :                 pfn = page_to_pfn(virt_to_page(cpu_addr));
    1078                 :            :         }
    1079                 :            : 
    1080                 :          0 :         return remap_pfn_range(vma, vma->vm_start, pfn + off,
    1081                 :            :                                vma->vm_end - vma->vm_start,
    1082                 :            :                                vma->vm_page_prot);
    1083                 :            : }
    1084                 :            : 
    1085                 :          0 : static int iommu_dma_get_sgtable(struct device *dev, struct sg_table *sgt,
    1086                 :            :                 void *cpu_addr, dma_addr_t dma_addr, size_t size,
    1087                 :            :                 unsigned long attrs)
    1088                 :            : {
    1089                 :          0 :         struct page *page;
    1090                 :          0 :         int ret;
    1091                 :            : 
    1092                 :          0 :         if (IS_ENABLED(CONFIG_DMA_REMAP) && is_vmalloc_addr(cpu_addr)) {
    1093                 :            :                 struct page **pages = dma_common_find_pages(cpu_addr);
    1094                 :            : 
    1095                 :            :                 if (pages) {
    1096                 :            :                         return sg_alloc_table_from_pages(sgt, pages,
    1097                 :            :                                         PAGE_ALIGN(size) >> PAGE_SHIFT,
    1098                 :            :                                         0, size, GFP_KERNEL);
    1099                 :            :                 }
    1100                 :            : 
    1101                 :            :                 page = vmalloc_to_page(cpu_addr);
    1102                 :            :         } else {
    1103         [ #  # ]:          0 :                 page = virt_to_page(cpu_addr);
    1104                 :            :         }
    1105                 :            : 
    1106                 :          0 :         ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
    1107         [ #  # ]:          0 :         if (!ret)
    1108         [ #  # ]:          0 :                 sg_set_page(sgt->sgl, page, PAGE_ALIGN(size), 0);
    1109                 :          0 :         return ret;
    1110                 :            : }
    1111                 :            : 
    1112                 :          0 : static unsigned long iommu_dma_get_merge_boundary(struct device *dev)
    1113                 :            : {
    1114                 :          0 :         struct iommu_domain *domain = iommu_get_dma_domain(dev);
    1115                 :            : 
    1116                 :          0 :         return (1UL << __ffs(domain->pgsize_bitmap)) - 1;
    1117                 :            : }
    1118                 :            : 
    1119                 :            : static const struct dma_map_ops iommu_dma_ops = {
    1120                 :            :         .alloc                  = iommu_dma_alloc,
    1121                 :            :         .free                   = iommu_dma_free,
    1122                 :            :         .mmap                   = iommu_dma_mmap,
    1123                 :            :         .get_sgtable            = iommu_dma_get_sgtable,
    1124                 :            :         .map_page               = iommu_dma_map_page,
    1125                 :            :         .unmap_page             = iommu_dma_unmap_page,
    1126                 :            :         .map_sg                 = iommu_dma_map_sg,
    1127                 :            :         .unmap_sg               = iommu_dma_unmap_sg,
    1128                 :            :         .sync_single_for_cpu    = iommu_dma_sync_single_for_cpu,
    1129                 :            :         .sync_single_for_device = iommu_dma_sync_single_for_device,
    1130                 :            :         .sync_sg_for_cpu        = iommu_dma_sync_sg_for_cpu,
    1131                 :            :         .sync_sg_for_device     = iommu_dma_sync_sg_for_device,
    1132                 :            :         .map_resource           = iommu_dma_map_resource,
    1133                 :            :         .unmap_resource         = iommu_dma_unmap_resource,
    1134                 :            :         .get_merge_boundary     = iommu_dma_get_merge_boundary,
    1135                 :            : };
    1136                 :            : 
    1137                 :            : /*
    1138                 :            :  * The IOMMU core code allocates the default DMA domain, which the underlying
    1139                 :            :  * IOMMU driver needs to support via the dma-iommu layer.
    1140                 :            :  */
    1141                 :          0 : void iommu_setup_dma_ops(struct device *dev, u64 dma_base, u64 size)
    1142                 :            : {
    1143                 :          0 :         struct iommu_domain *domain = iommu_get_domain_for_dev(dev);
    1144                 :            : 
    1145         [ #  # ]:          0 :         if (!domain)
    1146                 :          0 :                 goto out_err;
    1147                 :            : 
    1148                 :            :         /*
    1149                 :            :          * The IOMMU core code allocates the default DMA domain, which the
    1150                 :            :          * underlying IOMMU driver needs to support via the dma-iommu layer.
    1151                 :            :          */
    1152         [ #  # ]:          0 :         if (domain->type == IOMMU_DOMAIN_DMA) {
    1153         [ #  # ]:          0 :                 if (iommu_dma_init_domain(domain, dma_base, size, dev))
    1154                 :          0 :                         goto out_err;
    1155                 :          0 :                 dev->dma_ops = &iommu_dma_ops;
    1156                 :            :         }
    1157                 :            : 
    1158                 :            :         return;
    1159                 :          0 : out_err:
    1160         [ #  # ]:          0 :          pr_warn("Failed to set up IOMMU for device %s; retaining platform DMA ops\n",
    1161                 :            :                  dev_name(dev));
    1162                 :            : }
    1163                 :            : 
    1164                 :          0 : static struct iommu_dma_msi_page *iommu_dma_get_msi_page(struct device *dev,
    1165                 :            :                 phys_addr_t msi_addr, struct iommu_domain *domain)
    1166                 :            : {
    1167                 :          0 :         struct iommu_dma_cookie *cookie = domain->iova_cookie;
    1168                 :          0 :         struct iommu_dma_msi_page *msi_page;
    1169                 :          0 :         dma_addr_t iova;
    1170                 :          0 :         int prot = IOMMU_WRITE | IOMMU_NOEXEC | IOMMU_MMIO;
    1171         [ #  # ]:          0 :         size_t size = cookie_msi_granule(cookie);
    1172                 :            : 
    1173                 :          0 :         msi_addr &= ~(phys_addr_t)(size - 1);
    1174         [ #  # ]:          0 :         list_for_each_entry(msi_page, &cookie->msi_page_list, list)
    1175         [ #  # ]:          0 :                 if (msi_page->phys == msi_addr)
    1176                 :          0 :                         return msi_page;
    1177                 :            : 
    1178                 :          0 :         msi_page = kzalloc(sizeof(*msi_page), GFP_KERNEL);
    1179         [ #  # ]:          0 :         if (!msi_page)
    1180                 :            :                 return NULL;
    1181                 :            : 
    1182         [ #  # ]:          0 :         iova = iommu_dma_alloc_iova(domain, size, dma_get_mask(dev), dev);
    1183         [ #  # ]:          0 :         if (!iova)
    1184                 :          0 :                 goto out_free_page;
    1185                 :            : 
    1186         [ #  # ]:          0 :         if (iommu_map(domain, iova, msi_addr, size, prot))
    1187                 :          0 :                 goto out_free_iova;
    1188                 :            : 
    1189                 :          0 :         INIT_LIST_HEAD(&msi_page->list);
    1190                 :          0 :         msi_page->phys = msi_addr;
    1191                 :          0 :         msi_page->iova = iova;
    1192                 :          0 :         list_add(&msi_page->list, &cookie->msi_page_list);
    1193                 :          0 :         return msi_page;
    1194                 :            : 
    1195                 :            : out_free_iova:
    1196                 :          0 :         iommu_dma_free_iova(cookie, iova, size);
    1197                 :          0 : out_free_page:
    1198                 :          0 :         kfree(msi_page);
    1199                 :          0 :         return NULL;
    1200                 :            : }
    1201                 :            : 
    1202                 :          0 : int iommu_dma_prepare_msi(struct msi_desc *desc, phys_addr_t msi_addr)
    1203                 :            : {
    1204                 :          0 :         struct device *dev = msi_desc_to_dev(desc);
    1205                 :          0 :         struct iommu_domain *domain = iommu_get_domain_for_dev(dev);
    1206                 :          0 :         struct iommu_dma_msi_page *msi_page;
    1207                 :          0 :         static DEFINE_MUTEX(msi_prepare_lock); /* see below */
    1208                 :            : 
    1209   [ #  #  #  # ]:          0 :         if (!domain || !domain->iova_cookie) {
    1210                 :          0 :                 desc->iommu_cookie = NULL;
    1211                 :          0 :                 return 0;
    1212                 :            :         }
    1213                 :            : 
    1214                 :            :         /*
    1215                 :            :          * In fact the whole prepare operation should already be serialised by
    1216                 :            :          * irq_domain_mutex further up the callchain, but that's pretty subtle
    1217                 :            :          * on its own, so consider this locking as failsafe documentation...
    1218                 :            :          */
    1219                 :          0 :         mutex_lock(&msi_prepare_lock);
    1220                 :          0 :         msi_page = iommu_dma_get_msi_page(dev, msi_addr, domain);
    1221                 :          0 :         mutex_unlock(&msi_prepare_lock);
    1222                 :            : 
    1223         [ #  # ]:          0 :         msi_desc_set_iommu_cookie(desc, msi_page);
    1224                 :            : 
    1225         [ #  # ]:          0 :         if (!msi_page)
    1226                 :          0 :                 return -ENOMEM;
    1227                 :            :         return 0;
    1228                 :            : }
    1229                 :            : 
    1230                 :          0 : void iommu_dma_compose_msi_msg(struct msi_desc *desc,
    1231                 :            :                                struct msi_msg *msg)
    1232                 :            : {
    1233                 :          0 :         struct device *dev = msi_desc_to_dev(desc);
    1234                 :          0 :         const struct iommu_domain *domain = iommu_get_domain_for_dev(dev);
    1235                 :          0 :         const struct iommu_dma_msi_page *msi_page;
    1236                 :            : 
    1237         [ #  # ]:          0 :         msi_page = msi_desc_get_iommu_cookie(desc);
    1238                 :            : 
    1239   [ #  #  #  #  :          0 :         if (!domain || !domain->iova_cookie || WARN_ON(!msi_page))
             #  #  #  # ]
    1240                 :            :                 return;
    1241                 :            : 
    1242                 :          0 :         msg->address_hi = upper_32_bits(msi_page->iova);
    1243         [ #  # ]:          0 :         msg->address_lo &= cookie_msi_granule(domain->iova_cookie) - 1;
    1244                 :          0 :         msg->address_lo += lower_32_bits(msi_page->iova);
    1245                 :            : }
    1246                 :            : 
    1247                 :         21 : static int iommu_dma_init(void)
    1248                 :            : {
    1249                 :         21 :         return iova_cache_get();
    1250                 :            : }
    1251                 :            : arch_initcall(iommu_dma_init);

Generated by: LCOV version 1.14