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         vma->vm_file = filp;
 212
 213         vm_size = vma->vm_end - vma->vm_start;
 214         /*
 215          * a buffer contains information to physically continuous memory
 216          * allocated by user request or at framebuffer creation.
 217          */
 218         buffer = exynos_gem_obj->buffer;
 219
 220         /* check if user-requested size is valid. */
 221         if (vm_size > buffer->size)
 222                 return -EINVAL;
 223
 224         /*
 225          * get page frame number to physical memory to be mapped
 226          * to user space.
 227          */
 228         pfn = ((unsigned long)exynos_gem_obj->buffer->dma_addr) >> PAGE_SHIFT;
 229
 230         DRM_DEBUG_KMS("pfn = 0x%lx\n", pfn);
 231
 232         if (remap_pfn_range(vma, vma->vm_start, pfn, vm_size,
 233                                 vma->vm_page_prot)) {
 234                 DRM_ERROR("failed to remap pfn range.\n");
 235                 return -EAGAIN;
 236         }
 237
 238         return 0;
 239 }
 240
 241 static const struct file_operations exynos_drm_gem_fops = {
 242         .mmap = exynos_drm_gem_mmap_buffer,
 243 };
 244
 245 int exynos_drm_gem_mmap_ioctl(struct drm_device *dev, void *data,
 246                               struct drm_file *file_priv)
 247 {
 248         struct drm_exynos_gem_mmap *args = data;
 249         struct drm_gem_object *obj;
 250         unsigned int addr;
 251
 252         DRM_DEBUG_KMS("%s\n", __FILE__);
 253
 254         if (!(dev->driver->driver_features & DRIVER_GEM)) {
 255                 DRM_ERROR("does not support GEM.\n");
 256                 return -ENODEV;
 257         }
 258
 259         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
 260         if (!obj) {
 261                 DRM_ERROR("failed to lookup gem object.\n");
 262                 return -EINVAL;
 263         }
 264
 265         obj->filp->f_op = &exynos_drm_gem_fops;
 266         obj->filp->private_data = obj;
 267
 268         down_write(&current->mm->mmap_sem);
 269         addr = do_mmap(obj->filp, 0, args->size,
 270                         PROT_READ | PROT_WRITE, MAP_SHARED, 0);
 271         up_write(&current->mm->mmap_sem);
 272
 273         drm_gem_object_unreference_unlocked(obj);
 274
 275         if (IS_ERR((void *)addr))
 276                 return PTR_ERR((void *)addr);
 277
 278         args->mapped = addr;
 279
 280         DRM_DEBUG_KMS("mapped = 0x%lx\n", (unsigned long)args->mapped);
 281
 282         return 0;
 283 }
 284
 285 int exynos_drm_gem_init_object(struct drm_gem_object *obj)
 286 {
 287         DRM_DEBUG_KMS("%s\n", __FILE__);
 288
 289         return 0;
 290 }
 291
 292 void exynos_drm_gem_free_object(struct drm_gem_object *obj)
 293 {
 294         DRM_DEBUG_KMS("%s\n", __FILE__);
 295
 296         exynos_drm_gem_destroy(to_exynos_gem_obj(obj));
 297 }
 298
 299 int exynos_drm_gem_dumb_create(struct drm_file *file_priv,
 300                                struct drm_device *dev,
 301                                struct drm_mode_create_dumb *args)
 302 {
 303         struct exynos_drm_gem_obj *exynos_gem_obj;
 304         int ret;
 305
 306         DRM_DEBUG_KMS("%s\n", __FILE__);
 307
 308         /*
 309          * alocate memory to be used for framebuffer.
 310          * - this callback would be called by user application
 311          *      with DRM_IOCTL_MODE_CREATE_DUMB command.
 312          */
 313
 314         args->pitch = args->width * args->bpp >> 3;
 315         args->size = args->pitch * args->height;
 316
 317         exynos_gem_obj = exynos_drm_gem_create(dev, args->size);
 318         if (IS_ERR(exynos_gem_obj))
 319                 return PTR_ERR(exynos_gem_obj);
 320
 321         ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
 322                         &args->handle);
 323         if (ret) {
 324                 exynos_drm_gem_destroy(exynos_gem_obj);
 325                 return ret;
 326         }
 327
 328         return 0;
 329 }
 330
 331 int exynos_drm_gem_dumb_map_offset(struct drm_file *file_priv,
 332                                    struct drm_device *dev, uint32_t handle,
 333                                    uint64_t *offset)
 334 {
 335         struct exynos_drm_gem_obj *exynos_gem_obj;
 336         struct drm_gem_object *obj;
 337         int ret = 0;
 338
 339         DRM_DEBUG_KMS("%s\n", __FILE__);
 340
 341         mutex_lock(&dev->struct_mutex);
 342
 343         /*
 344          * get offset of memory allocated for drm framebuffer.
 345          * - this callback would be called by user application
 346          *      with DRM_IOCTL_MODE_MAP_DUMB command.
 347          */
 348
 349         obj = drm_gem_object_lookup(dev, file_priv, handle);
 350         if (!obj) {
 351                 DRM_ERROR("failed to lookup gem object.\n");
 352                 ret = -EINVAL;
 353                 goto unlock;
 354         }
 355
 356         exynos_gem_obj = to_exynos_gem_obj(obj);
 357
 358         if (!exynos_gem_obj->base.map_list.map) {
 359                 ret = drm_gem_create_mmap_offset(&exynos_gem_obj->base);
 360                 if (ret)
 361                         goto out;
 362         }
 363
 364         *offset = (u64)exynos_gem_obj->base.map_list.hash.key << PAGE_SHIFT;
 365         DRM_DEBUG_KMS("offset = 0x%lx\n", (unsigned long)*offset);
 366
 367 out:
 368         drm_gem_object_unreference(obj);
 369 unlock:
 370         mutex_unlock(&dev->struct_mutex);
 371         return ret;
 372 }
 373
 374 int exynos_drm_gem_dumb_destroy(struct drm_file *file_priv,
 375                                 struct drm_device *dev,
 376                                 unsigned int handle)
 377 {
 378         int ret;
 379
 380         DRM_DEBUG_KMS("%s\n", __FILE__);
 381
 382         /*
 383          * obj->refcount and obj->handle_count are decreased and
 384          * if both them are 0 then exynos_drm_gem_free_object()
 385          * would be called by callback to release resources.
 386          */
 387         ret = drm_gem_handle_delete(file_priv, handle);
 388         if (ret < 0) {
 389                 DRM_ERROR("failed to delete drm_gem_handle.\n");
 390                 return ret;
 391         }
 392
 393         return 0;
 394 }
 395
 396 int exynos_drm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 397 {
 398         struct drm_gem_object *obj = vma->vm_private_data;
 399         struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
 400         struct drm_device *dev = obj->dev;
 401         unsigned long pfn;
 402         pgoff_t page_offset;
 403         int ret;
 404
 405         page_offset = ((unsigned long)vmf->virtual_address -
 406                         vma->vm_start) >> PAGE_SHIFT;
 407
 408         mutex_lock(&dev->struct_mutex);
 409
 410         pfn = (((unsigned long)exynos_gem_obj->buffer->dma_addr) >>
 411                         PAGE_SHIFT) + page_offset;
 412
 413         ret = vm_insert_mixed(vma, (unsigned long)vmf->virtual_address, pfn);
 414
 415         mutex_unlock(&dev->struct_mutex);
 416
 417         return convert_to_vm_err_msg(ret);
 418 }
 419
 420 int exynos_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
 421 {
 422         int ret;
 423
 424         DRM_DEBUG_KMS("%s\n", __FILE__);
 425
 426         /* set vm_area_struct. */
 427         ret = drm_gem_mmap(filp, vma);
 428         if (ret < 0) {
 429                 DRM_ERROR("failed to mmap.\n");
 430                 return ret;
 431         }
 432
 433         vma->vm_flags &= ~VM_PFNMAP;
 434         vma->vm_flags |= VM_MIXEDMAP;
 435
 436         return ret;
 437 }
 438
 439 MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
 440 MODULE_DESCRIPTION("Samsung SoC DRM GEM Module");
 441 MODULE_LICENSE("GPL");