exynos_drm_gem.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /* exynos_drm_gem.c
  3. *
  4. * Copyright (c) 2011 Samsung Electronics Co., Ltd.
  5. * Author: Inki Dae <inki.dae@samsung.com>
  6. */
  7. #include <linux/dma-buf.h>
  8. #include <linux/pfn_t.h>
  9. #include <linux/shmem_fs.h>
  10. #include <drm/drm_prime.h>
  11. #include <drm/drm_vma_manager.h>
  12. #include <drm/exynos_drm.h>
  13. #include "exynos_drm_drv.h"
  14. #include "exynos_drm_gem.h"
  15. static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem, bool kvmap)
  16. {
  17. struct drm_device *dev = exynos_gem->base.dev;
  18. unsigned long attr = 0;
  19. if (exynos_gem->dma_addr) {
  20. DRM_DEV_DEBUG_KMS(to_dma_dev(dev), "already allocated.\n");
  21. return 0;
  22. }
  23. /*
  24. * if EXYNOS_BO_CONTIG, fully physically contiguous memory
  25. * region will be allocated else physically contiguous
  26. * as possible.
  27. */
  28. if (!(exynos_gem->flags & EXYNOS_BO_NONCONTIG))
  29. attr |= DMA_ATTR_FORCE_CONTIGUOUS;
  30. /*
  31. * if EXYNOS_BO_WC or EXYNOS_BO_NONCACHABLE, writecombine mapping
  32. * else cachable mapping.
  33. */
  34. if (exynos_gem->flags & EXYNOS_BO_WC ||
  35. !(exynos_gem->flags & EXYNOS_BO_CACHABLE))
  36. attr |= DMA_ATTR_WRITE_COMBINE;
  37. /* FBDev emulation requires kernel mapping */
  38. if (!kvmap)
  39. attr |= DMA_ATTR_NO_KERNEL_MAPPING;
  40. exynos_gem->dma_attrs = attr;
  41. exynos_gem->cookie = dma_alloc_attrs(to_dma_dev(dev), exynos_gem->size,
  42. &exynos_gem->dma_addr, GFP_KERNEL,
  43. exynos_gem->dma_attrs);
  44. if (!exynos_gem->cookie) {
  45. DRM_DEV_ERROR(to_dma_dev(dev), "failed to allocate buffer.\n");
  46. return -ENOMEM;
  47. }
  48. if (kvmap)
  49. exynos_gem->kvaddr = exynos_gem->cookie;
  50. DRM_DEV_DEBUG_KMS(to_dma_dev(dev), "dma_addr(0x%lx), size(0x%lx)\n",
  51. (unsigned long)exynos_gem->dma_addr, exynos_gem->size);
  52. return 0;
  53. }
  54. static void exynos_drm_free_buf(struct exynos_drm_gem *exynos_gem)
  55. {
  56. struct drm_device *dev = exynos_gem->base.dev;
  57. if (!exynos_gem->dma_addr) {
  58. DRM_DEV_DEBUG_KMS(dev->dev, "dma_addr is invalid.\n");
  59. return;
  60. }
  61. DRM_DEV_DEBUG_KMS(dev->dev, "dma_addr(0x%lx), size(0x%lx)\n",
  62. (unsigned long)exynos_gem->dma_addr, exynos_gem->size);
  63. dma_free_attrs(to_dma_dev(dev), exynos_gem->size, exynos_gem->cookie,
  64. (dma_addr_t)exynos_gem->dma_addr,
  65. exynos_gem->dma_attrs);
  66. }
  67. static int exynos_drm_gem_handle_create(struct drm_gem_object *obj,
  68. struct drm_file *file_priv,
  69. unsigned int *handle)
  70. {
  71. int ret;
  72. /*
  73. * allocate a id of idr table where the obj is registered
  74. * and handle has the id what user can see.
  75. */
  76. ret = drm_gem_handle_create(file_priv, obj, handle);
  77. if (ret)
  78. return ret;
  79. DRM_DEV_DEBUG_KMS(to_dma_dev(obj->dev), "gem handle = 0x%x\n", *handle);
  80. /* drop reference from allocate - handle holds it now. */
  81. drm_gem_object_put(obj);
  82. return 0;
  83. }
  84. void exynos_drm_gem_destroy(struct exynos_drm_gem *exynos_gem)
  85. {
  86. struct drm_gem_object *obj = &exynos_gem->base;
  87. DRM_DEV_DEBUG_KMS(to_dma_dev(obj->dev), "handle count = %d\n",
  88. obj->handle_count);
  89. /*
  90. * do not release memory region from exporter.
  91. *
  92. * the region will be released by exporter
  93. * once dmabuf's refcount becomes 0.
  94. */
  95. if (obj->import_attach)
  96. drm_prime_gem_destroy(obj, exynos_gem->sgt);
  97. else
  98. exynos_drm_free_buf(exynos_gem);
  99. /* release file pointer to gem object. */
  100. drm_gem_object_release(obj);
  101. kfree(exynos_gem);
  102. }
  103. static struct exynos_drm_gem *exynos_drm_gem_init(struct drm_device *dev,
  104. unsigned long size)
  105. {
  106. struct exynos_drm_gem *exynos_gem;
  107. struct drm_gem_object *obj;
  108. int ret;
  109. exynos_gem = kzalloc(sizeof(*exynos_gem), GFP_KERNEL);
  110. if (!exynos_gem)
  111. return ERR_PTR(-ENOMEM);
  112. exynos_gem->size = size;
  113. obj = &exynos_gem->base;
  114. ret = drm_gem_object_init(dev, obj, size);
  115. if (ret < 0) {
  116. DRM_DEV_ERROR(dev->dev, "failed to initialize gem object\n");
  117. kfree(exynos_gem);
  118. return ERR_PTR(ret);
  119. }
  120. ret = drm_gem_create_mmap_offset(obj);
  121. if (ret < 0) {
  122. drm_gem_object_release(obj);
  123. kfree(exynos_gem);
  124. return ERR_PTR(ret);
  125. }
  126. DRM_DEV_DEBUG_KMS(dev->dev, "created file object = %pK\n", obj->filp);
  127. return exynos_gem;
  128. }
  129. struct exynos_drm_gem *exynos_drm_gem_create(struct drm_device *dev,
  130. unsigned int flags,
  131. unsigned long size,
  132. bool kvmap)
  133. {
  134. struct exynos_drm_gem *exynos_gem;
  135. int ret;
  136. if (flags & ~(EXYNOS_BO_MASK)) {
  137. DRM_DEV_ERROR(dev->dev,
  138. "invalid GEM buffer flags: %u\n", flags);
  139. return ERR_PTR(-EINVAL);
  140. }
  141. if (!size) {
  142. DRM_DEV_ERROR(dev->dev, "invalid GEM buffer size: %lu\n", size);
  143. return ERR_PTR(-EINVAL);
  144. }
  145. size = roundup(size, PAGE_SIZE);
  146. exynos_gem = exynos_drm_gem_init(dev, size);
  147. if (IS_ERR(exynos_gem))
  148. return exynos_gem;
  149. if (!is_drm_iommu_supported(dev) && (flags & EXYNOS_BO_NONCONTIG)) {
  150. /*
  151. * when no IOMMU is available, all allocated buffers are
  152. * contiguous anyway, so drop EXYNOS_BO_NONCONTIG flag
  153. */
  154. flags &= ~EXYNOS_BO_NONCONTIG;
  155. DRM_WARN("Non-contiguous allocation is not supported without IOMMU, falling back to contiguous buffer\n");
  156. }
  157. /* set memory type and cache attribute from user side. */
  158. exynos_gem->flags = flags;
  159. ret = exynos_drm_alloc_buf(exynos_gem, kvmap);
  160. if (ret < 0) {
  161. drm_gem_object_release(&exynos_gem->base);
  162. kfree(exynos_gem);
  163. return ERR_PTR(ret);
  164. }
  165. return exynos_gem;
  166. }
  167. int exynos_drm_gem_create_ioctl(struct drm_device *dev, void *data,
  168. struct drm_file *file_priv)
  169. {
  170. struct drm_exynos_gem_create *args = data;
  171. struct exynos_drm_gem *exynos_gem;
  172. int ret;
  173. exynos_gem = exynos_drm_gem_create(dev, args->flags, args->size, false);
  174. if (IS_ERR(exynos_gem))
  175. return PTR_ERR(exynos_gem);
  176. ret = exynos_drm_gem_handle_create(&exynos_gem->base, file_priv,
  177. &args->handle);
  178. if (ret) {
  179. exynos_drm_gem_destroy(exynos_gem);
  180. return ret;
  181. }
  182. return 0;
  183. }
  184. int exynos_drm_gem_map_ioctl(struct drm_device *dev, void *data,
  185. struct drm_file *file_priv)
  186. {
  187. struct drm_exynos_gem_map *args = data;
  188. return drm_gem_dumb_map_offset(file_priv, dev, args->handle,
  189. &args->offset);
  190. }
  191. struct exynos_drm_gem *exynos_drm_gem_get(struct drm_file *filp,
  192. unsigned int gem_handle)
  193. {
  194. struct drm_gem_object *obj;
  195. obj = drm_gem_object_lookup(filp, gem_handle);
  196. if (!obj)
  197. return NULL;
  198. return to_exynos_gem(obj);
  199. }
  200. static int exynos_drm_gem_mmap_buffer(struct exynos_drm_gem *exynos_gem,
  201. struct vm_area_struct *vma)
  202. {
  203. struct drm_device *drm_dev = exynos_gem->base.dev;
  204. unsigned long vm_size;
  205. int ret;
  206. vma->vm_flags &= ~VM_PFNMAP;
  207. vma->vm_pgoff = 0;
  208. vm_size = vma->vm_end - vma->vm_start;
  209. /* check if user-requested size is valid. */
  210. if (vm_size > exynos_gem->size)
  211. return -EINVAL;
  212. ret = dma_mmap_attrs(to_dma_dev(drm_dev), vma, exynos_gem->cookie,
  213. exynos_gem->dma_addr, exynos_gem->size,
  214. exynos_gem->dma_attrs);
  215. if (ret < 0) {
  216. DRM_ERROR("failed to mmap.\n");
  217. return ret;
  218. }
  219. return 0;
  220. }
  221. int exynos_drm_gem_get_ioctl(struct drm_device *dev, void *data,
  222. struct drm_file *file_priv)
  223. {
  224. struct exynos_drm_gem *exynos_gem;
  225. struct drm_exynos_gem_info *args = data;
  226. struct drm_gem_object *obj;
  227. obj = drm_gem_object_lookup(file_priv, args->handle);
  228. if (!obj) {
  229. DRM_DEV_ERROR(dev->dev, "failed to lookup gem object.\n");
  230. return -EINVAL;
  231. }
  232. exynos_gem = to_exynos_gem(obj);
  233. args->flags = exynos_gem->flags;
  234. args->size = exynos_gem->size;
  235. drm_gem_object_put(obj);
  236. return 0;
  237. }
  238. void exynos_drm_gem_free_object(struct drm_gem_object *obj)
  239. {
  240. exynos_drm_gem_destroy(to_exynos_gem(obj));
  241. }
  242. int exynos_drm_gem_dumb_create(struct drm_file *file_priv,
  243. struct drm_device *dev,
  244. struct drm_mode_create_dumb *args)
  245. {
  246. struct exynos_drm_gem *exynos_gem;
  247. unsigned int flags;
  248. int ret;
  249. /*
  250. * allocate memory to be used for framebuffer.
  251. * - this callback would be called by user application
  252. * with DRM_IOCTL_MODE_CREATE_DUMB command.
  253. */
  254. args->pitch = args->width * ((args->bpp + 7) / 8);
  255. args->size = args->pitch * args->height;
  256. if (is_drm_iommu_supported(dev))
  257. flags = EXYNOS_BO_NONCONTIG | EXYNOS_BO_WC;
  258. else
  259. flags = EXYNOS_BO_CONTIG | EXYNOS_BO_WC;
  260. exynos_gem = exynos_drm_gem_create(dev, flags, args->size, false);
  261. if (IS_ERR(exynos_gem)) {
  262. dev_warn(dev->dev, "FB allocation failed.\n");
  263. return PTR_ERR(exynos_gem);
  264. }
  265. ret = exynos_drm_gem_handle_create(&exynos_gem->base, file_priv,
  266. &args->handle);
  267. if (ret) {
  268. exynos_drm_gem_destroy(exynos_gem);
  269. return ret;
  270. }
  271. return 0;
  272. }
  273. static int exynos_drm_gem_mmap_obj(struct drm_gem_object *obj,
  274. struct vm_area_struct *vma)
  275. {
  276. struct exynos_drm_gem *exynos_gem = to_exynos_gem(obj);
  277. int ret;
  278. DRM_DEV_DEBUG_KMS(to_dma_dev(obj->dev), "flags = 0x%x\n",
  279. exynos_gem->flags);
  280. /* non-cachable as default. */
  281. if (exynos_gem->flags & EXYNOS_BO_CACHABLE)
  282. vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
  283. else if (exynos_gem->flags & EXYNOS_BO_WC)
  284. vma->vm_page_prot =
  285. pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
  286. else
  287. vma->vm_page_prot =
  288. pgprot_noncached(vm_get_page_prot(vma->vm_flags));
  289. ret = exynos_drm_gem_mmap_buffer(exynos_gem, vma);
  290. if (ret)
  291. goto err_close_vm;
  292. return ret;
  293. err_close_vm:
  294. drm_gem_vm_close(vma);
  295. return ret;
  296. }
  297. int exynos_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
  298. {
  299. struct drm_gem_object *obj;
  300. int ret;
  301. /* set vm_area_struct. */
  302. ret = drm_gem_mmap(filp, vma);
  303. if (ret < 0) {
  304. DRM_ERROR("failed to mmap.\n");
  305. return ret;
  306. }
  307. obj = vma->vm_private_data;
  308. if (obj->import_attach)
  309. return dma_buf_mmap(obj->dma_buf, vma, 0);
  310. return exynos_drm_gem_mmap_obj(obj, vma);
  311. }
  312. /* low-level interface prime helpers */
  313. struct drm_gem_object *exynos_drm_gem_prime_import(struct drm_device *dev,
  314. struct dma_buf *dma_buf)
  315. {
  316. return drm_gem_prime_import_dev(dev, dma_buf, to_dma_dev(dev));
  317. }
  318. struct sg_table *exynos_drm_gem_prime_get_sg_table(struct drm_gem_object *obj)
  319. {
  320. struct exynos_drm_gem *exynos_gem = to_exynos_gem(obj);
  321. struct drm_device *drm_dev = obj->dev;
  322. struct sg_table *sgt;
  323. int ret;
  324. sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
  325. if (!sgt)
  326. return ERR_PTR(-ENOMEM);
  327. ret = dma_get_sgtable_attrs(to_dma_dev(drm_dev), sgt, exynos_gem->cookie,
  328. exynos_gem->dma_addr, exynos_gem->size,
  329. exynos_gem->dma_attrs);
  330. if (ret) {
  331. DRM_ERROR("failed to get sgtable, %d\n", ret);
  332. kfree(sgt);
  333. return ERR_PTR(ret);
  334. }
  335. return sgt;
  336. }
  337. struct drm_gem_object *
  338. exynos_drm_gem_prime_import_sg_table(struct drm_device *dev,
  339. struct dma_buf_attachment *attach,
  340. struct sg_table *sgt)
  341. {
  342. struct exynos_drm_gem *exynos_gem;
  343. /* check if the entries in the sg_table are contiguous */
  344. if (drm_prime_get_contiguous_size(sgt) < attach->dmabuf->size) {
  345. DRM_ERROR("buffer chunks must be mapped contiguously");
  346. return ERR_PTR(-EINVAL);
  347. }
  348. exynos_gem = exynos_drm_gem_init(dev, attach->dmabuf->size);
  349. if (IS_ERR(exynos_gem))
  350. return ERR_CAST(exynos_gem);
  351. /*
  352. * Buffer has been mapped as contiguous into DMA address space,
  353. * but if there is IOMMU, it can be either CONTIG or NONCONTIG.
  354. * We assume a simplified logic below:
  355. */
  356. if (is_drm_iommu_supported(dev))
  357. exynos_gem->flags |= EXYNOS_BO_NONCONTIG;
  358. else
  359. exynos_gem->flags |= EXYNOS_BO_CONTIG;
  360. exynos_gem->dma_addr = sg_dma_address(sgt->sgl);
  361. exynos_gem->sgt = sgt;
  362. return &exynos_gem->base;
  363. }
  364. void *exynos_drm_gem_prime_vmap(struct drm_gem_object *obj)
  365. {
  366. return NULL;
  367. }
  368. void exynos_drm_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr)
  369. {
  370. /* Nothing to do */
  371. }
  372. int exynos_drm_gem_prime_mmap(struct drm_gem_object *obj,
  373. struct vm_area_struct *vma)
  374. {
  375. int ret;
  376. ret = drm_gem_mmap_obj(obj, obj->size, vma);
  377. if (ret < 0)
  378. return ret;
  379. return exynos_drm_gem_mmap_obj(obj, vma);
  380. }