qxl_cmd.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658
  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. /* QXL cmd/ring handling */
  26. #include <linux/delay.h>
  27. #include <drm/drm_util.h>
  28. #include "qxl_drv.h"
  29. #include "qxl_object.h"
  30. static int qxl_reap_surface_id(struct qxl_device *qdev, int max_to_reap);
  31. struct ring {
  32. struct qxl_ring_header header;
  33. uint8_t elements[];
  34. };
  35. struct qxl_ring {
  36. struct ring *ring;
  37. int element_size;
  38. int n_elements;
  39. int prod_notify;
  40. wait_queue_head_t *push_event;
  41. spinlock_t lock;
  42. };
  43. void qxl_ring_free(struct qxl_ring *ring)
  44. {
  45. kfree(ring);
  46. }
  47. void qxl_ring_init_hdr(struct qxl_ring *ring)
  48. {
  49. ring->ring->header.notify_on_prod = ring->n_elements;
  50. }
  51. struct qxl_ring *
  52. qxl_ring_create(struct qxl_ring_header *header,
  53. int element_size,
  54. int n_elements,
  55. int prod_notify,
  56. bool set_prod_notify,
  57. wait_queue_head_t *push_event)
  58. {
  59. struct qxl_ring *ring;
  60. ring = kmalloc(sizeof(*ring), GFP_KERNEL);
  61. if (!ring)
  62. return NULL;
  63. ring->ring = (struct ring *)header;
  64. ring->element_size = element_size;
  65. ring->n_elements = n_elements;
  66. ring->prod_notify = prod_notify;
  67. ring->push_event = push_event;
  68. if (set_prod_notify)
  69. qxl_ring_init_hdr(ring);
  70. spin_lock_init(&ring->lock);
  71. return ring;
  72. }
  73. static int qxl_check_header(struct qxl_ring *ring)
  74. {
  75. int ret;
  76. struct qxl_ring_header *header = &(ring->ring->header);
  77. unsigned long flags;
  78. spin_lock_irqsave(&ring->lock, flags);
  79. ret = header->prod - header->cons < header->num_items;
  80. if (ret == 0)
  81. header->notify_on_cons = header->cons + 1;
  82. spin_unlock_irqrestore(&ring->lock, flags);
  83. return ret;
  84. }
  85. int qxl_check_idle(struct qxl_ring *ring)
  86. {
  87. int ret;
  88. struct qxl_ring_header *header = &(ring->ring->header);
  89. unsigned long flags;
  90. spin_lock_irqsave(&ring->lock, flags);
  91. ret = header->prod == header->cons;
  92. spin_unlock_irqrestore(&ring->lock, flags);
  93. return ret;
  94. }
  95. int qxl_ring_push(struct qxl_ring *ring,
  96. const void *new_elt, bool interruptible)
  97. {
  98. struct qxl_ring_header *header = &(ring->ring->header);
  99. uint8_t *elt;
  100. int idx, ret;
  101. unsigned long flags;
  102. spin_lock_irqsave(&ring->lock, flags);
  103. if (header->prod - header->cons == header->num_items) {
  104. header->notify_on_cons = header->cons + 1;
  105. mb();
  106. spin_unlock_irqrestore(&ring->lock, flags);
  107. if (!drm_can_sleep()) {
  108. while (!qxl_check_header(ring))
  109. udelay(1);
  110. } else {
  111. if (interruptible) {
  112. ret = wait_event_interruptible(*ring->push_event,
  113. qxl_check_header(ring));
  114. if (ret)
  115. return ret;
  116. } else {
  117. wait_event(*ring->push_event,
  118. qxl_check_header(ring));
  119. }
  120. }
  121. spin_lock_irqsave(&ring->lock, flags);
  122. }
  123. idx = header->prod & (ring->n_elements - 1);
  124. elt = ring->ring->elements + idx * ring->element_size;
  125. memcpy((void *)elt, new_elt, ring->element_size);
  126. header->prod++;
  127. mb();
  128. if (header->prod == header->notify_on_prod)
  129. outb(0, ring->prod_notify);
  130. spin_unlock_irqrestore(&ring->lock, flags);
  131. return 0;
  132. }
  133. static bool qxl_ring_pop(struct qxl_ring *ring,
  134. void *element)
  135. {
  136. volatile struct qxl_ring_header *header = &(ring->ring->header);
  137. volatile uint8_t *ring_elt;
  138. int idx;
  139. unsigned long flags;
  140. spin_lock_irqsave(&ring->lock, flags);
  141. if (header->cons == header->prod) {
  142. header->notify_on_prod = header->cons + 1;
  143. spin_unlock_irqrestore(&ring->lock, flags);
  144. return false;
  145. }
  146. idx = header->cons & (ring->n_elements - 1);
  147. ring_elt = ring->ring->elements + idx * ring->element_size;
  148. memcpy(element, (void *)ring_elt, ring->element_size);
  149. header->cons++;
  150. spin_unlock_irqrestore(&ring->lock, flags);
  151. return true;
  152. }
  153. int
  154. qxl_push_command_ring_release(struct qxl_device *qdev, struct qxl_release *release,
  155. uint32_t type, bool interruptible)
  156. {
  157. struct qxl_command cmd;
  158. cmd.type = type;
  159. cmd.data = qxl_bo_physical_address(qdev, release->release_bo, release->release_offset);
  160. return qxl_ring_push(qdev->command_ring, &cmd, interruptible);
  161. }
  162. int
  163. qxl_push_cursor_ring_release(struct qxl_device *qdev, struct qxl_release *release,
  164. uint32_t type, bool interruptible)
  165. {
  166. struct qxl_command cmd;
  167. cmd.type = type;
  168. cmd.data = qxl_bo_physical_address(qdev, release->release_bo, release->release_offset);
  169. return qxl_ring_push(qdev->cursor_ring, &cmd, interruptible);
  170. }
  171. bool qxl_queue_garbage_collect(struct qxl_device *qdev, bool flush)
  172. {
  173. if (!qxl_check_idle(qdev->release_ring)) {
  174. schedule_work(&qdev->gc_work);
  175. if (flush)
  176. flush_work(&qdev->gc_work);
  177. return true;
  178. }
  179. return false;
  180. }
  181. int qxl_garbage_collect(struct qxl_device *qdev)
  182. {
  183. struct qxl_release *release;
  184. uint64_t id, next_id;
  185. int i = 0;
  186. union qxl_release_info *info;
  187. while (qxl_ring_pop(qdev->release_ring, &id)) {
  188. DRM_DEBUG_DRIVER("popped %lld\n", id);
  189. while (id) {
  190. release = qxl_release_from_id_locked(qdev, id);
  191. if (release == NULL)
  192. break;
  193. info = qxl_release_map(qdev, release);
  194. next_id = info->next;
  195. qxl_release_unmap(qdev, release, info);
  196. DRM_DEBUG_DRIVER("popped %lld, next %lld\n", id,
  197. next_id);
  198. switch (release->type) {
  199. case QXL_RELEASE_DRAWABLE:
  200. case QXL_RELEASE_SURFACE_CMD:
  201. case QXL_RELEASE_CURSOR_CMD:
  202. break;
  203. default:
  204. DRM_ERROR("unexpected release type\n");
  205. break;
  206. }
  207. id = next_id;
  208. qxl_release_free(qdev, release);
  209. ++i;
  210. }
  211. }
  212. DRM_DEBUG_DRIVER("%d\n", i);
  213. return i;
  214. }
  215. int qxl_alloc_bo_reserved(struct qxl_device *qdev,
  216. struct qxl_release *release,
  217. unsigned long size,
  218. struct qxl_bo **_bo)
  219. {
  220. struct qxl_bo *bo;
  221. int ret;
  222. ret = qxl_bo_create(qdev, size, false /* not kernel - device */,
  223. false, QXL_GEM_DOMAIN_VRAM, 0, NULL, &bo);
  224. if (ret) {
  225. DRM_ERROR("failed to allocate VRAM BO\n");
  226. return ret;
  227. }
  228. ret = qxl_release_list_add(release, bo);
  229. if (ret)
  230. goto out_unref;
  231. *_bo = bo;
  232. return 0;
  233. out_unref:
  234. qxl_bo_unref(&bo);
  235. return ret;
  236. }
  237. static int wait_for_io_cmd_user(struct qxl_device *qdev, uint8_t val, long port, bool intr)
  238. {
  239. int irq_num;
  240. long addr = qdev->io_base + port;
  241. int ret;
  242. mutex_lock(&qdev->async_io_mutex);
  243. irq_num = atomic_read(&qdev->irq_received_io_cmd);
  244. if (qdev->last_sent_io_cmd > irq_num) {
  245. if (intr)
  246. ret = wait_event_interruptible_timeout(qdev->io_cmd_event,
  247. atomic_read(&qdev->irq_received_io_cmd) > irq_num, 5*HZ);
  248. else
  249. ret = wait_event_timeout(qdev->io_cmd_event,
  250. atomic_read(&qdev->irq_received_io_cmd) > irq_num, 5*HZ);
  251. /* 0 is timeout, just bail the "hw" has gone away */
  252. if (ret <= 0)
  253. goto out;
  254. irq_num = atomic_read(&qdev->irq_received_io_cmd);
  255. }
  256. outb(val, addr);
  257. qdev->last_sent_io_cmd = irq_num + 1;
  258. if (intr)
  259. ret = wait_event_interruptible_timeout(qdev->io_cmd_event,
  260. atomic_read(&qdev->irq_received_io_cmd) > irq_num, 5*HZ);
  261. else
  262. ret = wait_event_timeout(qdev->io_cmd_event,
  263. atomic_read(&qdev->irq_received_io_cmd) > irq_num, 5*HZ);
  264. out:
  265. if (ret > 0)
  266. ret = 0;
  267. mutex_unlock(&qdev->async_io_mutex);
  268. return ret;
  269. }
  270. static void wait_for_io_cmd(struct qxl_device *qdev, uint8_t val, long port)
  271. {
  272. int ret;
  273. restart:
  274. ret = wait_for_io_cmd_user(qdev, val, port, false);
  275. if (ret == -ERESTARTSYS)
  276. goto restart;
  277. }
  278. int qxl_io_update_area(struct qxl_device *qdev, struct qxl_bo *surf,
  279. const struct qxl_rect *area)
  280. {
  281. int surface_id;
  282. uint32_t surface_width, surface_height;
  283. int ret;
  284. if (!surf->hw_surf_alloc)
  285. DRM_ERROR("got io update area with no hw surface\n");
  286. if (surf->is_primary)
  287. surface_id = 0;
  288. else
  289. surface_id = surf->surface_id;
  290. surface_width = surf->surf.width;
  291. surface_height = surf->surf.height;
  292. if (area->left < 0 || area->top < 0 ||
  293. area->right > surface_width || area->bottom > surface_height)
  294. return -EINVAL;
  295. mutex_lock(&qdev->update_area_mutex);
  296. qdev->ram_header->update_area = *area;
  297. qdev->ram_header->update_surface = surface_id;
  298. ret = wait_for_io_cmd_user(qdev, 0, QXL_IO_UPDATE_AREA_ASYNC, true);
  299. mutex_unlock(&qdev->update_area_mutex);
  300. return ret;
  301. }
  302. void qxl_io_notify_oom(struct qxl_device *qdev)
  303. {
  304. outb(0, qdev->io_base + QXL_IO_NOTIFY_OOM);
  305. }
  306. void qxl_io_flush_release(struct qxl_device *qdev)
  307. {
  308. outb(0, qdev->io_base + QXL_IO_FLUSH_RELEASE);
  309. }
  310. void qxl_io_flush_surfaces(struct qxl_device *qdev)
  311. {
  312. wait_for_io_cmd(qdev, 0, QXL_IO_FLUSH_SURFACES_ASYNC);
  313. }
  314. void qxl_io_destroy_primary(struct qxl_device *qdev)
  315. {
  316. wait_for_io_cmd(qdev, 0, QXL_IO_DESTROY_PRIMARY_ASYNC);
  317. qdev->primary_bo->is_primary = false;
  318. drm_gem_object_put(&qdev->primary_bo->tbo.base);
  319. qdev->primary_bo = NULL;
  320. }
  321. void qxl_io_create_primary(struct qxl_device *qdev, struct qxl_bo *bo)
  322. {
  323. struct qxl_surface_create *create;
  324. if (WARN_ON(qdev->primary_bo))
  325. return;
  326. DRM_DEBUG_DRIVER("qdev %p, ram_header %p\n", qdev, qdev->ram_header);
  327. create = &qdev->ram_header->create_surface;
  328. create->format = bo->surf.format;
  329. create->width = bo->surf.width;
  330. create->height = bo->surf.height;
  331. create->stride = bo->surf.stride;
  332. create->mem = qxl_bo_physical_address(qdev, bo, 0);
  333. DRM_DEBUG_DRIVER("mem = %llx, from %p\n", create->mem, bo->kptr);
  334. create->flags = QXL_SURF_FLAG_KEEP_DATA;
  335. create->type = QXL_SURF_TYPE_PRIMARY;
  336. wait_for_io_cmd(qdev, 0, QXL_IO_CREATE_PRIMARY_ASYNC);
  337. qdev->primary_bo = bo;
  338. qdev->primary_bo->is_primary = true;
  339. drm_gem_object_get(&qdev->primary_bo->tbo.base);
  340. }
  341. void qxl_io_memslot_add(struct qxl_device *qdev, uint8_t id)
  342. {
  343. DRM_DEBUG_DRIVER("qxl_memslot_add %d\n", id);
  344. wait_for_io_cmd(qdev, id, QXL_IO_MEMSLOT_ADD_ASYNC);
  345. }
  346. void qxl_io_reset(struct qxl_device *qdev)
  347. {
  348. outb(0, qdev->io_base + QXL_IO_RESET);
  349. }
  350. void qxl_io_monitors_config(struct qxl_device *qdev)
  351. {
  352. wait_for_io_cmd(qdev, 0, QXL_IO_MONITORS_CONFIG_ASYNC);
  353. }
  354. int qxl_surface_id_alloc(struct qxl_device *qdev,
  355. struct qxl_bo *surf)
  356. {
  357. uint32_t handle;
  358. int idr_ret;
  359. int count = 0;
  360. again:
  361. idr_preload(GFP_ATOMIC);
  362. spin_lock(&qdev->surf_id_idr_lock);
  363. idr_ret = idr_alloc(&qdev->surf_id_idr, NULL, 1, 0, GFP_NOWAIT);
  364. spin_unlock(&qdev->surf_id_idr_lock);
  365. idr_preload_end();
  366. if (idr_ret < 0)
  367. return idr_ret;
  368. handle = idr_ret;
  369. if (handle >= qdev->rom->n_surfaces) {
  370. count++;
  371. spin_lock(&qdev->surf_id_idr_lock);
  372. idr_remove(&qdev->surf_id_idr, handle);
  373. spin_unlock(&qdev->surf_id_idr_lock);
  374. qxl_reap_surface_id(qdev, 2);
  375. goto again;
  376. }
  377. surf->surface_id = handle;
  378. spin_lock(&qdev->surf_id_idr_lock);
  379. qdev->last_alloced_surf_id = handle;
  380. spin_unlock(&qdev->surf_id_idr_lock);
  381. return 0;
  382. }
  383. void qxl_surface_id_dealloc(struct qxl_device *qdev,
  384. uint32_t surface_id)
  385. {
  386. spin_lock(&qdev->surf_id_idr_lock);
  387. idr_remove(&qdev->surf_id_idr, surface_id);
  388. spin_unlock(&qdev->surf_id_idr_lock);
  389. }
  390. int qxl_hw_surface_alloc(struct qxl_device *qdev,
  391. struct qxl_bo *surf)
  392. {
  393. struct qxl_surface_cmd *cmd;
  394. struct qxl_release *release;
  395. int ret;
  396. if (surf->hw_surf_alloc)
  397. return 0;
  398. ret = qxl_alloc_surface_release_reserved(qdev, QXL_SURFACE_CMD_CREATE,
  399. NULL,
  400. &release);
  401. if (ret)
  402. return ret;
  403. ret = qxl_release_reserve_list(release, true);
  404. if (ret) {
  405. qxl_release_free(qdev, release);
  406. return ret;
  407. }
  408. cmd = (struct qxl_surface_cmd *)qxl_release_map(qdev, release);
  409. cmd->type = QXL_SURFACE_CMD_CREATE;
  410. cmd->flags = QXL_SURF_FLAG_KEEP_DATA;
  411. cmd->u.surface_create.format = surf->surf.format;
  412. cmd->u.surface_create.width = surf->surf.width;
  413. cmd->u.surface_create.height = surf->surf.height;
  414. cmd->u.surface_create.stride = surf->surf.stride;
  415. cmd->u.surface_create.data = qxl_bo_physical_address(qdev, surf, 0);
  416. cmd->surface_id = surf->surface_id;
  417. qxl_release_unmap(qdev, release, &cmd->release_info);
  418. surf->surf_create = release;
  419. /* no need to add a release to the fence for this surface bo,
  420. since it is only released when we ask to destroy the surface
  421. and it would never signal otherwise */
  422. qxl_release_fence_buffer_objects(release);
  423. qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false);
  424. surf->hw_surf_alloc = true;
  425. spin_lock(&qdev->surf_id_idr_lock);
  426. idr_replace(&qdev->surf_id_idr, surf, surf->surface_id);
  427. spin_unlock(&qdev->surf_id_idr_lock);
  428. return 0;
  429. }
  430. int qxl_hw_surface_dealloc(struct qxl_device *qdev,
  431. struct qxl_bo *surf)
  432. {
  433. struct qxl_surface_cmd *cmd;
  434. struct qxl_release *release;
  435. int ret;
  436. int id;
  437. if (!surf->hw_surf_alloc)
  438. return 0;
  439. ret = qxl_alloc_surface_release_reserved(qdev, QXL_SURFACE_CMD_DESTROY,
  440. surf->surf_create,
  441. &release);
  442. if (ret)
  443. return ret;
  444. surf->surf_create = NULL;
  445. /* remove the surface from the idr, but not the surface id yet */
  446. spin_lock(&qdev->surf_id_idr_lock);
  447. idr_replace(&qdev->surf_id_idr, NULL, surf->surface_id);
  448. spin_unlock(&qdev->surf_id_idr_lock);
  449. surf->hw_surf_alloc = false;
  450. id = surf->surface_id;
  451. surf->surface_id = 0;
  452. release->surface_release_id = id;
  453. cmd = (struct qxl_surface_cmd *)qxl_release_map(qdev, release);
  454. cmd->type = QXL_SURFACE_CMD_DESTROY;
  455. cmd->surface_id = id;
  456. qxl_release_unmap(qdev, release, &cmd->release_info);
  457. qxl_release_fence_buffer_objects(release);
  458. qxl_push_command_ring_release(qdev, release, QXL_CMD_SURFACE, false);
  459. return 0;
  460. }
  461. static int qxl_update_surface(struct qxl_device *qdev, struct qxl_bo *surf)
  462. {
  463. struct qxl_rect rect;
  464. int ret;
  465. /* if we are evicting, we need to make sure the surface is up
  466. to date */
  467. rect.left = 0;
  468. rect.right = surf->surf.width;
  469. rect.top = 0;
  470. rect.bottom = surf->surf.height;
  471. retry:
  472. ret = qxl_io_update_area(qdev, surf, &rect);
  473. if (ret == -ERESTARTSYS)
  474. goto retry;
  475. return ret;
  476. }
  477. static void qxl_surface_evict_locked(struct qxl_device *qdev, struct qxl_bo *surf, bool do_update_area)
  478. {
  479. /* no need to update area if we are just freeing the surface normally */
  480. if (do_update_area)
  481. qxl_update_surface(qdev, surf);
  482. /* nuke the surface id at the hw */
  483. qxl_hw_surface_dealloc(qdev, surf);
  484. }
  485. void qxl_surface_evict(struct qxl_device *qdev, struct qxl_bo *surf, bool do_update_area)
  486. {
  487. mutex_lock(&qdev->surf_evict_mutex);
  488. qxl_surface_evict_locked(qdev, surf, do_update_area);
  489. mutex_unlock(&qdev->surf_evict_mutex);
  490. }
  491. static int qxl_reap_surf(struct qxl_device *qdev, struct qxl_bo *surf, bool stall)
  492. {
  493. int ret;
  494. ret = qxl_bo_reserve(surf);
  495. if (ret)
  496. return ret;
  497. if (stall)
  498. mutex_unlock(&qdev->surf_evict_mutex);
  499. ret = ttm_bo_wait(&surf->tbo, true, !stall);
  500. if (stall)
  501. mutex_lock(&qdev->surf_evict_mutex);
  502. if (ret) {
  503. qxl_bo_unreserve(surf);
  504. return ret;
  505. }
  506. qxl_surface_evict_locked(qdev, surf, true);
  507. qxl_bo_unreserve(surf);
  508. return 0;
  509. }
  510. static int qxl_reap_surface_id(struct qxl_device *qdev, int max_to_reap)
  511. {
  512. int num_reaped = 0;
  513. int i, ret;
  514. bool stall = false;
  515. int start = 0;
  516. mutex_lock(&qdev->surf_evict_mutex);
  517. again:
  518. spin_lock(&qdev->surf_id_idr_lock);
  519. start = qdev->last_alloced_surf_id + 1;
  520. spin_unlock(&qdev->surf_id_idr_lock);
  521. for (i = start; i < start + qdev->rom->n_surfaces; i++) {
  522. void *objptr;
  523. int surfid = i % qdev->rom->n_surfaces;
  524. /* this avoids the case where the objects is in the
  525. idr but has been evicted half way - its makes
  526. the idr lookup atomic with the eviction */
  527. spin_lock(&qdev->surf_id_idr_lock);
  528. objptr = idr_find(&qdev->surf_id_idr, surfid);
  529. spin_unlock(&qdev->surf_id_idr_lock);
  530. if (!objptr)
  531. continue;
  532. ret = qxl_reap_surf(qdev, objptr, stall);
  533. if (ret == 0)
  534. num_reaped++;
  535. if (num_reaped >= max_to_reap)
  536. break;
  537. }
  538. if (num_reaped == 0 && stall == false) {
  539. stall = true;
  540. goto again;
  541. }
  542. mutex_unlock(&qdev->surf_evict_mutex);
  543. if (num_reaped) {
  544. usleep_range(500, 1000);
  545. qxl_queue_garbage_collect(qdev, true);
  546. }
  547. return 0;
  548. }