exynos_drm_gem.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771
  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. #include "drmP.h"
  26. #include "drm.h"
  27. #include <linux/shmem_fs.h>
  28. #include <drm/exynos_drm.h>
  29. #include "exynos_drm_drv.h"
  30. #include "exynos_drm_gem.h"
  31. #include "exynos_drm_buf.h"
  32. static unsigned int convert_to_vm_err_msg(int msg)
  33. {
  34. unsigned int out_msg;
  35. switch (msg) {
  36. case 0:
  37. case -ERESTARTSYS:
  38. case -EINTR:
  39. out_msg = VM_FAULT_NOPAGE;
  40. break;
  41. case -ENOMEM:
  42. out_msg = VM_FAULT_OOM;
  43. break;
  44. default:
  45. out_msg = VM_FAULT_SIGBUS;
  46. break;
  47. }
  48. return out_msg;
  49. }
  50. static int check_gem_flags(unsigned int flags)
  51. {
  52. if (flags & ~(EXYNOS_BO_MASK)) {
  53. DRM_ERROR("invalid flags.\n");
  54. return -EINVAL;
  55. }
  56. return 0;
  57. }
  58. static void update_vm_cache_attr(struct exynos_drm_gem_obj *obj,
  59. struct vm_area_struct *vma)
  60. {
  61. DRM_DEBUG_KMS("flags = 0x%x\n", obj->flags);
  62. /* non-cachable as default. */
  63. if (obj->flags & EXYNOS_BO_CACHABLE)
  64. vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
  65. else if (obj->flags & EXYNOS_BO_WC)
  66. vma->vm_page_prot =
  67. pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
  68. else
  69. vma->vm_page_prot =
  70. pgprot_noncached(vm_get_page_prot(vma->vm_flags));
  71. }
  72. static unsigned long roundup_gem_size(unsigned long size, unsigned int flags)
  73. {
  74. if (!IS_NONCONTIG_BUFFER(flags)) {
  75. if (size >= SZ_1M)
  76. return roundup(size, SECTION_SIZE);
  77. else if (size >= SZ_64K)
  78. return roundup(size, SZ_64K);
  79. else
  80. goto out;
  81. }
  82. out:
  83. return roundup(size, PAGE_SIZE);
  84. }
  85. static struct page **exynos_gem_get_pages(struct drm_gem_object *obj,
  86. gfp_t gfpmask)
  87. {
  88. struct inode *inode;
  89. struct address_space *mapping;
  90. struct page *p, **pages;
  91. int i, npages;
  92. /* This is the shared memory object that backs the GEM resource */
  93. inode = obj->filp->f_path.dentry->d_inode;
  94. mapping = inode->i_mapping;
  95. npages = obj->size >> PAGE_SHIFT;
  96. pages = drm_malloc_ab(npages, sizeof(struct page *));
  97. if (pages == NULL)
  98. return ERR_PTR(-ENOMEM);
  99. gfpmask |= mapping_gfp_mask(mapping);
  100. for (i = 0; i < npages; i++) {
  101. p = shmem_read_mapping_page_gfp(mapping, i, gfpmask);
  102. if (IS_ERR(p))
  103. goto fail;
  104. pages[i] = p;
  105. }
  106. return pages;
  107. fail:
  108. while (i--)
  109. page_cache_release(pages[i]);
  110. drm_free_large(pages);
  111. return ERR_PTR(PTR_ERR(p));
  112. }
  113. static void exynos_gem_put_pages(struct drm_gem_object *obj,
  114. struct page **pages,
  115. bool dirty, bool accessed)
  116. {
  117. int i, npages;
  118. npages = obj->size >> PAGE_SHIFT;
  119. for (i = 0; i < npages; i++) {
  120. if (dirty)
  121. set_page_dirty(pages[i]);
  122. if (accessed)
  123. mark_page_accessed(pages[i]);
  124. /* Undo the reference we took when populating the table */
  125. page_cache_release(pages[i]);
  126. }
  127. drm_free_large(pages);
  128. }
  129. static int exynos_drm_gem_map_pages(struct drm_gem_object *obj,
  130. struct vm_area_struct *vma,
  131. unsigned long f_vaddr,
  132. pgoff_t page_offset)
  133. {
  134. struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
  135. struct exynos_drm_gem_buf *buf = exynos_gem_obj->buffer;
  136. unsigned long pfn;
  137. if (exynos_gem_obj->flags & EXYNOS_BO_NONCONTIG) {
  138. if (!buf->pages)
  139. return -EINTR;
  140. pfn = page_to_pfn(buf->pages[page_offset++]);
  141. } else
  142. pfn = (buf->dma_addr >> PAGE_SHIFT) + page_offset;
  143. return vm_insert_mixed(vma, f_vaddr, pfn);
  144. }
  145. static int exynos_drm_gem_get_pages(struct drm_gem_object *obj)
  146. {
  147. struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
  148. struct exynos_drm_gem_buf *buf = exynos_gem_obj->buffer;
  149. struct scatterlist *sgl;
  150. struct page **pages;
  151. unsigned int npages, i = 0;
  152. int ret;
  153. if (buf->pages) {
  154. DRM_DEBUG_KMS("already allocated.\n");
  155. return -EINVAL;
  156. }
  157. pages = exynos_gem_get_pages(obj, GFP_KERNEL);
  158. if (IS_ERR(pages)) {
  159. DRM_ERROR("failed to get pages.\n");
  160. return PTR_ERR(pages);
  161. }
  162. npages = obj->size >> PAGE_SHIFT;
  163. buf->sgt = kzalloc(sizeof(struct sg_table), GFP_KERNEL);
  164. if (!buf->sgt) {
  165. DRM_ERROR("failed to allocate sg table.\n");
  166. ret = -ENOMEM;
  167. goto err;
  168. }
  169. ret = sg_alloc_table(buf->sgt, npages, GFP_KERNEL);
  170. if (ret < 0) {
  171. DRM_ERROR("failed to initialize sg table.\n");
  172. ret = -EFAULT;
  173. goto err1;
  174. }
  175. sgl = buf->sgt->sgl;
  176. /* set all pages to sg list. */
  177. while (i < npages) {
  178. sg_set_page(sgl, pages[i], PAGE_SIZE, 0);
  179. sg_dma_address(sgl) = page_to_phys(pages[i]);
  180. i++;
  181. sgl = sg_next(sgl);
  182. }
  183. /* add some codes for UNCACHED type here. TODO */
  184. buf->pages = pages;
  185. return ret;
  186. err1:
  187. kfree(buf->sgt);
  188. buf->sgt = NULL;
  189. err:
  190. exynos_gem_put_pages(obj, pages, true, false);
  191. return ret;
  192. }
  193. static void exynos_drm_gem_put_pages(struct drm_gem_object *obj)
  194. {
  195. struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
  196. struct exynos_drm_gem_buf *buf = exynos_gem_obj->buffer;
  197. /*
  198. * if buffer typs is EXYNOS_BO_NONCONTIG then release all pages
  199. * allocated at gem fault handler.
  200. */
  201. sg_free_table(buf->sgt);
  202. kfree(buf->sgt);
  203. buf->sgt = NULL;
  204. exynos_gem_put_pages(obj, buf->pages, true, false);
  205. buf->pages = NULL;
  206. /* add some codes for UNCACHED type here. TODO */
  207. }
  208. static int exynos_drm_gem_handle_create(struct drm_gem_object *obj,
  209. struct drm_file *file_priv,
  210. unsigned int *handle)
  211. {
  212. int ret;
  213. /*
  214. * allocate a id of idr table where the obj is registered
  215. * and handle has the id what user can see.
  216. */
  217. ret = drm_gem_handle_create(file_priv, obj, handle);
  218. if (ret)
  219. return ret;
  220. DRM_DEBUG_KMS("gem handle = 0x%x\n", *handle);
  221. /* drop reference from allocate - handle holds it now. */
  222. drm_gem_object_unreference_unlocked(obj);
  223. return 0;
  224. }
  225. void exynos_drm_gem_destroy(struct exynos_drm_gem_obj *exynos_gem_obj)
  226. {
  227. struct drm_gem_object *obj;
  228. struct exynos_drm_gem_buf *buf;
  229. DRM_DEBUG_KMS("%s\n", __FILE__);
  230. obj = &exynos_gem_obj->base;
  231. buf = exynos_gem_obj->buffer;
  232. DRM_DEBUG_KMS("handle count = %d\n", atomic_read(&obj->handle_count));
  233. if (!buf->pages)
  234. return;
  235. if (exynos_gem_obj->flags & EXYNOS_BO_NONCONTIG)
  236. exynos_drm_gem_put_pages(obj);
  237. else
  238. exynos_drm_free_buf(obj->dev, exynos_gem_obj->flags, buf);
  239. exynos_drm_fini_buf(obj->dev, buf);
  240. exynos_gem_obj->buffer = NULL;
  241. if (obj->map_list.map)
  242. drm_gem_free_mmap_offset(obj);
  243. /* release file pointer to gem object. */
  244. drm_gem_object_release(obj);
  245. kfree(exynos_gem_obj);
  246. exynos_gem_obj = NULL;
  247. }
  248. static struct exynos_drm_gem_obj *exynos_drm_gem_init(struct drm_device *dev,
  249. unsigned long size)
  250. {
  251. struct exynos_drm_gem_obj *exynos_gem_obj;
  252. struct drm_gem_object *obj;
  253. int ret;
  254. exynos_gem_obj = kzalloc(sizeof(*exynos_gem_obj), GFP_KERNEL);
  255. if (!exynos_gem_obj) {
  256. DRM_ERROR("failed to allocate exynos gem object\n");
  257. return NULL;
  258. }
  259. exynos_gem_obj->size = size;
  260. obj = &exynos_gem_obj->base;
  261. ret = drm_gem_object_init(dev, obj, size);
  262. if (ret < 0) {
  263. DRM_ERROR("failed to initialize gem object\n");
  264. kfree(exynos_gem_obj);
  265. return NULL;
  266. }
  267. DRM_DEBUG_KMS("created file object = 0x%x\n", (unsigned int)obj->filp);
  268. return exynos_gem_obj;
  269. }
  270. struct exynos_drm_gem_obj *exynos_drm_gem_create(struct drm_device *dev,
  271. unsigned int flags,
  272. unsigned long size)
  273. {
  274. struct exynos_drm_gem_obj *exynos_gem_obj;
  275. struct exynos_drm_gem_buf *buf;
  276. int ret;
  277. if (!size) {
  278. DRM_ERROR("invalid size.\n");
  279. return ERR_PTR(-EINVAL);
  280. }
  281. size = roundup_gem_size(size, flags);
  282. DRM_DEBUG_KMS("%s\n", __FILE__);
  283. ret = check_gem_flags(flags);
  284. if (ret)
  285. return ERR_PTR(ret);
  286. buf = exynos_drm_init_buf(dev, size);
  287. if (!buf)
  288. return ERR_PTR(-ENOMEM);
  289. exynos_gem_obj = exynos_drm_gem_init(dev, size);
  290. if (!exynos_gem_obj) {
  291. ret = -ENOMEM;
  292. goto err_fini_buf;
  293. }
  294. exynos_gem_obj->buffer = buf;
  295. /* set memory type and cache attribute from user side. */
  296. exynos_gem_obj->flags = flags;
  297. /*
  298. * allocate all pages as desired size if user wants to allocate
  299. * physically non-continuous memory.
  300. */
  301. if (flags & EXYNOS_BO_NONCONTIG) {
  302. ret = exynos_drm_gem_get_pages(&exynos_gem_obj->base);
  303. if (ret < 0) {
  304. drm_gem_object_release(&exynos_gem_obj->base);
  305. goto err_fini_buf;
  306. }
  307. } else {
  308. ret = exynos_drm_alloc_buf(dev, buf, flags);
  309. if (ret < 0) {
  310. drm_gem_object_release(&exynos_gem_obj->base);
  311. goto err_fini_buf;
  312. }
  313. }
  314. return exynos_gem_obj;
  315. err_fini_buf:
  316. exynos_drm_fini_buf(dev, buf);
  317. return ERR_PTR(ret);
  318. }
  319. int exynos_drm_gem_create_ioctl(struct drm_device *dev, void *data,
  320. struct drm_file *file_priv)
  321. {
  322. struct drm_exynos_gem_create *args = data;
  323. struct exynos_drm_gem_obj *exynos_gem_obj;
  324. int ret;
  325. DRM_DEBUG_KMS("%s\n", __FILE__);
  326. exynos_gem_obj = exynos_drm_gem_create(dev, args->flags, args->size);
  327. if (IS_ERR(exynos_gem_obj))
  328. return PTR_ERR(exynos_gem_obj);
  329. ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
  330. &args->handle);
  331. if (ret) {
  332. exynos_drm_gem_destroy(exynos_gem_obj);
  333. return ret;
  334. }
  335. return 0;
  336. }
  337. void *exynos_drm_gem_get_dma_addr(struct drm_device *dev,
  338. unsigned int gem_handle,
  339. struct drm_file *file_priv)
  340. {
  341. struct exynos_drm_gem_obj *exynos_gem_obj;
  342. struct drm_gem_object *obj;
  343. obj = drm_gem_object_lookup(dev, file_priv, gem_handle);
  344. if (!obj) {
  345. DRM_ERROR("failed to lookup gem object.\n");
  346. return ERR_PTR(-EINVAL);
  347. }
  348. exynos_gem_obj = to_exynos_gem_obj(obj);
  349. if (exynos_gem_obj->flags & EXYNOS_BO_NONCONTIG) {
  350. DRM_DEBUG_KMS("not support NONCONTIG type.\n");
  351. drm_gem_object_unreference_unlocked(obj);
  352. /* TODO */
  353. return ERR_PTR(-EINVAL);
  354. }
  355. return &exynos_gem_obj->buffer->dma_addr;
  356. }
  357. void exynos_drm_gem_put_dma_addr(struct drm_device *dev,
  358. unsigned int gem_handle,
  359. struct drm_file *file_priv)
  360. {
  361. struct exynos_drm_gem_obj *exynos_gem_obj;
  362. struct drm_gem_object *obj;
  363. obj = drm_gem_object_lookup(dev, file_priv, gem_handle);
  364. if (!obj) {
  365. DRM_ERROR("failed to lookup gem object.\n");
  366. return;
  367. }
  368. exynos_gem_obj = to_exynos_gem_obj(obj);
  369. if (exynos_gem_obj->flags & EXYNOS_BO_NONCONTIG) {
  370. DRM_DEBUG_KMS("not support NONCONTIG type.\n");
  371. drm_gem_object_unreference_unlocked(obj);
  372. /* TODO */
  373. return;
  374. }
  375. drm_gem_object_unreference_unlocked(obj);
  376. /*
  377. * decrease obj->refcount one more time because we has already
  378. * increased it at exynos_drm_gem_get_dma_addr().
  379. */
  380. drm_gem_object_unreference_unlocked(obj);
  381. }
  382. int exynos_drm_gem_map_offset_ioctl(struct drm_device *dev, void *data,
  383. struct drm_file *file_priv)
  384. {
  385. struct drm_exynos_gem_map_off *args = data;
  386. DRM_DEBUG_KMS("%s\n", __FILE__);
  387. DRM_DEBUG_KMS("handle = 0x%x, offset = 0x%lx\n",
  388. args->handle, (unsigned long)args->offset);
  389. if (!(dev->driver->driver_features & DRIVER_GEM)) {
  390. DRM_ERROR("does not support GEM.\n");
  391. return -ENODEV;
  392. }
  393. return exynos_drm_gem_dumb_map_offset(file_priv, dev, args->handle,
  394. &args->offset);
  395. }
  396. static int exynos_drm_gem_mmap_buffer(struct file *filp,
  397. struct vm_area_struct *vma)
  398. {
  399. struct drm_gem_object *obj = filp->private_data;
  400. struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
  401. struct exynos_drm_gem_buf *buffer;
  402. unsigned long pfn, vm_size, usize, uaddr = vma->vm_start;
  403. int ret;
  404. DRM_DEBUG_KMS("%s\n", __FILE__);
  405. vma->vm_flags |= (VM_IO | VM_RESERVED);
  406. update_vm_cache_attr(exynos_gem_obj, vma);
  407. vm_size = usize = vma->vm_end - vma->vm_start;
  408. /*
  409. * a buffer contains information to physically continuous memory
  410. * allocated by user request or at framebuffer creation.
  411. */
  412. buffer = exynos_gem_obj->buffer;
  413. /* check if user-requested size is valid. */
  414. if (vm_size > buffer->size)
  415. return -EINVAL;
  416. if (exynos_gem_obj->flags & EXYNOS_BO_NONCONTIG) {
  417. int i = 0;
  418. if (!buffer->pages)
  419. return -EINVAL;
  420. vma->vm_flags |= VM_MIXEDMAP;
  421. do {
  422. ret = vm_insert_page(vma, uaddr, buffer->pages[i++]);
  423. if (ret) {
  424. DRM_ERROR("failed to remap user space.\n");
  425. return ret;
  426. }
  427. uaddr += PAGE_SIZE;
  428. usize -= PAGE_SIZE;
  429. } while (usize > 0);
  430. } else {
  431. /*
  432. * get page frame number to physical memory to be mapped
  433. * to user space.
  434. */
  435. pfn = ((unsigned long)exynos_gem_obj->buffer->dma_addr) >>
  436. PAGE_SHIFT;
  437. DRM_DEBUG_KMS("pfn = 0x%lx\n", pfn);
  438. if (remap_pfn_range(vma, vma->vm_start, pfn, vm_size,
  439. vma->vm_page_prot)) {
  440. DRM_ERROR("failed to remap pfn range.\n");
  441. return -EAGAIN;
  442. }
  443. }
  444. return 0;
  445. }
  446. static const struct file_operations exynos_drm_gem_fops = {
  447. .mmap = exynos_drm_gem_mmap_buffer,
  448. };
  449. int exynos_drm_gem_mmap_ioctl(struct drm_device *dev, void *data,
  450. struct drm_file *file_priv)
  451. {
  452. struct drm_exynos_gem_mmap *args = data;
  453. struct drm_gem_object *obj;
  454. unsigned int addr;
  455. DRM_DEBUG_KMS("%s\n", __FILE__);
  456. if (!(dev->driver->driver_features & DRIVER_GEM)) {
  457. DRM_ERROR("does not support GEM.\n");
  458. return -ENODEV;
  459. }
  460. obj = drm_gem_object_lookup(dev, file_priv, args->handle);
  461. if (!obj) {
  462. DRM_ERROR("failed to lookup gem object.\n");
  463. return -EINVAL;
  464. }
  465. obj->filp->f_op = &exynos_drm_gem_fops;
  466. obj->filp->private_data = obj;
  467. addr = vm_mmap(obj->filp, 0, args->size,
  468. PROT_READ | PROT_WRITE, MAP_SHARED, 0);
  469. drm_gem_object_unreference_unlocked(obj);
  470. if (IS_ERR((void *)addr))
  471. return PTR_ERR((void *)addr);
  472. args->mapped = addr;
  473. DRM_DEBUG_KMS("mapped = 0x%lx\n", (unsigned long)args->mapped);
  474. return 0;
  475. }
  476. int exynos_drm_gem_init_object(struct drm_gem_object *obj)
  477. {
  478. DRM_DEBUG_KMS("%s\n", __FILE__);
  479. return 0;
  480. }
  481. void exynos_drm_gem_free_object(struct drm_gem_object *obj)
  482. {
  483. DRM_DEBUG_KMS("%s\n", __FILE__);
  484. exynos_drm_gem_destroy(to_exynos_gem_obj(obj));
  485. }
  486. int exynos_drm_gem_dumb_create(struct drm_file *file_priv,
  487. struct drm_device *dev,
  488. struct drm_mode_create_dumb *args)
  489. {
  490. struct exynos_drm_gem_obj *exynos_gem_obj;
  491. int ret;
  492. DRM_DEBUG_KMS("%s\n", __FILE__);
  493. /*
  494. * alocate memory to be used for framebuffer.
  495. * - this callback would be called by user application
  496. * with DRM_IOCTL_MODE_CREATE_DUMB command.
  497. */
  498. args->pitch = args->width * args->bpp >> 3;
  499. args->size = PAGE_ALIGN(args->pitch * args->height);
  500. exynos_gem_obj = exynos_drm_gem_create(dev, args->flags, args->size);
  501. if (IS_ERR(exynos_gem_obj))
  502. return PTR_ERR(exynos_gem_obj);
  503. ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
  504. &args->handle);
  505. if (ret) {
  506. exynos_drm_gem_destroy(exynos_gem_obj);
  507. return ret;
  508. }
  509. return 0;
  510. }
  511. int exynos_drm_gem_dumb_map_offset(struct drm_file *file_priv,
  512. struct drm_device *dev, uint32_t handle,
  513. uint64_t *offset)
  514. {
  515. struct exynos_drm_gem_obj *exynos_gem_obj;
  516. struct drm_gem_object *obj;
  517. int ret = 0;
  518. DRM_DEBUG_KMS("%s\n", __FILE__);
  519. mutex_lock(&dev->struct_mutex);
  520. /*
  521. * get offset of memory allocated for drm framebuffer.
  522. * - this callback would be called by user application
  523. * with DRM_IOCTL_MODE_MAP_DUMB command.
  524. */
  525. obj = drm_gem_object_lookup(dev, file_priv, handle);
  526. if (!obj) {
  527. DRM_ERROR("failed to lookup gem object.\n");
  528. ret = -EINVAL;
  529. goto unlock;
  530. }
  531. exynos_gem_obj = to_exynos_gem_obj(obj);
  532. if (!exynos_gem_obj->base.map_list.map) {
  533. ret = drm_gem_create_mmap_offset(&exynos_gem_obj->base);
  534. if (ret)
  535. goto out;
  536. }
  537. *offset = (u64)exynos_gem_obj->base.map_list.hash.key << PAGE_SHIFT;
  538. DRM_DEBUG_KMS("offset = 0x%lx\n", (unsigned long)*offset);
  539. out:
  540. drm_gem_object_unreference(obj);
  541. unlock:
  542. mutex_unlock(&dev->struct_mutex);
  543. return ret;
  544. }
  545. int exynos_drm_gem_dumb_destroy(struct drm_file *file_priv,
  546. struct drm_device *dev,
  547. unsigned int handle)
  548. {
  549. int ret;
  550. DRM_DEBUG_KMS("%s\n", __FILE__);
  551. /*
  552. * obj->refcount and obj->handle_count are decreased and
  553. * if both them are 0 then exynos_drm_gem_free_object()
  554. * would be called by callback to release resources.
  555. */
  556. ret = drm_gem_handle_delete(file_priv, handle);
  557. if (ret < 0) {
  558. DRM_ERROR("failed to delete drm_gem_handle.\n");
  559. return ret;
  560. }
  561. return 0;
  562. }
  563. int exynos_drm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
  564. {
  565. struct drm_gem_object *obj = vma->vm_private_data;
  566. struct drm_device *dev = obj->dev;
  567. unsigned long f_vaddr;
  568. pgoff_t page_offset;
  569. int ret;
  570. page_offset = ((unsigned long)vmf->virtual_address -
  571. vma->vm_start) >> PAGE_SHIFT;
  572. f_vaddr = (unsigned long)vmf->virtual_address;
  573. mutex_lock(&dev->struct_mutex);
  574. ret = exynos_drm_gem_map_pages(obj, vma, f_vaddr, page_offset);
  575. if (ret < 0)
  576. DRM_ERROR("failed to map pages.\n");
  577. mutex_unlock(&dev->struct_mutex);
  578. return convert_to_vm_err_msg(ret);
  579. }
  580. int exynos_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
  581. {
  582. struct exynos_drm_gem_obj *exynos_gem_obj;
  583. struct drm_gem_object *obj;
  584. int ret;
  585. DRM_DEBUG_KMS("%s\n", __FILE__);
  586. /* set vm_area_struct. */
  587. ret = drm_gem_mmap(filp, vma);
  588. if (ret < 0) {
  589. DRM_ERROR("failed to mmap.\n");
  590. return ret;
  591. }
  592. obj = vma->vm_private_data;
  593. exynos_gem_obj = to_exynos_gem_obj(obj);
  594. ret = check_gem_flags(exynos_gem_obj->flags);
  595. if (ret) {
  596. drm_gem_vm_close(vma);
  597. drm_gem_free_mmap_offset(obj);
  598. return ret;
  599. }
  600. vma->vm_flags &= ~VM_PFNMAP;
  601. vma->vm_flags |= VM_MIXEDMAP;
  602. update_vm_cache_attr(exynos_gem_obj, vma);
  603. return ret;
  604. }