dma_alloc_wc-Toy模板网

这篇具有很好参考价值的文章主要介绍了dma_alloc_wc。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

static inline void *dma_alloc_wc(struct device *dev, size_t size,
dma_addr_t *dma_addr, gfp_t gfp)
{
unsigned long attrs = DMA_ATTR_WRITE_COMBINE;

if (gfp & __GFP_NOWARN)
attrs |= DMA_ATTR_NO_WARN;

return dma_alloc_attrs(dev, size, dma_addr, gfp, attrs);
}

void *dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
       gfp_t flag, unsigned long attrs)
{
   const struct dma_map_ops *ops = get_dma_ops(dev);
   void *cpu_addr;

WARN_ON_ONCE(!dev->coherent_dma_mask);

if (dma_alloc_from_dev_coherent(dev, size, dma_handle, &cpu_addr))
return cpu_addr;

/* let the implementation decide on the zone to allocate from: */
flag &= ~(__GFP_DMA | __GFP_DMA32 | __GFP_HIGHMEM);

   if (dma_is_direct(ops))
       cpu_addr = dma_direct_alloc(dev, size, dma_handle, flag, attrs);
   else if (ops->alloc)
       cpu_addr = ops->alloc(dev, size, dma_handle, flag, attrs);
   else
       return NULL;

debug_dma_alloc_coherent(dev, size, *dma_handle, cpu_addr);
return cpu_addr;
}

void *dma_direct_alloc(struct device *dev, size_t size,
       dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
{
   if (!IS_ENABLED(CONFIG_ARCH_HAS_UNCACHED_SEGMENT) &&
        dma_alloc_need_uncached(dev, attrs))
       return arch_dma_alloc(dev, size, dma_handle, gfp, attrs);
   return dma_direct_alloc_pages(dev, size, dma_handle, gfp, attrs);
}

void *dma_direct_alloc_pages(struct device *dev, size_t size,
       dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
{
   struct page *page;
   void *ret;

   page = __dma_direct_alloc_pages(dev, size, dma_handle, gfp, attrs);
   if (!page)
       return NULL;

   if ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) &&
        !force_dma_unencrypted(dev)) {
       /* remove any dirty cache lines on the kernel alias */
       if (!PageHighMem(page))
           arch_dma_prep_coherent(page, size);
       *dma_handle = phys_to_dma(dev, page_to_phys(page));
       /* return the page pointer as the opaque cookie */
       return page;
   }

   if (PageHighMem(page)) {
       /*
       * Depending on the cma= arguments and per-arch setup
       * dma_alloc_contiguous could return highmem pages.
       * Without remapping there is no way to return them here,
       * so log an error and fail.
       */
       dev_info(dev, "Rejecting highmem page from CMA.\n");
       __dma_direct_free_pages(dev, size, page);
       return NULL;
   }

   ret = page_address(page);
   if (force_dma_unencrypted(dev)) {
       set_memory_decrypted((unsigned long)ret, 1 << get_order(size));
       *dma_handle = __phys_to_dma(dev, page_to_phys(page));
   } else {
       *dma_handle = phys_to_dma(dev, page_to_phys(page));
   }
   memset(ret, 0, size);

   if (IS_ENABLED(CONFIG_ARCH_HAS_UNCACHED_SEGMENT) &&
        dma_alloc_need_uncached(dev, attrs)) {
       arch_dma_prep_coherent(page, size);
       ret = uncached_kernel_address(ret);
   }

return ret;
}

struct page *__dma_direct_alloc_pages(struct device *dev, size_t size,
       dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
{
   size_t alloc_size = PAGE_ALIGN(size);
   int node = dev_to_node(dev);
   struct page *page = NULL;
   u64 phys_mask;

if (attrs & DMA_ATTR_NO_WARN)
gfp |= __GFP_NOWARN;

   /* we always manually zero the memory once we are done: */
   gfp &= ~__GFP_ZERO;
   gfp |= __dma_direct_optimal_gfp_mask(dev, dev->coherent_dma_mask,
           &phys_mask);
   page = dma_alloc_contiguous(dev, alloc_size, gfp);
   if (page && !dma_coherent_ok(dev, page_to_phys(page), size)) {
       dma_free_contiguous(dev, page, alloc_size);
       page = NULL;
   }
again:
   if (!page)
       page = alloc_pages_node(node, gfp, get_order(alloc_size));
   if (page && !dma_coherent_ok(dev, page_to_phys(page), size)) {
       dma_free_contiguous(dev, page, size);
       page = NULL;

       if (IS_ENABLED(CONFIG_ZONE_DMA32) &&
            phys_mask < DMA_BIT_MASK(64) &&
            !(gfp & (GFP_DMA32 | GFP_DMA))) {
           gfp |= GFP_DMA32;
           goto again;
       }

       if (IS_ENABLED(CONFIG_ZONE_DMA) && !(gfp & GFP_DMA)) {
           gfp = (gfp & ~GFP_DMA32) | GFP_DMA;
           goto again;
       }
   }

return page;
}文章来源地址https://www.toymoban.com/news/detail-561166.html

/**
* dma_alloc_contiguous() - allocate contiguous pages
* @dev:   Pointer to device for which the allocation is performed.
* @size: Requested allocation size.
* @gfp:   Allocation flags.
*
* This function allocates contiguous memory buffer for specified device. It
* first tries to use device specific contiguous memory area if available or
* the default global one, then tries a fallback allocation of normal pages.
*
* Note that it byapss one-page size of allocations from the global area as
* the addresses within one page are always contiguous, so there is no need
* to waste CMA pages for that kind; it also helps reduce fragmentations.
*/
struct page *dma_alloc_contiguous(struct device *dev, size_t size, gfp_t gfp)
{
   size_t count = size >> PAGE_SHIFT;
   struct page *page = NULL;
   struct cma *cma = NULL;

   if (dev && dev->cma_area)
       cma = dev->cma_area;
   else if (count > 1)
       cma = dma_contiguous_default_area;

   /* CMA can be used only in the context which permits sleeping */
   if (cma && gfpflags_allow_blocking(gfp)) {
       size_t align = get_order(size);
       size_t cma_align = min_t(size_t, align, CONFIG_CMA_ALIGNMENT);

page = cma_alloc(cma, count, cma_align, gfp & __GFP_NOWARN);
}

return page;
}

到了这里，关于dma_alloc_wc的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！