drivers/gpu/drm/udl/udl_gem.c

   1 /*
   2  * Copyright (C) 2012 Red Hat
   3  *
   4  * This file is subject to the terms and conditions of the GNU General Public
   5  * License v2. See the file COPYING in the main directory of this archive for
   6  * more details.
   7  */
   8
   9 #include <drm/drmP.h>
  10 #include "udl_drv.h"
  11 #include <linux/shmem_fs.h>
  12 #include <linux/dma-buf.h>
  13
  14 struct udl_gem_object *udl_gem_alloc_object(struct drm_device *dev,
  15                                             size_t size)
  16 {
  17         struct udl_gem_object *obj;
  18
  19         obj = kzalloc(sizeof(*obj), GFP_KERNEL);
  20         if (obj == NULL)
  21                 return NULL;
  22
  23         if (drm_gem_object_init(dev, &obj->base, size) != 0) {
  24                 kfree(obj);
  25                 return NULL;
  26         }
  27
  28         obj->flags = UDL_BO_CACHEABLE;
  29         return obj;
  30 }
  31
  32 static int
  33 udl_gem_create(struct drm_file *file,
  34                struct drm_device *dev,
  35                uint64_t size,
  36                uint32_t *handle_p)
  37 {
  38         struct udl_gem_object *obj;
  39         int ret;
  40         u32 handle;
  41
  42         size = roundup(size, PAGE_SIZE);
  43
  44         obj = udl_gem_alloc_object(dev, size);
  45         if (obj == NULL)
  46                 return -ENOMEM;
  47
  48         ret = drm_gem_handle_create(file, &obj->base, &handle);
  49         if (ret) {
  50                 drm_gem_object_release(&obj->base);
  51                 kfree(obj);
  52                 return ret;
  53         }
  54
  55         drm_gem_object_unreference_unlocked(&obj->base);
  56         *handle_p = handle;
  57         return 0;
  58 }
  59
  60 static void update_vm_cache_attr(struct udl_gem_object *obj,
  61                                  struct vm_area_struct *vma)
  62 {
  63         DRM_DEBUG_KMS("flags = 0x%x\n", obj->flags);
  64
  65         /* non-cacheable as default. */
  66         if (obj->flags & UDL_BO_CACHEABLE) {
  67                 vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
  68         } else if (obj->flags & UDL_BO_WC) {
  69                 vma->vm_page_prot =
  70                         pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
  71         } else {
  72                 vma->vm_page_prot =
  73                         pgprot_noncached(vm_get_page_prot(vma->vm_flags));
  74         }
  75 }
  76
  77 int udl_dumb_create(struct drm_file *file,
  78                     struct drm_device *dev,
  79                     struct drm_mode_create_dumb *args)
  80 {
  81         args->pitch = args->width * DIV_ROUND_UP(args->bpp, 8);
  82         args->size = args->pitch * args->height;
  83         return udl_gem_create(file, dev,
  84                               args->size, &args->handle);
  85 }
  86
  87 int udl_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
  88 {
  89         int ret;
  90
  91         ret = drm_gem_mmap(filp, vma);
  92         if (ret)
  93                 return ret;
  94
  95         vma->vm_flags &= ~VM_PFNMAP;
  96         vma->vm_flags |= VM_MIXEDMAP;
  97
  98         update_vm_cache_attr(to_udl_bo(vma->vm_private_data), vma);
  99
 100         return ret;
 101 }
 102
 103 int udl_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 104 {
 105         struct udl_gem_object *obj = to_udl_bo(vma->vm_private_data);
 106         struct page *page;
 107         unsigned int page_offset;
 108         int ret = 0;
 109
 110         page_offset = (vmf->address - vma->vm_start) >> PAGE_SHIFT;
 111
 112         if (!obj->pages)
 113                 return VM_FAULT_SIGBUS;
 114
 115         page = obj->pages[page_offset];
 116         ret = vm_insert_page(vma, vmf->address, page);
 117         switch (ret) {
 118         case -EAGAIN:
 119         case 0:
 120         case -ERESTARTSYS:
 121                 return VM_FAULT_NOPAGE;
 122         case -ENOMEM:
 123                 return VM_FAULT_OOM;
 124         default:
 125                 return VM_FAULT_SIGBUS;
 126         }
 127 }
 128
 129 int udl_gem_get_pages(struct udl_gem_object *obj)
 130 {
 131         struct page **pages;
 132
 133         if (obj->pages)
 134                 return 0;
 135
 136         pages = drm_gem_get_pages(&obj->base);
 137         if (IS_ERR(pages))
 138                 return PTR_ERR(pages);
 139
 140         obj->pages = pages;
 141
 142         return 0;
 143 }
 144
 145 void udl_gem_put_pages(struct udl_gem_object *obj)
 146 {
 147         if (obj->base.import_attach) {
 148                 drm_free_large(obj->pages);
 149                 obj->pages = NULL;
 150                 return;
 151         }
 152
 153         drm_gem_put_pages(&obj->base, obj->pages, false, false);
 154         obj->pages = NULL;
 155 }
 156
 157 int udl_gem_vmap(struct udl_gem_object *obj)
 158 {
 159         int page_count = obj->base.size / PAGE_SIZE;
 160         int ret;
 161
 162         if (obj->base.import_attach) {
 163                 obj->vmapping = dma_buf_vmap(obj->base.import_attach->dmabuf);
 164                 if (!obj->vmapping)
 165                         return -ENOMEM;
 166                 return 0;
 167         }
 168
 169         ret = udl_gem_get_pages(obj);
 170         if (ret)
 171                 return ret;
 172
 173         obj->vmapping = vmap(obj->pages, page_count, 0, PAGE_KERNEL);
 174         if (!obj->vmapping)
 175                 return -ENOMEM;
 176         return 0;
 177 }
 178
 179 void udl_gem_vunmap(struct udl_gem_object *obj)
 180 {
 181         if (obj->base.import_attach) {
 182                 dma_buf_vunmap(obj->base.import_attach->dmabuf, obj->vmapping);
 183                 return;
 184         }
 185
 186         vunmap(obj->vmapping);
 187
 188         udl_gem_put_pages(obj);
 189 }
 190
 191 void udl_gem_free_object(struct drm_gem_object *gem_obj)
 192 {
 193         struct udl_gem_object *obj = to_udl_bo(gem_obj);
 194
 195         if (obj->vmapping)
 196                 udl_gem_vunmap(obj);
 197
 198         if (gem_obj->import_attach) {
 199                 drm_prime_gem_destroy(gem_obj, obj->sg);
 200                 put_device(gem_obj->dev->dev);
 201         }
 202
 203         if (obj->pages)
 204                 udl_gem_put_pages(obj);
 205
 206         drm_gem_free_mmap_offset(gem_obj);
 207 }
 208
 209 /* the dumb interface doesn't work with the GEM straight MMAP
 210    interface, it expects to do MMAP on the drm fd, like normal */
 211 int udl_gem_mmap(struct drm_file *file, struct drm_device *dev,
 212                  uint32_t handle, uint64_t *offset)
 213 {
 214         struct udl_gem_object *gobj;
 215         struct drm_gem_object *obj;
 216         int ret = 0;
 217
 218         mutex_lock(&dev->struct_mutex);
 219         obj = drm_gem_object_lookup(file, handle);
 220         if (obj == NULL) {
 221                 ret = -ENOENT;
 222                 goto unlock;
 223         }
 224         gobj = to_udl_bo(obj);
 225
 226         ret = udl_gem_get_pages(gobj);
 227         if (ret)
 228                 goto out;
 229         ret = drm_gem_create_mmap_offset(obj);
 230         if (ret)
 231                 goto out;
 232
 233         *offset = drm_vma_node_offset_addr(&gobj->base.vma_node);
 234
 235 out:
 236         drm_gem_object_unreference(&gobj->base);
 237 unlock:
 238         mutex_unlock(&dev->struct_mutex);
 239         return ret;
 240 }