qxl_object.c 8.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326
  1. /*
  2. * Copyright 2013 Red Hat Inc.
  3. *
  4. * Permission is hereby granted, free of charge, to any person obtaining a
  5. * copy of this software and associated documentation files (the "Software"),
  6. * to deal in the Software without restriction, including without limitation
  7. * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8. * and/or sell copies of the Software, and to permit persons to whom the
  9. * Software is furnished to do so, subject to the following conditions:
  10. *
  11. * The above copyright notice and this permission notice shall be included in
  12. * all copies or substantial portions of the Software.
  13. *
  14. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  17. * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18. * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19. * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20. * OTHER DEALINGS IN THE SOFTWARE.
  21. *
  22. * Authors: Dave Airlie
  23. * Alon Levy
  24. */
  25. #include "qxl_drv.h"
  26. #include "qxl_object.h"
  27. #include <linux/io-mapping.h>
  28. static void qxl_ttm_bo_destroy(struct ttm_buffer_object *tbo)
  29. {
  30. struct qxl_bo *bo;
  31. struct qxl_device *qdev;
  32. bo = container_of(tbo, struct qxl_bo, tbo);
  33. qdev = (struct qxl_device *)bo->gem_base.dev->dev_private;
  34. qxl_surface_evict(qdev, bo, false);
  35. qxl_fence_fini(&bo->fence);
  36. mutex_lock(&qdev->gem.mutex);
  37. list_del_init(&bo->list);
  38. mutex_unlock(&qdev->gem.mutex);
  39. drm_gem_object_release(&bo->gem_base);
  40. kfree(bo);
  41. }
  42. bool qxl_ttm_bo_is_qxl_bo(struct ttm_buffer_object *bo)
  43. {
  44. if (bo->destroy == &qxl_ttm_bo_destroy)
  45. return true;
  46. return false;
  47. }
  48. void qxl_ttm_placement_from_domain(struct qxl_bo *qbo, u32 domain, bool pinned)
  49. {
  50. u32 c = 0;
  51. u32 pflag = pinned ? TTM_PL_FLAG_NO_EVICT : 0;
  52. qbo->placement.fpfn = 0;
  53. qbo->placement.lpfn = 0;
  54. qbo->placement.placement = qbo->placements;
  55. qbo->placement.busy_placement = qbo->placements;
  56. if (domain == QXL_GEM_DOMAIN_VRAM)
  57. qbo->placements[c++] = TTM_PL_FLAG_CACHED | TTM_PL_FLAG_VRAM | pflag;
  58. if (domain == QXL_GEM_DOMAIN_SURFACE)
  59. qbo->placements[c++] = TTM_PL_FLAG_CACHED | TTM_PL_FLAG_PRIV0 | pflag;
  60. if (domain == QXL_GEM_DOMAIN_CPU)
  61. qbo->placements[c++] = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM | pflag;
  62. if (!c)
  63. qbo->placements[c++] = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM;
  64. qbo->placement.num_placement = c;
  65. qbo->placement.num_busy_placement = c;
  66. }
  67. int qxl_bo_create(struct qxl_device *qdev,
  68. unsigned long size, bool kernel, bool pinned, u32 domain,
  69. struct qxl_surface *surf,
  70. struct qxl_bo **bo_ptr)
  71. {
  72. struct qxl_bo *bo;
  73. enum ttm_bo_type type;
  74. int r;
  75. if (unlikely(qdev->mman.bdev.dev_mapping == NULL))
  76. qdev->mman.bdev.dev_mapping = qdev->ddev->dev_mapping;
  77. if (kernel)
  78. type = ttm_bo_type_kernel;
  79. else
  80. type = ttm_bo_type_device;
  81. *bo_ptr = NULL;
  82. bo = kzalloc(sizeof(struct qxl_bo), GFP_KERNEL);
  83. if (bo == NULL)
  84. return -ENOMEM;
  85. size = roundup(size, PAGE_SIZE);
  86. r = drm_gem_object_init(qdev->ddev, &bo->gem_base, size);
  87. if (unlikely(r)) {
  88. kfree(bo);
  89. return r;
  90. }
  91. bo->type = domain;
  92. bo->pin_count = pinned ? 1 : 0;
  93. bo->surface_id = 0;
  94. qxl_fence_init(qdev, &bo->fence);
  95. INIT_LIST_HEAD(&bo->list);
  96. if (surf)
  97. bo->surf = *surf;
  98. qxl_ttm_placement_from_domain(bo, domain, pinned);
  99. r = ttm_bo_init(&qdev->mman.bdev, &bo->tbo, size, type,
  100. &bo->placement, 0, !kernel, NULL, size,
  101. NULL, &qxl_ttm_bo_destroy);
  102. if (unlikely(r != 0)) {
  103. if (r != -ERESTARTSYS)
  104. dev_err(qdev->dev,
  105. "object_init failed for (%lu, 0x%08X)\n",
  106. size, domain);
  107. return r;
  108. }
  109. *bo_ptr = bo;
  110. return 0;
  111. }
  112. int qxl_bo_kmap(struct qxl_bo *bo, void **ptr)
  113. {
  114. bool is_iomem;
  115. int r;
  116. if (bo->kptr) {
  117. if (ptr)
  118. *ptr = bo->kptr;
  119. return 0;
  120. }
  121. r = ttm_bo_kmap(&bo->tbo, 0, bo->tbo.num_pages, &bo->kmap);
  122. if (r)
  123. return r;
  124. bo->kptr = ttm_kmap_obj_virtual(&bo->kmap, &is_iomem);
  125. if (ptr)
  126. *ptr = bo->kptr;
  127. return 0;
  128. }
  129. void *qxl_bo_kmap_atomic_page(struct qxl_device *qdev,
  130. struct qxl_bo *bo, int page_offset)
  131. {
  132. struct ttm_mem_type_manager *man = &bo->tbo.bdev->man[bo->tbo.mem.mem_type];
  133. void *rptr;
  134. int ret;
  135. struct io_mapping *map;
  136. if (bo->tbo.mem.mem_type == TTM_PL_VRAM)
  137. map = qdev->vram_mapping;
  138. else if (bo->tbo.mem.mem_type == TTM_PL_PRIV0)
  139. map = qdev->surface_mapping;
  140. else
  141. goto fallback;
  142. (void) ttm_mem_io_lock(man, false);
  143. ret = ttm_mem_io_reserve(bo->tbo.bdev, &bo->tbo.mem);
  144. ttm_mem_io_unlock(man);
  145. return io_mapping_map_atomic_wc(map, bo->tbo.mem.bus.offset + page_offset);
  146. fallback:
  147. if (bo->kptr) {
  148. rptr = bo->kptr + (page_offset * PAGE_SIZE);
  149. return rptr;
  150. }
  151. ret = qxl_bo_kmap(bo, &rptr);
  152. if (ret)
  153. return NULL;
  154. rptr += page_offset * PAGE_SIZE;
  155. return rptr;
  156. }
  157. void qxl_bo_kunmap(struct qxl_bo *bo)
  158. {
  159. if (bo->kptr == NULL)
  160. return;
  161. bo->kptr = NULL;
  162. ttm_bo_kunmap(&bo->kmap);
  163. }
  164. void qxl_bo_kunmap_atomic_page(struct qxl_device *qdev,
  165. struct qxl_bo *bo, void *pmap)
  166. {
  167. struct ttm_mem_type_manager *man = &bo->tbo.bdev->man[bo->tbo.mem.mem_type];
  168. struct io_mapping *map;
  169. if (bo->tbo.mem.mem_type == TTM_PL_VRAM)
  170. map = qdev->vram_mapping;
  171. else if (bo->tbo.mem.mem_type == TTM_PL_PRIV0)
  172. map = qdev->surface_mapping;
  173. else
  174. goto fallback;
  175. io_mapping_unmap_atomic(pmap);
  176. (void) ttm_mem_io_lock(man, false);
  177. ttm_mem_io_free(bo->tbo.bdev, &bo->tbo.mem);
  178. ttm_mem_io_unlock(man);
  179. return ;
  180. fallback:
  181. qxl_bo_kunmap(bo);
  182. }
  183. void qxl_bo_unref(struct qxl_bo **bo)
  184. {
  185. struct ttm_buffer_object *tbo;
  186. if ((*bo) == NULL)
  187. return;
  188. tbo = &((*bo)->tbo);
  189. ttm_bo_unref(&tbo);
  190. if (tbo == NULL)
  191. *bo = NULL;
  192. }
  193. struct qxl_bo *qxl_bo_ref(struct qxl_bo *bo)
  194. {
  195. ttm_bo_reference(&bo->tbo);
  196. return bo;
  197. }
  198. int qxl_bo_pin(struct qxl_bo *bo, u32 domain, u64 *gpu_addr)
  199. {
  200. struct qxl_device *qdev = (struct qxl_device *)bo->gem_base.dev->dev_private;
  201. int r;
  202. if (bo->pin_count) {
  203. bo->pin_count++;
  204. if (gpu_addr)
  205. *gpu_addr = qxl_bo_gpu_offset(bo);
  206. return 0;
  207. }
  208. qxl_ttm_placement_from_domain(bo, domain, true);
  209. r = ttm_bo_validate(&bo->tbo, &bo->placement, false, false);
  210. if (likely(r == 0)) {
  211. bo->pin_count = 1;
  212. if (gpu_addr != NULL)
  213. *gpu_addr = qxl_bo_gpu_offset(bo);
  214. }
  215. if (unlikely(r != 0))
  216. dev_err(qdev->dev, "%p pin failed\n", bo);
  217. return r;
  218. }
  219. int qxl_bo_unpin(struct qxl_bo *bo)
  220. {
  221. struct qxl_device *qdev = (struct qxl_device *)bo->gem_base.dev->dev_private;
  222. int r, i;
  223. if (!bo->pin_count) {
  224. dev_warn(qdev->dev, "%p unpin not necessary\n", bo);
  225. return 0;
  226. }
  227. bo->pin_count--;
  228. if (bo->pin_count)
  229. return 0;
  230. for (i = 0; i < bo->placement.num_placement; i++)
  231. bo->placements[i] &= ~TTM_PL_FLAG_NO_EVICT;
  232. r = ttm_bo_validate(&bo->tbo, &bo->placement, false, false);
  233. if (unlikely(r != 0))
  234. dev_err(qdev->dev, "%p validate failed for unpin\n", bo);
  235. return r;
  236. }
  237. void qxl_bo_force_delete(struct qxl_device *qdev)
  238. {
  239. struct qxl_bo *bo, *n;
  240. if (list_empty(&qdev->gem.objects))
  241. return;
  242. dev_err(qdev->dev, "Userspace still has active objects !\n");
  243. list_for_each_entry_safe(bo, n, &qdev->gem.objects, list) {
  244. mutex_lock(&qdev->ddev->struct_mutex);
  245. dev_err(qdev->dev, "%p %p %lu %lu force free\n",
  246. &bo->gem_base, bo, (unsigned long)bo->gem_base.size,
  247. *((unsigned long *)&bo->gem_base.refcount));
  248. mutex_lock(&qdev->gem.mutex);
  249. list_del_init(&bo->list);
  250. mutex_unlock(&qdev->gem.mutex);
  251. /* this should unref the ttm bo */
  252. drm_gem_object_unreference(&bo->gem_base);
  253. mutex_unlock(&qdev->ddev->struct_mutex);
  254. }
  255. }
  256. int qxl_bo_init(struct qxl_device *qdev)
  257. {
  258. return qxl_ttm_init(qdev);
  259. }
  260. void qxl_bo_fini(struct qxl_device *qdev)
  261. {
  262. qxl_ttm_fini(qdev);
  263. }
  264. int qxl_bo_check_id(struct qxl_device *qdev, struct qxl_bo *bo)
  265. {
  266. int ret;
  267. if (bo->type == QXL_GEM_DOMAIN_SURFACE && bo->surface_id == 0) {
  268. /* allocate a surface id for this surface now */
  269. ret = qxl_surface_id_alloc(qdev, bo);
  270. if (ret)
  271. return ret;
  272. ret = qxl_hw_surface_alloc(qdev, bo, NULL);
  273. if (ret)
  274. return ret;
  275. }
  276. return 0;
  277. }
  278. int qxl_surf_evict(struct qxl_device *qdev)
  279. {
  280. return ttm_bo_evict_mm(&qdev->mman.bdev, TTM_PL_PRIV0);
  281. }
  282. int qxl_vram_evict(struct qxl_device *qdev)
  283. {
  284. return ttm_bo_evict_mm(&qdev->mman.bdev, TTM_PL_VRAM);
  285. }