gem.c 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249
  1. /*
  2. * NVIDIA Tegra DRM GEM helper functions
  3. *
  4. * Copyright (C) 2012 Sascha Hauer, Pengutronix
  5. * Copyright (C) 2013 NVIDIA CORPORATION, All rights reserved.
  6. *
  7. * Based on the GEM/CMA helpers
  8. *
  9. * Copyright (c) 2011 Samsung Electronics Co., Ltd.
  10. *
  11. * This program is free software; you can redistribute it and/or
  12. * modify it under the terms of the GNU General Public License
  13. * as published by the Free Software Foundation; either version 2
  14. * of the License, or (at your option) any later version.
  15. * This program is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. * GNU General Public License for more details.
  19. */
  20. #include "gem.h"
  21. static inline struct tegra_bo *host1x_to_drm_bo(struct host1x_bo *bo)
  22. {
  23. return container_of(bo, struct tegra_bo, base);
  24. }
  25. static void tegra_bo_put(struct host1x_bo *bo)
  26. {
  27. struct tegra_bo *obj = host1x_to_drm_bo(bo);
  28. struct drm_device *drm = obj->gem.dev;
  29. mutex_lock(&drm->struct_mutex);
  30. drm_gem_object_unreference(&obj->gem);
  31. mutex_unlock(&drm->struct_mutex);
  32. }
  33. static dma_addr_t tegra_bo_pin(struct host1x_bo *bo, struct sg_table **sgt)
  34. {
  35. struct tegra_bo *obj = host1x_to_drm_bo(bo);
  36. return obj->paddr;
  37. }
  38. static void tegra_bo_unpin(struct host1x_bo *bo, struct sg_table *sgt)
  39. {
  40. }
  41. static void *tegra_bo_mmap(struct host1x_bo *bo)
  42. {
  43. struct tegra_bo *obj = host1x_to_drm_bo(bo);
  44. return obj->vaddr;
  45. }
  46. static void tegra_bo_munmap(struct host1x_bo *bo, void *addr)
  47. {
  48. }
  49. static void *tegra_bo_kmap(struct host1x_bo *bo, unsigned int page)
  50. {
  51. struct tegra_bo *obj = host1x_to_drm_bo(bo);
  52. return obj->vaddr + page * PAGE_SIZE;
  53. }
  54. static void tegra_bo_kunmap(struct host1x_bo *bo, unsigned int page,
  55. void *addr)
  56. {
  57. }
  58. static struct host1x_bo *tegra_bo_get(struct host1x_bo *bo)
  59. {
  60. struct tegra_bo *obj = host1x_to_drm_bo(bo);
  61. struct drm_device *drm = obj->gem.dev;
  62. mutex_lock(&drm->struct_mutex);
  63. drm_gem_object_reference(&obj->gem);
  64. mutex_unlock(&drm->struct_mutex);
  65. return bo;
  66. }
  67. const struct host1x_bo_ops tegra_bo_ops = {
  68. .get = tegra_bo_get,
  69. .put = tegra_bo_put,
  70. .pin = tegra_bo_pin,
  71. .unpin = tegra_bo_unpin,
  72. .mmap = tegra_bo_mmap,
  73. .munmap = tegra_bo_munmap,
  74. .kmap = tegra_bo_kmap,
  75. .kunmap = tegra_bo_kunmap,
  76. };
  77. static void tegra_bo_destroy(struct drm_device *drm, struct tegra_bo *bo)
  78. {
  79. dma_free_writecombine(drm->dev, bo->gem.size, bo->vaddr, bo->paddr);
  80. }
  81. struct tegra_bo *tegra_bo_create(struct drm_device *drm, unsigned int size)
  82. {
  83. struct tegra_bo *bo;
  84. int err;
  85. bo = kzalloc(sizeof(*bo), GFP_KERNEL);
  86. if (!bo)
  87. return ERR_PTR(-ENOMEM);
  88. host1x_bo_init(&bo->base, &tegra_bo_ops);
  89. size = round_up(size, PAGE_SIZE);
  90. bo->vaddr = dma_alloc_writecombine(drm->dev, size, &bo->paddr,
  91. GFP_KERNEL | __GFP_NOWARN);
  92. if (!bo->vaddr) {
  93. dev_err(drm->dev, "failed to allocate buffer with size %u\n",
  94. size);
  95. err = -ENOMEM;
  96. goto err_dma;
  97. }
  98. err = drm_gem_object_init(drm, &bo->gem, size);
  99. if (err)
  100. goto err_init;
  101. err = drm_gem_create_mmap_offset(&bo->gem);
  102. if (err)
  103. goto err_mmap;
  104. return bo;
  105. err_mmap:
  106. drm_gem_object_release(&bo->gem);
  107. err_init:
  108. tegra_bo_destroy(drm, bo);
  109. err_dma:
  110. kfree(bo);
  111. return ERR_PTR(err);
  112. }
  113. struct tegra_bo *tegra_bo_create_with_handle(struct drm_file *file,
  114. struct drm_device *drm,
  115. unsigned int size,
  116. unsigned int *handle)
  117. {
  118. struct tegra_bo *bo;
  119. int ret;
  120. bo = tegra_bo_create(drm, size);
  121. if (IS_ERR(bo))
  122. return bo;
  123. ret = drm_gem_handle_create(file, &bo->gem, handle);
  124. if (ret)
  125. goto err;
  126. drm_gem_object_unreference_unlocked(&bo->gem);
  127. return bo;
  128. err:
  129. tegra_bo_free_object(&bo->gem);
  130. return ERR_PTR(ret);
  131. }
  132. void tegra_bo_free_object(struct drm_gem_object *gem)
  133. {
  134. struct tegra_bo *bo = to_tegra_bo(gem);
  135. drm_gem_free_mmap_offset(gem);
  136. drm_gem_object_release(gem);
  137. tegra_bo_destroy(gem->dev, bo);
  138. kfree(bo);
  139. }
  140. int tegra_bo_dumb_create(struct drm_file *file, struct drm_device *drm,
  141. struct drm_mode_create_dumb *args)
  142. {
  143. int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
  144. struct tegra_bo *bo;
  145. if (args->pitch < min_pitch)
  146. args->pitch = min_pitch;
  147. if (args->size < args->pitch * args->height)
  148. args->size = args->pitch * args->height;
  149. bo = tegra_bo_create_with_handle(file, drm, args->size,
  150. &args->handle);
  151. if (IS_ERR(bo))
  152. return PTR_ERR(bo);
  153. return 0;
  154. }
  155. int tegra_bo_dumb_map_offset(struct drm_file *file, struct drm_device *drm,
  156. uint32_t handle, uint64_t *offset)
  157. {
  158. struct drm_gem_object *gem;
  159. struct tegra_bo *bo;
  160. mutex_lock(&drm->struct_mutex);
  161. gem = drm_gem_object_lookup(drm, file, handle);
  162. if (!gem) {
  163. dev_err(drm->dev, "failed to lookup GEM object\n");
  164. mutex_unlock(&drm->struct_mutex);
  165. return -EINVAL;
  166. }
  167. bo = to_tegra_bo(gem);
  168. *offset = drm_vma_node_offset_addr(&bo->gem.vma_node);
  169. drm_gem_object_unreference(gem);
  170. mutex_unlock(&drm->struct_mutex);
  171. return 0;
  172. }
  173. const struct vm_operations_struct tegra_bo_vm_ops = {
  174. .open = drm_gem_vm_open,
  175. .close = drm_gem_vm_close,
  176. };
  177. int tegra_drm_mmap(struct file *file, struct vm_area_struct *vma)
  178. {
  179. struct drm_gem_object *gem;
  180. struct tegra_bo *bo;
  181. int ret;
  182. ret = drm_gem_mmap(file, vma);
  183. if (ret)
  184. return ret;
  185. gem = vma->vm_private_data;
  186. bo = to_tegra_bo(gem);
  187. ret = remap_pfn_range(vma, vma->vm_start, bo->paddr >> PAGE_SHIFT,
  188. vma->vm_end - vma->vm_start, vma->vm_page_prot);
  189. if (ret)
  190. drm_gem_vm_close(vma);
  191. return ret;
  192. }