3 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
4 * Author: Inki Dae <inki.dae@samsung.com>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2 of the License, or (at your
9 * option) any later version.
14 #include <linux/shmem_fs.h>
15 #include <drm/exynos_drm.h>
17 #include "exynos_drm_drv.h"
18 #include "exynos_drm_gem.h"
19 #include "exynos_drm_buf.h"
21 static unsigned int convert_to_vm_err_msg(int msg
)
29 out_msg
= VM_FAULT_NOPAGE
;
33 out_msg
= VM_FAULT_OOM
;
37 out_msg
= VM_FAULT_SIGBUS
;
44 static int check_gem_flags(unsigned int flags
)
46 if (flags
& ~(EXYNOS_BO_MASK
)) {
47 DRM_ERROR("invalid flags.\n");
54 static void update_vm_cache_attr(struct exynos_drm_gem_obj
*obj
,
55 struct vm_area_struct
*vma
)
57 DRM_DEBUG_KMS("flags = 0x%x\n", obj
->flags
);
59 /* non-cachable as default. */
60 if (obj
->flags
& EXYNOS_BO_CACHABLE
)
61 vma
->vm_page_prot
= vm_get_page_prot(vma
->vm_flags
);
62 else if (obj
->flags
& EXYNOS_BO_WC
)
64 pgprot_writecombine(vm_get_page_prot(vma
->vm_flags
));
67 pgprot_noncached(vm_get_page_prot(vma
->vm_flags
));
70 static unsigned long roundup_gem_size(unsigned long size
, unsigned int flags
)
74 return roundup(size
, PAGE_SIZE
);
77 static int exynos_drm_gem_map_buf(struct drm_gem_object
*obj
,
78 struct vm_area_struct
*vma
,
79 unsigned long f_vaddr
,
82 struct exynos_drm_gem_obj
*exynos_gem_obj
= to_exynos_gem_obj(obj
);
83 struct exynos_drm_gem_buf
*buf
= exynos_gem_obj
->buffer
;
84 struct scatterlist
*sgl
;
91 if (page_offset
>= (buf
->size
>> PAGE_SHIFT
)) {
92 DRM_ERROR("invalid page offset\n");
97 for_each_sg(buf
->sgt
->sgl
, sgl
, buf
->sgt
->nents
, i
) {
98 if (page_offset
< (sgl
->length
>> PAGE_SHIFT
))
100 page_offset
-= (sgl
->length
>> PAGE_SHIFT
);
103 pfn
= __phys_to_pfn(sg_phys(sgl
)) + page_offset
;
105 return vm_insert_mixed(vma
, f_vaddr
, pfn
);
108 static int exynos_drm_gem_handle_create(struct drm_gem_object
*obj
,
109 struct drm_file
*file_priv
,
110 unsigned int *handle
)
115 * allocate a id of idr table where the obj is registered
116 * and handle has the id what user can see.
118 ret
= drm_gem_handle_create(file_priv
, obj
, handle
);
122 DRM_DEBUG_KMS("gem handle = 0x%x\n", *handle
);
124 /* drop reference from allocate - handle holds it now. */
125 drm_gem_object_unreference_unlocked(obj
);
130 void exynos_drm_gem_destroy(struct exynos_drm_gem_obj
*exynos_gem_obj
)
132 struct drm_gem_object
*obj
;
133 struct exynos_drm_gem_buf
*buf
;
135 DRM_DEBUG_KMS("%s\n", __FILE__
);
137 obj
= &exynos_gem_obj
->base
;
138 buf
= exynos_gem_obj
->buffer
;
140 DRM_DEBUG_KMS("handle count = %d\n", atomic_read(&obj
->handle_count
));
143 * do not release memory region from exporter.
145 * the region will be released by exporter
146 * once dmabuf's refcount becomes 0.
148 if (obj
->import_attach
)
151 exynos_drm_free_buf(obj
->dev
, exynos_gem_obj
->flags
, buf
);
154 exynos_drm_fini_buf(obj
->dev
, buf
);
155 exynos_gem_obj
->buffer
= NULL
;
157 if (obj
->map_list
.map
)
158 drm_gem_free_mmap_offset(obj
);
160 /* release file pointer to gem object. */
161 drm_gem_object_release(obj
);
163 kfree(exynos_gem_obj
);
164 exynos_gem_obj
= NULL
;
167 unsigned long exynos_drm_gem_get_size(struct drm_device
*dev
,
168 unsigned int gem_handle
,
169 struct drm_file
*file_priv
)
171 struct exynos_drm_gem_obj
*exynos_gem_obj
;
172 struct drm_gem_object
*obj
;
174 obj
= drm_gem_object_lookup(dev
, file_priv
, gem_handle
);
176 DRM_ERROR("failed to lookup gem object.\n");
180 exynos_gem_obj
= to_exynos_gem_obj(obj
);
182 drm_gem_object_unreference_unlocked(obj
);
184 return exynos_gem_obj
->buffer
->size
;
188 struct exynos_drm_gem_obj
*exynos_drm_gem_init(struct drm_device
*dev
,
191 struct exynos_drm_gem_obj
*exynos_gem_obj
;
192 struct drm_gem_object
*obj
;
195 exynos_gem_obj
= kzalloc(sizeof(*exynos_gem_obj
), GFP_KERNEL
);
196 if (!exynos_gem_obj
) {
197 DRM_ERROR("failed to allocate exynos gem object\n");
201 exynos_gem_obj
->size
= size
;
202 obj
= &exynos_gem_obj
->base
;
204 ret
= drm_gem_object_init(dev
, obj
, size
);
206 DRM_ERROR("failed to initialize gem object\n");
207 kfree(exynos_gem_obj
);
211 DRM_DEBUG_KMS("created file object = 0x%x\n", (unsigned int)obj
->filp
);
213 return exynos_gem_obj
;
216 struct exynos_drm_gem_obj
*exynos_drm_gem_create(struct drm_device
*dev
,
220 struct exynos_drm_gem_obj
*exynos_gem_obj
;
221 struct exynos_drm_gem_buf
*buf
;
225 DRM_ERROR("invalid size.\n");
226 return ERR_PTR(-EINVAL
);
229 size
= roundup_gem_size(size
, flags
);
230 DRM_DEBUG_KMS("%s\n", __FILE__
);
232 ret
= check_gem_flags(flags
);
236 buf
= exynos_drm_init_buf(dev
, size
);
238 return ERR_PTR(-ENOMEM
);
240 exynos_gem_obj
= exynos_drm_gem_init(dev
, size
);
241 if (!exynos_gem_obj
) {
246 exynos_gem_obj
->buffer
= buf
;
248 /* set memory type and cache attribute from user side. */
249 exynos_gem_obj
->flags
= flags
;
251 ret
= exynos_drm_alloc_buf(dev
, buf
, flags
);
253 drm_gem_object_release(&exynos_gem_obj
->base
);
257 return exynos_gem_obj
;
260 exynos_drm_fini_buf(dev
, buf
);
264 int exynos_drm_gem_create_ioctl(struct drm_device
*dev
, void *data
,
265 struct drm_file
*file_priv
)
267 struct drm_exynos_gem_create
*args
= data
;
268 struct exynos_drm_gem_obj
*exynos_gem_obj
;
271 DRM_DEBUG_KMS("%s\n", __FILE__
);
273 exynos_gem_obj
= exynos_drm_gem_create(dev
, args
->flags
, args
->size
);
274 if (IS_ERR(exynos_gem_obj
))
275 return PTR_ERR(exynos_gem_obj
);
277 ret
= exynos_drm_gem_handle_create(&exynos_gem_obj
->base
, file_priv
,
280 exynos_drm_gem_destroy(exynos_gem_obj
);
287 dma_addr_t
*exynos_drm_gem_get_dma_addr(struct drm_device
*dev
,
288 unsigned int gem_handle
,
289 struct drm_file
*filp
)
291 struct exynos_drm_gem_obj
*exynos_gem_obj
;
292 struct drm_gem_object
*obj
;
294 obj
= drm_gem_object_lookup(dev
, filp
, gem_handle
);
296 DRM_ERROR("failed to lookup gem object.\n");
297 return ERR_PTR(-EINVAL
);
300 exynos_gem_obj
= to_exynos_gem_obj(obj
);
302 return &exynos_gem_obj
->buffer
->dma_addr
;
305 void exynos_drm_gem_put_dma_addr(struct drm_device
*dev
,
306 unsigned int gem_handle
,
307 struct drm_file
*filp
)
309 struct exynos_drm_gem_obj
*exynos_gem_obj
;
310 struct drm_gem_object
*obj
;
312 obj
= drm_gem_object_lookup(dev
, filp
, gem_handle
);
314 DRM_ERROR("failed to lookup gem object.\n");
318 exynos_gem_obj
= to_exynos_gem_obj(obj
);
320 drm_gem_object_unreference_unlocked(obj
);
323 * decrease obj->refcount one more time because we has already
324 * increased it at exynos_drm_gem_get_dma_addr().
326 drm_gem_object_unreference_unlocked(obj
);
329 int exynos_drm_gem_map_offset_ioctl(struct drm_device
*dev
, void *data
,
330 struct drm_file
*file_priv
)
332 struct drm_exynos_gem_map_off
*args
= data
;
334 DRM_DEBUG_KMS("%s\n", __FILE__
);
336 DRM_DEBUG_KMS("handle = 0x%x, offset = 0x%lx\n",
337 args
->handle
, (unsigned long)args
->offset
);
339 if (!(dev
->driver
->driver_features
& DRIVER_GEM
)) {
340 DRM_ERROR("does not support GEM.\n");
344 return exynos_drm_gem_dumb_map_offset(file_priv
, dev
, args
->handle
,
348 static struct drm_file
*exynos_drm_find_drm_file(struct drm_device
*drm_dev
,
351 struct drm_file
*file_priv
;
353 /* find current process's drm_file from filelist. */
354 list_for_each_entry(file_priv
, &drm_dev
->filelist
, lhead
)
355 if (file_priv
->filp
== filp
)
360 return ERR_PTR(-EFAULT
);
363 static int exynos_drm_gem_mmap_buffer(struct file
*filp
,
364 struct vm_area_struct
*vma
)
366 struct drm_gem_object
*obj
= filp
->private_data
;
367 struct exynos_drm_gem_obj
*exynos_gem_obj
= to_exynos_gem_obj(obj
);
368 struct drm_device
*drm_dev
= obj
->dev
;
369 struct exynos_drm_gem_buf
*buffer
;
370 struct drm_file
*file_priv
;
371 unsigned long vm_size
;
374 DRM_DEBUG_KMS("%s\n", __FILE__
);
376 vma
->vm_flags
|= VM_IO
| VM_DONTEXPAND
| VM_DONTDUMP
;
377 vma
->vm_private_data
= obj
;
378 vma
->vm_ops
= drm_dev
->driver
->gem_vm_ops
;
380 /* restore it to driver's fops. */
381 filp
->f_op
= fops_get(drm_dev
->driver
->fops
);
383 file_priv
= exynos_drm_find_drm_file(drm_dev
, filp
);
384 if (IS_ERR(file_priv
))
385 return PTR_ERR(file_priv
);
387 /* restore it to drm_file. */
388 filp
->private_data
= file_priv
;
390 update_vm_cache_attr(exynos_gem_obj
, vma
);
392 vm_size
= vma
->vm_end
- vma
->vm_start
;
395 * a buffer contains information to physically continuous memory
396 * allocated by user request or at framebuffer creation.
398 buffer
= exynos_gem_obj
->buffer
;
400 /* check if user-requested size is valid. */
401 if (vm_size
> buffer
->size
)
404 ret
= dma_mmap_attrs(drm_dev
->dev
, vma
, buffer
->pages
,
405 buffer
->dma_addr
, buffer
->size
,
408 DRM_ERROR("failed to mmap.\n");
413 * take a reference to this mapping of the object. And this reference
414 * is unreferenced by the corresponding vm_close call.
416 drm_gem_object_reference(obj
);
418 drm_vm_open_locked(drm_dev
, vma
);
423 static const struct file_operations exynos_drm_gem_fops
= {
424 .mmap
= exynos_drm_gem_mmap_buffer
,
427 int exynos_drm_gem_mmap_ioctl(struct drm_device
*dev
, void *data
,
428 struct drm_file
*file_priv
)
430 struct drm_exynos_gem_mmap
*args
= data
;
431 struct drm_gem_object
*obj
;
434 DRM_DEBUG_KMS("%s\n", __FILE__
);
436 if (!(dev
->driver
->driver_features
& DRIVER_GEM
)) {
437 DRM_ERROR("does not support GEM.\n");
441 obj
= drm_gem_object_lookup(dev
, file_priv
, args
->handle
);
443 DRM_ERROR("failed to lookup gem object.\n");
448 * We have to use gem object and its fops for specific mmaper,
449 * but vm_mmap() can deliver only filp. So we have to change
450 * filp->f_op and filp->private_data temporarily, then restore
451 * again. So it is important to keep lock until restoration the
452 * settings to prevent others from misuse of filp->f_op or
453 * filp->private_data.
455 mutex_lock(&dev
->struct_mutex
);
458 * Set specific mmper's fops. And it will be restored by
459 * exynos_drm_gem_mmap_buffer to dev->driver->fops.
460 * This is used to call specific mapper temporarily.
462 file_priv
->filp
->f_op
= &exynos_drm_gem_fops
;
465 * Set gem object to private_data so that specific mmaper
466 * can get the gem object. And it will be restored by
467 * exynos_drm_gem_mmap_buffer to drm_file.
469 file_priv
->filp
->private_data
= obj
;
471 addr
= vm_mmap(file_priv
->filp
, 0, args
->size
,
472 PROT_READ
| PROT_WRITE
, MAP_SHARED
, 0);
474 drm_gem_object_unreference(obj
);
476 if (IS_ERR((void *)addr
)) {
477 /* check filp->f_op, filp->private_data are restored */
478 if (file_priv
->filp
->f_op
== &exynos_drm_gem_fops
) {
479 file_priv
->filp
->f_op
= fops_get(dev
->driver
->fops
);
480 file_priv
->filp
->private_data
= file_priv
;
482 mutex_unlock(&dev
->struct_mutex
);
483 return PTR_ERR((void *)addr
);
486 mutex_unlock(&dev
->struct_mutex
);
490 DRM_DEBUG_KMS("mapped = 0x%lx\n", (unsigned long)args
->mapped
);
495 int exynos_drm_gem_get_ioctl(struct drm_device
*dev
, void *data
,
496 struct drm_file
*file_priv
)
497 { struct exynos_drm_gem_obj
*exynos_gem_obj
;
498 struct drm_exynos_gem_info
*args
= data
;
499 struct drm_gem_object
*obj
;
501 mutex_lock(&dev
->struct_mutex
);
503 obj
= drm_gem_object_lookup(dev
, file_priv
, args
->handle
);
505 DRM_ERROR("failed to lookup gem object.\n");
506 mutex_unlock(&dev
->struct_mutex
);
510 exynos_gem_obj
= to_exynos_gem_obj(obj
);
512 args
->flags
= exynos_gem_obj
->flags
;
513 args
->size
= exynos_gem_obj
->size
;
515 drm_gem_object_unreference(obj
);
516 mutex_unlock(&dev
->struct_mutex
);
521 struct vm_area_struct
*exynos_gem_get_vma(struct vm_area_struct
*vma
)
523 struct vm_area_struct
*vma_copy
;
525 vma_copy
= kmalloc(sizeof(*vma_copy
), GFP_KERNEL
);
529 if (vma
->vm_ops
&& vma
->vm_ops
->open
)
530 vma
->vm_ops
->open(vma
);
533 get_file(vma
->vm_file
);
535 memcpy(vma_copy
, vma
, sizeof(*vma
));
537 vma_copy
->vm_mm
= NULL
;
538 vma_copy
->vm_next
= NULL
;
539 vma_copy
->vm_prev
= NULL
;
544 void exynos_gem_put_vma(struct vm_area_struct
*vma
)
549 if (vma
->vm_ops
&& vma
->vm_ops
->close
)
550 vma
->vm_ops
->close(vma
);
558 int exynos_gem_get_pages_from_userptr(unsigned long start
,
561 struct vm_area_struct
*vma
)
565 /* the memory region mmaped with VM_PFNMAP. */
566 if (vma_is_io(vma
)) {
569 for (i
= 0; i
< npages
; ++i
, start
+= PAGE_SIZE
) {
571 int ret
= follow_pfn(vma
, start
, &pfn
);
575 pages
[i
] = pfn_to_page(pfn
);
579 DRM_ERROR("failed to get user_pages.\n");
586 get_npages
= get_user_pages(current
, current
->mm
, start
,
587 npages
, 1, 1, pages
, NULL
);
588 get_npages
= max(get_npages
, 0);
589 if (get_npages
!= npages
) {
590 DRM_ERROR("failed to get user_pages.\n");
592 put_page(pages
[--get_npages
]);
599 void exynos_gem_put_pages_to_userptr(struct page
**pages
,
601 struct vm_area_struct
*vma
)
603 if (!vma_is_io(vma
)) {
606 for (i
= 0; i
< npages
; i
++) {
607 set_page_dirty_lock(pages
[i
]);
610 * undo the reference we took when populating
618 int exynos_gem_map_sgt_with_dma(struct drm_device
*drm_dev
,
619 struct sg_table
*sgt
,
620 enum dma_data_direction dir
)
624 mutex_lock(&drm_dev
->struct_mutex
);
626 nents
= dma_map_sg(drm_dev
->dev
, sgt
->sgl
, sgt
->nents
, dir
);
628 DRM_ERROR("failed to map sgl with dma.\n");
629 mutex_unlock(&drm_dev
->struct_mutex
);
633 mutex_unlock(&drm_dev
->struct_mutex
);
637 void exynos_gem_unmap_sgt_from_dma(struct drm_device
*drm_dev
,
638 struct sg_table
*sgt
,
639 enum dma_data_direction dir
)
641 dma_unmap_sg(drm_dev
->dev
, sgt
->sgl
, sgt
->nents
, dir
);
644 int exynos_drm_gem_init_object(struct drm_gem_object
*obj
)
646 DRM_DEBUG_KMS("%s\n", __FILE__
);
651 void exynos_drm_gem_free_object(struct drm_gem_object
*obj
)
653 struct exynos_drm_gem_obj
*exynos_gem_obj
;
654 struct exynos_drm_gem_buf
*buf
;
656 DRM_DEBUG_KMS("%s\n", __FILE__
);
658 exynos_gem_obj
= to_exynos_gem_obj(obj
);
659 buf
= exynos_gem_obj
->buffer
;
661 if (obj
->import_attach
)
662 drm_prime_gem_destroy(obj
, buf
->sgt
);
664 exynos_drm_gem_destroy(to_exynos_gem_obj(obj
));
667 int exynos_drm_gem_dumb_create(struct drm_file
*file_priv
,
668 struct drm_device
*dev
,
669 struct drm_mode_create_dumb
*args
)
671 struct exynos_drm_gem_obj
*exynos_gem_obj
;
674 DRM_DEBUG_KMS("%s\n", __FILE__
);
677 * alocate memory to be used for framebuffer.
678 * - this callback would be called by user application
679 * with DRM_IOCTL_MODE_CREATE_DUMB command.
682 args
->pitch
= args
->width
* ((args
->bpp
+ 7) / 8);
683 args
->size
= args
->pitch
* args
->height
;
685 exynos_gem_obj
= exynos_drm_gem_create(dev
, EXYNOS_BO_CONTIG
|
686 EXYNOS_BO_WC
, args
->size
);
687 if (IS_ERR(exynos_gem_obj
))
688 return PTR_ERR(exynos_gem_obj
);
690 ret
= exynos_drm_gem_handle_create(&exynos_gem_obj
->base
, file_priv
,
693 exynos_drm_gem_destroy(exynos_gem_obj
);
700 int exynos_drm_gem_dumb_map_offset(struct drm_file
*file_priv
,
701 struct drm_device
*dev
, uint32_t handle
,
704 struct drm_gem_object
*obj
;
707 DRM_DEBUG_KMS("%s\n", __FILE__
);
709 mutex_lock(&dev
->struct_mutex
);
712 * get offset of memory allocated for drm framebuffer.
713 * - this callback would be called by user application
714 * with DRM_IOCTL_MODE_MAP_DUMB command.
717 obj
= drm_gem_object_lookup(dev
, file_priv
, handle
);
719 DRM_ERROR("failed to lookup gem object.\n");
724 if (!obj
->map_list
.map
) {
725 ret
= drm_gem_create_mmap_offset(obj
);
730 *offset
= (u64
)obj
->map_list
.hash
.key
<< PAGE_SHIFT
;
731 DRM_DEBUG_KMS("offset = 0x%lx\n", (unsigned long)*offset
);
734 drm_gem_object_unreference(obj
);
736 mutex_unlock(&dev
->struct_mutex
);
740 int exynos_drm_gem_dumb_destroy(struct drm_file
*file_priv
,
741 struct drm_device
*dev
,
746 DRM_DEBUG_KMS("%s\n", __FILE__
);
749 * obj->refcount and obj->handle_count are decreased and
750 * if both them are 0 then exynos_drm_gem_free_object()
751 * would be called by callback to release resources.
753 ret
= drm_gem_handle_delete(file_priv
, handle
);
755 DRM_ERROR("failed to delete drm_gem_handle.\n");
762 int exynos_drm_gem_fault(struct vm_area_struct
*vma
, struct vm_fault
*vmf
)
764 struct drm_gem_object
*obj
= vma
->vm_private_data
;
765 struct drm_device
*dev
= obj
->dev
;
766 unsigned long f_vaddr
;
770 page_offset
= ((unsigned long)vmf
->virtual_address
-
771 vma
->vm_start
) >> PAGE_SHIFT
;
772 f_vaddr
= (unsigned long)vmf
->virtual_address
;
774 mutex_lock(&dev
->struct_mutex
);
776 ret
= exynos_drm_gem_map_buf(obj
, vma
, f_vaddr
, page_offset
);
778 DRM_ERROR("failed to map a buffer with user.\n");
780 mutex_unlock(&dev
->struct_mutex
);
782 return convert_to_vm_err_msg(ret
);
785 int exynos_drm_gem_mmap(struct file
*filp
, struct vm_area_struct
*vma
)
787 struct exynos_drm_gem_obj
*exynos_gem_obj
;
788 struct drm_gem_object
*obj
;
791 DRM_DEBUG_KMS("%s\n", __FILE__
);
793 /* set vm_area_struct. */
794 ret
= drm_gem_mmap(filp
, vma
);
796 DRM_ERROR("failed to mmap.\n");
800 obj
= vma
->vm_private_data
;
801 exynos_gem_obj
= to_exynos_gem_obj(obj
);
803 ret
= check_gem_flags(exynos_gem_obj
->flags
);
805 drm_gem_vm_close(vma
);
806 drm_gem_free_mmap_offset(obj
);
810 vma
->vm_flags
&= ~VM_PFNMAP
;
811 vma
->vm_flags
|= VM_MIXEDMAP
;
813 update_vm_cache_attr(exynos_gem_obj
, vma
);