drivers/gpu/drm/exynos/exynos_drm_gem.c

   1 /* exynos_drm_gem.c
   2  *
   3  * Copyright (c) 2011 Samsung Electronics Co., Ltd.
   4  * Author: Inki Dae <inki.dae@samsung.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the next
  14  * paragraph) shall be included in all copies or substantial portions of the
  15  * Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23  * OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 #include "drmP.h"
  27 #include "drm.h"
  28
  29 #include <drm/exynos_drm.h>
  30
  31 #include "exynos_drm_drv.h"
  32 #include "exynos_drm_gem.h"
  33 #include "exynos_drm_buf.h"
  34
  35 static unsigned int convert_to_vm_err_msg(int msg)
  36 {
  37         unsigned int out_msg;
  38
  39         switch (msg) {
  40         case 0:
  41         case -ERESTARTSYS:
  42         case -EINTR:
  43                 out_msg = VM_FAULT_NOPAGE;
  44                 break;
  45
  46         case -ENOMEM:
  47                 out_msg = VM_FAULT_OOM;
  48                 break;
  49
  50         default:
  51                 out_msg = VM_FAULT_SIGBUS;
  52                 break;
  53         }
  54
  55         return out_msg;
  56 }
  57
  58 static int exynos_drm_gem_handle_create(struct drm_gem_object *obj,
  59                                         struct drm_file *file_priv,
  60                                         unsigned int *handle)
  61 {
  62         int ret;
  63
  64         /*
  65          * allocate a id of idr table where the obj is registered
  66          * and handle has the id what user can see.
  67          */
  68         ret = drm_gem_handle_create(file_priv, obj, handle);
  69         if (ret)
  70                 return ret;
  71
  72         DRM_DEBUG_KMS("gem handle = 0x%x\n", *handle);
  73
  74         /* drop reference from allocate - handle holds it now. */
  75         drm_gem_object_unreference_unlocked(obj);
  76
  77         return 0;
  78 }
  79
  80 void exynos_drm_gem_destroy(struct exynos_drm_gem_obj *exynos_gem_obj)
  81 {
  82         struct drm_gem_object *obj;
  83
  84         DRM_DEBUG_KMS("%s\n", __FILE__);
  85
  86         if (!exynos_gem_obj)
  87                 return;
  88
  89         obj = &exynos_gem_obj->base;
  90
  91         DRM_DEBUG_KMS("handle count = %d\n", atomic_read(&obj->handle_count));
  92
  93         exynos_drm_buf_destroy(obj->dev, exynos_gem_obj->buffer);
  94
  95         if (obj->map_list.map)
  96                 drm_gem_free_mmap_offset(obj);
  97
  98         /* release file pointer to gem object. */
  99         drm_gem_object_release(obj);
 100
 101         kfree(exynos_gem_obj);
 102 }
 103
 104 static struct exynos_drm_gem_obj *exynos_drm_gem_init(struct drm_device *dev,
 105                                                       unsigned long size)
 106 {
 107         struct exynos_drm_gem_obj *exynos_gem_obj;
 108         struct drm_gem_object *obj;
 109         int ret;
 110
 111         exynos_gem_obj = kzalloc(sizeof(*exynos_gem_obj), GFP_KERNEL);
 112         if (!exynos_gem_obj) {
 113                 DRM_ERROR("failed to allocate exynos gem object\n");
 114                 return NULL;
 115         }
 116
 117         obj = &exynos_gem_obj->base;
 118
 119         ret = drm_gem_object_init(dev, obj, size);
 120         if (ret < 0) {
 121                 DRM_ERROR("failed to initialize gem object\n");
 122                 kfree(exynos_gem_obj);
 123                 return NULL;
 124         }
 125
 126         DRM_DEBUG_KMS("created file object = 0x%x\n", (unsigned int)obj->filp);
 127
 128         return exynos_gem_obj;
 129 }
 130
 131 struct exynos_drm_gem_obj *exynos_drm_gem_create(struct drm_device *dev,
 132                                                  unsigned long size)
 133 {
 134         struct exynos_drm_gem_buf *buffer;
 135         struct exynos_drm_gem_obj *exynos_gem_obj;
 136
 137         size = roundup(size, PAGE_SIZE);
 138         DRM_DEBUG_KMS("%s: size = 0x%lx\n", __FILE__, size);
 139
 140         buffer = exynos_drm_buf_create(dev, size);
 141         if (!buffer)
 142                 return ERR_PTR(-ENOMEM);
 143
 144         exynos_gem_obj = exynos_drm_gem_init(dev, size);
 145         if (!exynos_gem_obj) {
 146                 exynos_drm_buf_destroy(dev, buffer);
 147                 return ERR_PTR(-ENOMEM);
 148         }
 149
 150         exynos_gem_obj->buffer = buffer;
 151
 152         return exynos_gem_obj;
 153 }
 154
 155 int exynos_drm_gem_create_ioctl(struct drm_device *dev, void *data,
 156                                 struct drm_file *file_priv)
 157 {
 158         struct drm_exynos_gem_create *args = data;
 159         struct exynos_drm_gem_obj *exynos_gem_obj;
 160         int ret;
 161
 162         DRM_DEBUG_KMS("%s\n", __FILE__);
 163
 164         exynos_gem_obj = exynos_drm_gem_create(dev, args->size);
 165         if (IS_ERR(exynos_gem_obj))
 166                 return PTR_ERR(exynos_gem_obj);
 167
 168         ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
 169                         &args->handle);
 170         if (ret) {
 171                 exynos_drm_gem_destroy(exynos_gem_obj);
 172                 return ret;
 173         }
 174
 175         return 0;
 176 }
 177
 178 int exynos_drm_gem_map_offset_ioctl(struct drm_device *dev, void *data,
 179                                     struct drm_file *file_priv)
 180 {
 181         struct drm_exynos_gem_map_off *args = data;
 182
 183         DRM_DEBUG_KMS("%s\n", __FILE__);
 184
 185         DRM_DEBUG_KMS("handle = 0x%x, offset = 0x%lx\n",
 186                         args->handle, (unsigned long)args->offset);
 187
 188         if (!(dev->driver->driver_features & DRIVER_GEM)) {
 189                 DRM_ERROR("does not support GEM.\n");
 190                 return -ENODEV;
 191         }
 192
 193         return exynos_drm_gem_dumb_map_offset(file_priv, dev, args->handle,
 194                         &args->offset);
 195 }
 196
 197 static int exynos_drm_gem_mmap_buffer(struct file *filp,
 198                                       struct vm_area_struct *vma)
 199 {
 200         struct drm_gem_object *obj = filp->private_data;
 201         struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
 202         struct exynos_drm_gem_buf *buffer;
 203         unsigned long pfn, vm_size;
 204
 205         DRM_DEBUG_KMS("%s\n", __FILE__);
 206
 207         vma->vm_flags |= (VM_IO | VM_RESERVED);
 208
 209         /* in case of direct mapping, always having non-cachable attribute */
 210         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 211
 212         vm_size = vma->vm_end - vma->vm_start;
 213         /*
 214          * a buffer contains information to physically continuous memory
 215          * allocated by user request or at framebuffer creation.
 216          */
 217         buffer = exynos_gem_obj->buffer;
 218
 219         /* check if user-requested size is valid. */
 220         if (vm_size > buffer->size)
 221                 return -EINVAL;
 222
 223         /*
 224          * get page frame number to physical memory to be mapped
 225          * to user space.
 226          */
 227         pfn = ((unsigned long)exynos_gem_obj->buffer->dma_addr) >> PAGE_SHIFT;
 228
 229         DRM_DEBUG_KMS("pfn = 0x%lx\n", pfn);
 230
 231         if (remap_pfn_range(vma, vma->vm_start, pfn, vm_size,
 232                                 vma->vm_page_prot)) {
 233                 DRM_ERROR("failed to remap pfn range.\n");
 234                 return -EAGAIN;
 235         }
 236
 237         return 0;
 238 }
 239
 240 static const struct file_operations exynos_drm_gem_fops = {
 241         .mmap = exynos_drm_gem_mmap_buffer,
 242 };
 243
 244 int exynos_drm_gem_mmap_ioctl(struct drm_device *dev, void *data,
 245                               struct drm_file *file_priv)
 246 {
 247         struct drm_exynos_gem_mmap *args = data;
 248         struct drm_gem_object *obj;
 249         unsigned int addr;
 250
 251         DRM_DEBUG_KMS("%s\n", __FILE__);
 252
 253         if (!(dev->driver->driver_features & DRIVER_GEM)) {
 254                 DRM_ERROR("does not support GEM.\n");
 255                 return -ENODEV;
 256         }
 257
 258         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
 259         if (!obj) {
 260                 DRM_ERROR("failed to lookup gem object.\n");
 261                 return -EINVAL;
 262         }
 263
 264         obj->filp->f_op = &exynos_drm_gem_fops;
 265         obj->filp->private_data = obj;
 266
 267         down_write(&current->mm->mmap_sem);
 268         addr = do_mmap(obj->filp, 0, args->size,
 269                         PROT_READ | PROT_WRITE, MAP_SHARED, 0);
 270         up_write(&current->mm->mmap_sem);
 271
 272         drm_gem_object_unreference_unlocked(obj);
 273
 274         if (IS_ERR((void *)addr))
 275                 return PTR_ERR((void *)addr);
 276
 277         args->mapped = addr;
 278
 279         DRM_DEBUG_KMS("mapped = 0x%lx\n", (unsigned long)args->mapped);
 280
 281         return 0;
 282 }
 283
 284 int exynos_drm_gem_init_object(struct drm_gem_object *obj)
 285 {
 286         DRM_DEBUG_KMS("%s\n", __FILE__);
 287
 288         return 0;
 289 }
 290
 291 void exynos_drm_gem_free_object(struct drm_gem_object *obj)
 292 {
 293         DRM_DEBUG_KMS("%s\n", __FILE__);
 294
 295         exynos_drm_gem_destroy(to_exynos_gem_obj(obj));
 296 }
 297
 298 int exynos_drm_gem_dumb_create(struct drm_file *file_priv,
 299                                struct drm_device *dev,
 300                                struct drm_mode_create_dumb *args)
 301 {
 302         struct exynos_drm_gem_obj *exynos_gem_obj;
 303         int ret;
 304
 305         DRM_DEBUG_KMS("%s\n", __FILE__);
 306
 307         /*
 308          * alocate memory to be used for framebuffer.
 309          * - this callback would be called by user application
 310          *      with DRM_IOCTL_MODE_CREATE_DUMB command.
 311          */
 312
 313         args->pitch = args->width * args->bpp >> 3;
 314         args->size = args->pitch * args->height;
 315
 316         exynos_gem_obj = exynos_drm_gem_create(dev, args->size);
 317         if (IS_ERR(exynos_gem_obj))
 318                 return PTR_ERR(exynos_gem_obj);
 319
 320         ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
 321                         &args->handle);
 322         if (ret) {
 323                 exynos_drm_gem_destroy(exynos_gem_obj);
 324                 return ret;
 325         }
 326
 327         return 0;
 328 }
 329
 330 int exynos_drm_gem_dumb_map_offset(struct drm_file *file_priv,
 331                                    struct drm_device *dev, uint32_t handle,
 332                                    uint64_t *offset)
 333 {
 334         struct exynos_drm_gem_obj *exynos_gem_obj;
 335         struct drm_gem_object *obj;
 336         int ret = 0;
 337
 338         DRM_DEBUG_KMS("%s\n", __FILE__);
 339
 340         mutex_lock(&dev->struct_mutex);
 341
 342         /*
 343          * get offset of memory allocated for drm framebuffer.
 344          * - this callback would be called by user application
 345          *      with DRM_IOCTL_MODE_MAP_DUMB command.
 346          */
 347
 348         obj = drm_gem_object_lookup(dev, file_priv, handle);
 349         if (!obj) {
 350                 DRM_ERROR("failed to lookup gem object.\n");
 351                 ret = -EINVAL;
 352                 goto unlock;
 353         }
 354
 355         exynos_gem_obj = to_exynos_gem_obj(obj);
 356
 357         if (!exynos_gem_obj->base.map_list.map) {
 358                 ret = drm_gem_create_mmap_offset(&exynos_gem_obj->base);
 359                 if (ret)
 360                         goto out;
 361         }
 362
 363         *offset = (u64)exynos_gem_obj->base.map_list.hash.key << PAGE_SHIFT;
 364         DRM_DEBUG_KMS("offset = 0x%lx\n", (unsigned long)*offset);
 365
 366 out:
 367         drm_gem_object_unreference(obj);
 368 unlock:
 369         mutex_unlock(&dev->struct_mutex);
 370         return ret;
 371 }
 372
 373 int exynos_drm_gem_dumb_destroy(struct drm_file *file_priv,
 374                                 struct drm_device *dev,
 375                                 unsigned int handle)
 376 {
 377         int ret;
 378
 379         DRM_DEBUG_KMS("%s\n", __FILE__);
 380
 381         /*
 382          * obj->refcount and obj->handle_count are decreased and
 383          * if both them are 0 then exynos_drm_gem_free_object()
 384          * would be called by callback to release resources.
 385          */
 386         ret = drm_gem_handle_delete(file_priv, handle);
 387         if (ret < 0) {
 388                 DRM_ERROR("failed to delete drm_gem_handle.\n");
 389                 return ret;
 390         }
 391
 392         return 0;
 393 }
 394
 395 int exynos_drm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 396 {
 397         struct drm_gem_object *obj = vma->vm_private_data;
 398         struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
 399         struct drm_device *dev = obj->dev;
 400         unsigned long pfn;
 401         pgoff_t page_offset;
 402         int ret;
 403
 404         page_offset = ((unsigned long)vmf->virtual_address -
 405                         vma->vm_start) >> PAGE_SHIFT;
 406
 407         mutex_lock(&dev->struct_mutex);
 408
 409         pfn = (((unsigned long)exynos_gem_obj->buffer->dma_addr) >>
 410                         PAGE_SHIFT) + page_offset;
 411
 412         ret = vm_insert_mixed(vma, (unsigned long)vmf->virtual_address, pfn);
 413
 414         mutex_unlock(&dev->struct_mutex);
 415
 416         return convert_to_vm_err_msg(ret);
 417 }
 418
 419 int exynos_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
 420 {
 421         int ret;
 422
 423         DRM_DEBUG_KMS("%s\n", __FILE__);
 424
 425         /* set vm_area_struct. */
 426         ret = drm_gem_mmap(filp, vma);
 427         if (ret < 0) {
 428                 DRM_ERROR("failed to mmap.\n");
 429                 return ret;
 430         }
 431
 432         vma->vm_flags &= ~VM_PFNMAP;
 433         vma->vm_flags |= VM_MIXEDMAP;
 434
 435         return ret;
 436 }
 437
 438 MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
 439 MODULE_DESCRIPTION("Samsung SoC DRM GEM Module");
 440 MODULE_LICENSE("GPL");