drivers/gpu/drm/i915/i915_gem_dmabuf.c

   1 /*
   2  * Copyright 2012 Red Hat Inc
   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
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *      Dave Airlie <airlied@redhat.com>
  25  */
  26 #include <drm/drmP.h>
  27 #include "i915_drv.h"
  28 #include <linux/dma-buf.h>
  29
  30 static struct drm_i915_gem_object *dma_buf_to_obj(struct dma_buf *buf)
  31 {
  32         return to_intel_bo(buf->priv);
  33 }
  34
  35 static struct sg_table *i915_gem_map_dma_buf(struct dma_buf_attachment *attachment,
  36                                              enum dma_data_direction dir)
  37 {
  38         struct drm_i915_gem_object *obj = dma_buf_to_obj(attachment->dmabuf);
  39         struct sg_table *st;
  40         struct scatterlist *src, *dst;
  41         int ret, i;
  42
  43         ret = i915_mutex_lock_interruptible(obj->base.dev);
  44         if (ret)
  45                 return ERR_PTR(ret);
  46
  47         ret = i915_gem_object_get_pages(obj);
  48         if (ret) {
  49                 st = ERR_PTR(ret);
  50                 goto out;
  51         }
  52
  53         /* Copy sg so that we make an independent mapping */
  54         st = kmalloc(sizeof(struct sg_table), GFP_KERNEL);
  55         if (st == NULL) {
  56                 st = ERR_PTR(-ENOMEM);
  57                 goto out;
  58         }
  59
  60         ret = sg_alloc_table(st, obj->pages->nents, GFP_KERNEL);
  61         if (ret) {
  62                 kfree(st);
  63                 st = ERR_PTR(ret);
  64                 goto out;
  65         }
  66
  67         src = obj->pages->sgl;
  68         dst = st->sgl;
  69         for (i = 0; i < obj->pages->nents; i++) {
  70                 sg_set_page(dst, sg_page(src), src->length, 0);
  71                 dst = sg_next(dst);
  72                 src = sg_next(src);
  73         }
  74
  75         if (!dma_map_sg(attachment->dev, st->sgl, st->nents, dir)) {
  76                 sg_free_table(st);
  77                 kfree(st);
  78                 st = ERR_PTR(-ENOMEM);
  79                 goto out;
  80         }
  81
  82         i915_gem_object_pin_pages(obj);
  83
  84 out:
  85         mutex_unlock(&obj->base.dev->struct_mutex);
  86         return st;
  87 }
  88
  89 static void i915_gem_unmap_dma_buf(struct dma_buf_attachment *attachment,
  90                                    struct sg_table *sg,
  91                                    enum dma_data_direction dir)
  92 {
  93         struct drm_i915_gem_object *obj = dma_buf_to_obj(attachment->dmabuf);
  94
  95         mutex_lock(&obj->base.dev->struct_mutex);
  96
  97         dma_unmap_sg(attachment->dev, sg->sgl, sg->nents, dir);
  98         sg_free_table(sg);
  99         kfree(sg);
 100
 101         i915_gem_object_unpin_pages(obj);
 102
 103         mutex_unlock(&obj->base.dev->struct_mutex);
 104 }
 105
 106 static void *i915_gem_dmabuf_vmap(struct dma_buf *dma_buf)
 107 {
 108         struct drm_i915_gem_object *obj = dma_buf_to_obj(dma_buf);
 109         struct drm_device *dev = obj->base.dev;
 110         struct sg_page_iter sg_iter;
 111         struct page **pages;
 112         int ret, i;
 113
 114         ret = i915_mutex_lock_interruptible(dev);
 115         if (ret)
 116                 return ERR_PTR(ret);
 117
 118         if (obj->dma_buf_vmapping) {
 119                 obj->vmapping_count++;
 120                 goto out_unlock;
 121         }
 122
 123         ret = i915_gem_object_get_pages(obj);
 124         if (ret)
 125                 goto error;
 126
 127         ret = -ENOMEM;
 128
 129         pages = drm_malloc_ab(obj->base.size >> PAGE_SHIFT, sizeof(*pages));
 130         if (pages == NULL)
 131                 goto error;
 132
 133         i = 0;
 134         for_each_sg_page(obj->pages->sgl, &sg_iter, obj->pages->nents, 0)
 135                 pages[i++] = sg_page_iter_page(&sg_iter);
 136
 137         obj->dma_buf_vmapping = vmap(pages, i, 0, PAGE_KERNEL);
 138         drm_free_large(pages);
 139
 140         if (!obj->dma_buf_vmapping)
 141                 goto error;
 142
 143         obj->vmapping_count = 1;
 144         i915_gem_object_pin_pages(obj);
 145 out_unlock:
 146         mutex_unlock(&dev->struct_mutex);
 147         return obj->dma_buf_vmapping;
 148
 149 error:
 150         mutex_unlock(&dev->struct_mutex);
 151         return ERR_PTR(ret);
 152 }
 153
 154 static void i915_gem_dmabuf_vunmap(struct dma_buf *dma_buf, void *vaddr)
 155 {
 156         struct drm_i915_gem_object *obj = dma_buf_to_obj(dma_buf);
 157         struct drm_device *dev = obj->base.dev;
 158         int ret;
 159
 160         ret = i915_mutex_lock_interruptible(dev);
 161         if (ret)
 162                 return;
 163
 164         if (--obj->vmapping_count == 0) {
 165                 vunmap(obj->dma_buf_vmapping);
 166                 obj->dma_buf_vmapping = NULL;
 167
 168                 i915_gem_object_unpin_pages(obj);
 169         }
 170         mutex_unlock(&dev->struct_mutex);
 171 }
 172
 173 static void *i915_gem_dmabuf_kmap_atomic(struct dma_buf *dma_buf, unsigned long page_num)
 174 {
 175         return NULL;
 176 }
 177
 178 static void i915_gem_dmabuf_kunmap_atomic(struct dma_buf *dma_buf, unsigned long page_num, void *addr)
 179 {
 180
 181 }
 182 static void *i915_gem_dmabuf_kmap(struct dma_buf *dma_buf, unsigned long page_num)
 183 {
 184         return NULL;
 185 }
 186
 187 static void i915_gem_dmabuf_kunmap(struct dma_buf *dma_buf, unsigned long page_num, void *addr)
 188 {
 189
 190 }
 191
 192 static int i915_gem_dmabuf_mmap(struct dma_buf *dma_buf, struct vm_area_struct *vma)
 193 {
 194         return -EINVAL;
 195 }
 196
 197 static int i915_gem_begin_cpu_access(struct dma_buf *dma_buf, size_t start, size_t length, enum dma_data_direction direction)
 198 {
 199         struct drm_i915_gem_object *obj = dma_buf_to_obj(dma_buf);
 200         struct drm_device *dev = obj->base.dev;
 201         int ret;
 202         bool write = (direction == DMA_BIDIRECTIONAL || direction == DMA_TO_DEVICE);
 203
 204         ret = i915_mutex_lock_interruptible(dev);
 205         if (ret)
 206                 return ret;
 207
 208         ret = i915_gem_object_set_to_cpu_domain(obj, write);
 209         mutex_unlock(&dev->struct_mutex);
 210         return ret;
 211 }
 212
 213 static const struct dma_buf_ops i915_dmabuf_ops =  {
 214         .map_dma_buf = i915_gem_map_dma_buf,
 215         .unmap_dma_buf = i915_gem_unmap_dma_buf,
 216         .release = drm_gem_dmabuf_release,
 217         .kmap = i915_gem_dmabuf_kmap,
 218         .kmap_atomic = i915_gem_dmabuf_kmap_atomic,
 219         .kunmap = i915_gem_dmabuf_kunmap,
 220         .kunmap_atomic = i915_gem_dmabuf_kunmap_atomic,
 221         .mmap = i915_gem_dmabuf_mmap,
 222         .vmap = i915_gem_dmabuf_vmap,
 223         .vunmap = i915_gem_dmabuf_vunmap,
 224         .begin_cpu_access = i915_gem_begin_cpu_access,
 225 };
 226
 227 struct dma_buf *i915_gem_prime_export(struct drm_device *dev,
 228                                       struct drm_gem_object *gem_obj, int flags)
 229 {
 230         return dma_buf_export(gem_obj, &i915_dmabuf_ops, gem_obj->size, flags);
 231 }
 232
 233 static int i915_gem_object_get_pages_dmabuf(struct drm_i915_gem_object *obj)
 234 {
 235         struct sg_table *sg;
 236
 237         sg = dma_buf_map_attachment(obj->base.import_attach, DMA_BIDIRECTIONAL);
 238         if (IS_ERR(sg))
 239                 return PTR_ERR(sg);
 240
 241         obj->pages = sg;
 242         obj->has_dma_mapping = true;
 243         return 0;
 244 }
 245
 246 static void i915_gem_object_put_pages_dmabuf(struct drm_i915_gem_object *obj)
 247 {
 248         dma_buf_unmap_attachment(obj->base.import_attach,
 249                                  obj->pages, DMA_BIDIRECTIONAL);
 250         obj->has_dma_mapping = false;
 251 }
 252
 253 static const struct drm_i915_gem_object_ops i915_gem_object_dmabuf_ops = {
 254         .get_pages = i915_gem_object_get_pages_dmabuf,
 255         .put_pages = i915_gem_object_put_pages_dmabuf,
 256 };
 257
 258 struct drm_gem_object *i915_gem_prime_import(struct drm_device *dev,
 259                                              struct dma_buf *dma_buf)
 260 {
 261         struct dma_buf_attachment *attach;
 262         struct drm_i915_gem_object *obj;
 263         int ret;
 264
 265         /* is this one of own objects? */
 266         if (dma_buf->ops == &i915_dmabuf_ops) {
 267                 obj = dma_buf_to_obj(dma_buf);
 268                 /* is it from our device? */
 269                 if (obj->base.dev == dev) {
 270                         /*
 271                          * Importing dmabuf exported from out own gem increases
 272                          * refcount on gem itself instead of f_count of dmabuf.
 273                          */
 274                         drm_gem_object_reference(&obj->base);
 275                         return &obj->base;
 276                 }
 277         }
 278
 279         /* need to attach */
 280         attach = dma_buf_attach(dma_buf, dev->dev);
 281         if (IS_ERR(attach))
 282                 return ERR_CAST(attach);
 283
 284         get_dma_buf(dma_buf);
 285
 286         obj = i915_gem_object_alloc(dev);
 287         if (obj == NULL) {
 288                 ret = -ENOMEM;
 289                 goto fail_detach;
 290         }
 291
 292         drm_gem_private_object_init(dev, &obj->base, dma_buf->size);
 293         i915_gem_object_init(obj, &i915_gem_object_dmabuf_ops);
 294         obj->base.import_attach = attach;
 295
 296         return &obj->base;
 297
 298 fail_detach:
 299         dma_buf_detach(dma_buf, attach);
 300         dma_buf_put(dma_buf);
 301
 302         return ERR_PTR(ret);
 303 }