drivers/gpu/drm/i915/selftests/huge_gem_object.c

   1 /*
   2  * Copyright © 2016 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  */
  24
  25 #include "huge_gem_object.h"
  26
  27 static void huge_free_pages(struct drm_i915_gem_object *obj,
  28                             struct sg_table *pages)
  29 {
  30         unsigned long nreal = obj->scratch / PAGE_SIZE;
  31         struct scatterlist *sg;
  32
  33         for (sg = pages->sgl; sg && nreal--; sg = __sg_next(sg))
  34                 __free_page(sg_page(sg));
  35
  36         sg_free_table(pages);
  37         kfree(pages);
  38 }
  39
  40 static struct sg_table *
  41 huge_get_pages(struct drm_i915_gem_object *obj)
  42 {
  43 #define GFP (GFP_KERNEL | __GFP_NOWARN | __GFP_NORETRY)
  44         const unsigned long nreal = obj->scratch / PAGE_SIZE;
  45         const unsigned long npages = obj->base.size / PAGE_SIZE;
  46         struct scatterlist *sg, *src, *end;
  47         struct sg_table *pages;
  48         unsigned long n;
  49
  50         pages = kmalloc(sizeof(*pages), GFP);
  51         if (!pages)
  52                 return ERR_PTR(-ENOMEM);
  53
  54         if (sg_alloc_table(pages, npages, GFP)) {
  55                 kfree(pages);
  56                 return ERR_PTR(-ENOMEM);
  57         }
  58
  59         sg = pages->sgl;
  60         for (n = 0; n < nreal; n++) {
  61                 struct page *page;
  62
  63                 page = alloc_page(GFP | __GFP_HIGHMEM);
  64                 if (!page) {
  65                         sg_mark_end(sg);
  66                         goto err;
  67                 }
  68
  69                 sg_set_page(sg, page, PAGE_SIZE, 0);
  70                 sg = __sg_next(sg);
  71         }
  72         if (nreal < npages) {
  73                 for (end = sg, src = pages->sgl; sg; sg = __sg_next(sg)) {
  74                         sg_set_page(sg, sg_page(src), PAGE_SIZE, 0);
  75                         src = __sg_next(src);
  76                         if (src == end)
  77                                 src = pages->sgl;
  78                 }
  79         }
  80
  81         if (i915_gem_gtt_prepare_pages(obj, pages))
  82                 goto err;
  83
  84         return pages;
  85
  86 err:
  87         huge_free_pages(obj, pages);
  88         return ERR_PTR(-ENOMEM);
  89 #undef GFP
  90 }
  91
  92 static void huge_put_pages(struct drm_i915_gem_object *obj,
  93                            struct sg_table *pages)
  94 {
  95         i915_gem_gtt_finish_pages(obj, pages);
  96         huge_free_pages(obj, pages);
  97
  98         obj->mm.dirty = false;
  99 }
 100
 101 static const struct drm_i915_gem_object_ops huge_ops = {
 102         .flags = I915_GEM_OBJECT_HAS_STRUCT_PAGE |
 103                  I915_GEM_OBJECT_IS_SHRINKABLE,
 104         .get_pages = huge_get_pages,
 105         .put_pages = huge_put_pages,
 106 };
 107
 108 struct drm_i915_gem_object *
 109 huge_gem_object(struct drm_i915_private *i915,
 110                 phys_addr_t phys_size,
 111                 dma_addr_t dma_size)
 112 {
 113         struct drm_i915_gem_object *obj;
 114         unsigned int cache_level;
 115
 116         GEM_BUG_ON(!phys_size || phys_size > dma_size);
 117         GEM_BUG_ON(!IS_ALIGNED(phys_size, PAGE_SIZE));
 118         GEM_BUG_ON(!IS_ALIGNED(dma_size, I915_GTT_PAGE_SIZE));
 119
 120         if (overflows_type(dma_size, obj->base.size))
 121                 return ERR_PTR(-E2BIG);
 122
 123         obj = i915_gem_object_alloc(i915);
 124         if (!obj)
 125                 return ERR_PTR(-ENOMEM);
 126
 127         drm_gem_private_object_init(&i915->drm, &obj->base, dma_size);
 128         i915_gem_object_init(obj, &huge_ops);
 129
 130         obj->base.read_domains = I915_GEM_DOMAIN_CPU;
 131         obj->base.write_domain = I915_GEM_DOMAIN_CPU;
 132         cache_level = HAS_LLC(i915) ? I915_CACHE_LLC : I915_CACHE_NONE;
 133         i915_gem_object_set_cache_coherency(obj, cache_level);
 134         obj->scratch = phys_size;
 135
 136         return obj;
 137 }