blob: 34d0bc59621342521ef9cfe4b81f109932fffd9d [file] [log] [blame]
Ben Skeggs6ee73862009-12-11 19:24:15 +10001/*
2 * Copyright (C) 2008 Ben Skeggs.
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial
15 * portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
21 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 *
25 */
Dave Airlie22b33e82012-04-02 11:53:06 +010026#include <linux/dma-buf.h>
Ben Skeggs6ee73862009-12-11 19:24:15 +100027#include "drmP.h"
28#include "drm.h"
29
30#include "nouveau_drv.h"
31#include "nouveau_drm.h"
32#include "nouveau_dma.h"
Ben Skeggsd375e7d52012-04-30 13:30:00 +100033#include "nouveau_fence.h"
Ben Skeggs6ee73862009-12-11 19:24:15 +100034
35#define nouveau_gem_pushbuf_sync(chan) 0
36
37int
38nouveau_gem_object_new(struct drm_gem_object *gem)
39{
40 return 0;
41}
42
43void
44nouveau_gem_object_del(struct drm_gem_object *gem)
45{
46 struct nouveau_bo *nvbo = gem->driver_private;
47 struct ttm_buffer_object *bo = &nvbo->bo;
48
49 if (!nvbo)
50 return;
51 nvbo->gem = NULL;
52
Ben Skeggs6ee73862009-12-11 19:24:15 +100053 if (unlikely(nvbo->pin_refcnt)) {
54 nvbo->pin_refcnt = 1;
55 nouveau_bo_unpin(nvbo);
56 }
57
Dave Airlie22b33e82012-04-02 11:53:06 +010058 if (gem->import_attach)
59 drm_prime_gem_destroy(gem, nvbo->bo.sg);
60
Ben Skeggs6ee73862009-12-11 19:24:15 +100061 ttm_bo_unref(&bo);
Daniel Vetterfd632aa2010-04-09 19:05:05 +000062
63 drm_gem_object_release(gem);
64 kfree(gem);
Ben Skeggs6ee73862009-12-11 19:24:15 +100065}
66
67int
Ben Skeggs639212d2011-06-03 16:18:26 +100068nouveau_gem_object_open(struct drm_gem_object *gem, struct drm_file *file_priv)
69{
70 struct nouveau_fpriv *fpriv = nouveau_fpriv(file_priv);
Ben Skeggs2fd3db62011-06-07 15:25:12 +100071 struct nouveau_bo *nvbo = nouveau_gem_object(gem);
72 struct nouveau_vma *vma;
73 int ret;
Ben Skeggs639212d2011-06-03 16:18:26 +100074
75 if (!fpriv->vm)
76 return 0;
77
Ben Skeggs2fd3db62011-06-07 15:25:12 +100078 ret = ttm_bo_reserve(&nvbo->bo, false, false, false, 0);
79 if (ret)
80 return ret;
81
82 vma = nouveau_bo_vma_find(nvbo, fpriv->vm);
83 if (!vma) {
84 vma = kzalloc(sizeof(*vma), GFP_KERNEL);
85 if (!vma) {
86 ret = -ENOMEM;
87 goto out;
88 }
89
90 ret = nouveau_bo_vma_add(nvbo, fpriv->vm, vma);
91 if (ret) {
92 kfree(vma);
93 goto out;
94 }
95 } else {
96 vma->refcount++;
97 }
98
99out:
100 ttm_bo_unreserve(&nvbo->bo);
101 return ret;
Ben Skeggs639212d2011-06-03 16:18:26 +1000102}
103
104void
105nouveau_gem_object_close(struct drm_gem_object *gem, struct drm_file *file_priv)
106{
107 struct nouveau_fpriv *fpriv = nouveau_fpriv(file_priv);
Ben Skeggs2fd3db62011-06-07 15:25:12 +1000108 struct nouveau_bo *nvbo = nouveau_gem_object(gem);
109 struct nouveau_vma *vma;
110 int ret;
Ben Skeggs639212d2011-06-03 16:18:26 +1000111
112 if (!fpriv->vm)
113 return;
Ben Skeggs2fd3db62011-06-07 15:25:12 +1000114
115 ret = ttm_bo_reserve(&nvbo->bo, false, false, false, 0);
116 if (ret)
117 return;
118
119 vma = nouveau_bo_vma_find(nvbo, fpriv->vm);
120 if (vma) {
Marcin Slusarz8fe198b2011-06-23 16:34:30 +0200121 if (--vma->refcount == 0) {
Ben Skeggs2fd3db62011-06-07 15:25:12 +1000122 nouveau_bo_vma_del(nvbo, vma);
Marcin Slusarz8fe198b2011-06-23 16:34:30 +0200123 kfree(vma);
124 }
Ben Skeggs2fd3db62011-06-07 15:25:12 +1000125 }
126 ttm_bo_unreserve(&nvbo->bo);
Ben Skeggs639212d2011-06-03 16:18:26 +1000127}
128
129int
Ben Skeggsf6d4e622011-06-07 12:25:36 +1000130nouveau_gem_new(struct drm_device *dev, int size, int align, uint32_t domain,
131 uint32_t tile_mode, uint32_t tile_flags,
132 struct nouveau_bo **pnvbo)
Ben Skeggs6ee73862009-12-11 19:24:15 +1000133{
Ben Skeggsdb5c8e22011-02-10 13:41:01 +1000134 struct drm_nouveau_private *dev_priv = dev->dev_private;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000135 struct nouveau_bo *nvbo;
Ben Skeggs6ba9a682011-02-10 14:42:08 +1000136 u32 flags = 0;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000137 int ret;
138
Ben Skeggs6ba9a682011-02-10 14:42:08 +1000139 if (domain & NOUVEAU_GEM_DOMAIN_VRAM)
140 flags |= TTM_PL_FLAG_VRAM;
141 if (domain & NOUVEAU_GEM_DOMAIN_GART)
142 flags |= TTM_PL_FLAG_TT;
143 if (!flags || domain & NOUVEAU_GEM_DOMAIN_CPU)
144 flags |= TTM_PL_FLAG_SYSTEM;
145
Ben Skeggs7375c952011-06-07 14:21:29 +1000146 ret = nouveau_bo_new(dev, size, align, flags, tile_mode,
Dave Airlie22b33e82012-04-02 11:53:06 +0100147 tile_flags, NULL, pnvbo);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000148 if (ret)
149 return ret;
150 nvbo = *pnvbo;
151
Ben Skeggsdb5c8e22011-02-10 13:41:01 +1000152 /* we restrict allowed domains on nv50+ to only the types
153 * that were requested at creation time. not possibly on
154 * earlier chips without busting the ABI.
155 */
156 nvbo->valid_domains = NOUVEAU_GEM_DOMAIN_VRAM |
157 NOUVEAU_GEM_DOMAIN_GART;
158 if (dev_priv->card_type >= NV_50)
159 nvbo->valid_domains &= domain;
160
Ben Skeggs6ee73862009-12-11 19:24:15 +1000161 nvbo->gem = drm_gem_object_alloc(dev, nvbo->bo.mem.size);
162 if (!nvbo->gem) {
163 nouveau_bo_ref(NULL, pnvbo);
164 return -ENOMEM;
165 }
166
Jan Engelhardt5df23972011-04-04 01:25:18 +0200167 nvbo->bo.persistent_swap_storage = nvbo->gem->filp;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000168 nvbo->gem->driver_private = nvbo;
169 return 0;
170}
171
172static int
Ben Skeggse758a312011-06-07 13:28:11 +1000173nouveau_gem_info(struct drm_file *file_priv, struct drm_gem_object *gem,
174 struct drm_nouveau_gem_info *rep)
Ben Skeggs6ee73862009-12-11 19:24:15 +1000175{
Ben Skeggse758a312011-06-07 13:28:11 +1000176 struct nouveau_fpriv *fpriv = nouveau_fpriv(file_priv);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000177 struct nouveau_bo *nvbo = nouveau_gem_object(gem);
Ben Skeggse758a312011-06-07 13:28:11 +1000178 struct nouveau_vma *vma;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000179
180 if (nvbo->bo.mem.mem_type == TTM_PL_TT)
181 rep->domain = NOUVEAU_GEM_DOMAIN_GART;
182 else
183 rep->domain = NOUVEAU_GEM_DOMAIN_VRAM;
184
Ben Skeggse758a312011-06-07 13:28:11 +1000185 rep->offset = nvbo->bo.offset;
186 if (fpriv->vm) {
187 vma = nouveau_bo_vma_find(nvbo, fpriv->vm);
188 if (!vma)
189 return -EINVAL;
190
191 rep->offset = vma->offset;
192 }
193
Ben Skeggs6ee73862009-12-11 19:24:15 +1000194 rep->size = nvbo->bo.mem.num_pages << PAGE_SHIFT;
Ben Skeggsd550c412011-02-16 08:41:56 +1000195 rep->map_handle = nvbo->bo.addr_space_offset;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000196 rep->tile_mode = nvbo->tile_mode;
197 rep->tile_flags = nvbo->tile_flags;
198 return 0;
199}
200
Ben Skeggs6ee73862009-12-11 19:24:15 +1000201int
202nouveau_gem_ioctl_new(struct drm_device *dev, void *data,
203 struct drm_file *file_priv)
204{
205 struct drm_nouveau_private *dev_priv = dev->dev_private;
206 struct drm_nouveau_gem_new *req = data;
207 struct nouveau_bo *nvbo = NULL;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000208 int ret = 0;
209
Ben Skeggs6ee73862009-12-11 19:24:15 +1000210 if (unlikely(dev_priv->ttm.bdev.dev_mapping == NULL))
211 dev_priv->ttm.bdev.dev_mapping = dev_priv->dev->dev_mapping;
212
Ben Skeggs60d2a882010-12-06 15:28:54 +1000213 if (!dev_priv->engine.vram.flags_valid(dev, req->info.tile_flags)) {
214 NV_ERROR(dev, "bad page flags: 0x%08x\n", req->info.tile_flags);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000215 return -EINVAL;
Ben Skeggs60d2a882010-12-06 15:28:54 +1000216 }
Ben Skeggs6ee73862009-12-11 19:24:15 +1000217
Ben Skeggsf6d4e622011-06-07 12:25:36 +1000218 ret = nouveau_gem_new(dev, req->info.size, req->align,
Ben Skeggs6ba9a682011-02-10 14:42:08 +1000219 req->info.domain, req->info.tile_mode,
220 req->info.tile_flags, &nvbo);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000221 if (ret)
222 return ret;
223
Ben Skeggs6ee73862009-12-11 19:24:15 +1000224 ret = drm_gem_handle_create(file_priv, nvbo->gem, &req->info.handle);
Ben Skeggse758a312011-06-07 13:28:11 +1000225 if (ret == 0) {
226 ret = nouveau_gem_info(file_priv, nvbo->gem, &req->info);
227 if (ret)
228 drm_gem_handle_delete(file_priv, req->info.handle);
229 }
230
Dave Airlie29d08b32010-09-27 16:17:17 +1000231 /* drop reference from allocate - handle holds it now */
232 drm_gem_object_unreference_unlocked(nvbo->gem);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000233 return ret;
234}
235
236static int
237nouveau_gem_set_domain(struct drm_gem_object *gem, uint32_t read_domains,
238 uint32_t write_domains, uint32_t valid_domains)
239{
240 struct nouveau_bo *nvbo = gem->driver_private;
241 struct ttm_buffer_object *bo = &nvbo->bo;
Ben Skeggsdb5c8e22011-02-10 13:41:01 +1000242 uint32_t domains = valid_domains & nvbo->valid_domains &
Francisco Jerez78ad0f72010-03-18 13:07:47 +0100243 (write_domains ? write_domains : read_domains);
244 uint32_t pref_flags = 0, valid_flags = 0;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000245
Francisco Jerez78ad0f72010-03-18 13:07:47 +0100246 if (!domains)
Ben Skeggs6ee73862009-12-11 19:24:15 +1000247 return -EINVAL;
248
Francisco Jerez78ad0f72010-03-18 13:07:47 +0100249 if (valid_domains & NOUVEAU_GEM_DOMAIN_VRAM)
250 valid_flags |= TTM_PL_FLAG_VRAM;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000251
Francisco Jerez78ad0f72010-03-18 13:07:47 +0100252 if (valid_domains & NOUVEAU_GEM_DOMAIN_GART)
253 valid_flags |= TTM_PL_FLAG_TT;
254
255 if ((domains & NOUVEAU_GEM_DOMAIN_VRAM) &&
256 bo->mem.mem_type == TTM_PL_VRAM)
257 pref_flags |= TTM_PL_FLAG_VRAM;
258
259 else if ((domains & NOUVEAU_GEM_DOMAIN_GART) &&
260 bo->mem.mem_type == TTM_PL_TT)
261 pref_flags |= TTM_PL_FLAG_TT;
262
263 else if (domains & NOUVEAU_GEM_DOMAIN_VRAM)
264 pref_flags |= TTM_PL_FLAG_VRAM;
265
266 else
267 pref_flags |= TTM_PL_FLAG_TT;
268
269 nouveau_bo_placement_set(nvbo, pref_flags, valid_flags);
270
Ben Skeggs6ee73862009-12-11 19:24:15 +1000271 return 0;
272}
273
274struct validate_op {
Ben Skeggs6ee73862009-12-11 19:24:15 +1000275 struct list_head vram_list;
276 struct list_head gart_list;
277 struct list_head both_list;
278};
279
280static void
281validate_fini_list(struct list_head *list, struct nouveau_fence *fence)
282{
283 struct list_head *entry, *tmp;
284 struct nouveau_bo *nvbo;
285
286 list_for_each_safe(entry, tmp, list) {
287 nvbo = list_entry(entry, struct nouveau_bo, entry);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000288
Francisco Jerez332b2422010-10-20 23:35:40 +0200289 nouveau_bo_fence(nvbo, fence);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000290
Ben Skeggsa1606a92010-02-12 10:27:35 +1000291 if (unlikely(nvbo->validate_mapped)) {
292 ttm_bo_kunmap(&nvbo->kmap);
293 nvbo->validate_mapped = false;
294 }
295
Ben Skeggs6ee73862009-12-11 19:24:15 +1000296 list_del(&nvbo->entry);
297 nvbo->reserved_by = NULL;
298 ttm_bo_unreserve(&nvbo->bo);
Francisco Jerez374c3af2010-08-29 12:21:16 +0200299 drm_gem_object_unreference_unlocked(nvbo->gem);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000300 }
301}
302
303static void
Luca Barbieri234896a2010-01-06 04:02:45 +0100304validate_fini(struct validate_op *op, struct nouveau_fence* fence)
Ben Skeggs6ee73862009-12-11 19:24:15 +1000305{
Luca Barbieri234896a2010-01-06 04:02:45 +0100306 validate_fini_list(&op->vram_list, fence);
307 validate_fini_list(&op->gart_list, fence);
308 validate_fini_list(&op->both_list, fence);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000309}
310
311static int
312validate_init(struct nouveau_channel *chan, struct drm_file *file_priv,
313 struct drm_nouveau_gem_pushbuf_bo *pbbo,
314 int nr_buffers, struct validate_op *op)
315{
316 struct drm_device *dev = chan->dev;
317 struct drm_nouveau_private *dev_priv = dev->dev_private;
318 uint32_t sequence;
319 int trycnt = 0;
320 int ret, i;
321
322 sequence = atomic_add_return(1, &dev_priv->ttm.validate_sequence);
323retry:
324 if (++trycnt > 100000) {
325 NV_ERROR(dev, "%s failed and gave up.\n", __func__);
326 return -EINVAL;
327 }
328
329 for (i = 0; i < nr_buffers; i++) {
330 struct drm_nouveau_gem_pushbuf_bo *b = &pbbo[i];
331 struct drm_gem_object *gem;
332 struct nouveau_bo *nvbo;
333
334 gem = drm_gem_object_lookup(dev, file_priv, b->handle);
335 if (!gem) {
336 NV_ERROR(dev, "Unknown handle 0x%08x\n", b->handle);
337 validate_fini(op, NULL);
Chris Wilsonbf79cb92010-08-04 14:19:46 +0100338 return -ENOENT;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000339 }
340 nvbo = gem->driver_private;
341
342 if (nvbo->reserved_by && nvbo->reserved_by == file_priv) {
343 NV_ERROR(dev, "multiple instances of buffer %d on "
344 "validation list\n", b->handle);
Ben Skeggs5086f692012-06-25 18:04:27 +1000345 drm_gem_object_unreference_unlocked(gem);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000346 validate_fini(op, NULL);
347 return -EINVAL;
348 }
349
Ben Skeggs938c40e2010-10-12 09:54:54 +1000350 ret = ttm_bo_reserve(&nvbo->bo, true, false, true, sequence);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000351 if (ret) {
352 validate_fini(op, NULL);
Ben Skeggs938c40e2010-10-12 09:54:54 +1000353 if (unlikely(ret == -EAGAIN))
354 ret = ttm_bo_wait_unreserved(&nvbo->bo, true);
Francisco Jerez374c3af2010-08-29 12:21:16 +0200355 drm_gem_object_unreference_unlocked(gem);
Ben Skeggs938c40e2010-10-12 09:54:54 +1000356 if (unlikely(ret)) {
357 if (ret != -ERESTARTSYS)
358 NV_ERROR(dev, "fail reserve\n");
Ben Skeggs6ee73862009-12-11 19:24:15 +1000359 return ret;
Ben Skeggsa1606a92010-02-12 10:27:35 +1000360 }
Ben Skeggs6ee73862009-12-11 19:24:15 +1000361 goto retry;
362 }
363
Ben Skeggsa1606a92010-02-12 10:27:35 +1000364 b->user_priv = (uint64_t)(unsigned long)nvbo;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000365 nvbo->reserved_by = file_priv;
366 nvbo->pbbo_index = i;
367 if ((b->valid_domains & NOUVEAU_GEM_DOMAIN_VRAM) &&
368 (b->valid_domains & NOUVEAU_GEM_DOMAIN_GART))
369 list_add_tail(&nvbo->entry, &op->both_list);
370 else
371 if (b->valid_domains & NOUVEAU_GEM_DOMAIN_VRAM)
372 list_add_tail(&nvbo->entry, &op->vram_list);
373 else
374 if (b->valid_domains & NOUVEAU_GEM_DOMAIN_GART)
375 list_add_tail(&nvbo->entry, &op->gart_list);
376 else {
377 NV_ERROR(dev, "invalid valid domains: 0x%08x\n",
378 b->valid_domains);
Ben Skeggs02088432010-01-21 15:03:23 +1000379 list_add_tail(&nvbo->entry, &op->both_list);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000380 validate_fini(op, NULL);
381 return -EINVAL;
382 }
Ben Skeggs6ee73862009-12-11 19:24:15 +1000383 }
384
385 return 0;
386}
387
388static int
Ben Skeggs525895b2012-01-10 10:18:28 +1000389validate_sync(struct nouveau_channel *chan, struct nouveau_bo *nvbo)
390{
391 struct nouveau_fence *fence = NULL;
392 int ret = 0;
393
394 spin_lock(&nvbo->bo.bdev->fence_lock);
395 if (nvbo->bo.sync_obj)
396 fence = nouveau_fence_ref(nvbo->bo.sync_obj);
397 spin_unlock(&nvbo->bo.bdev->fence_lock);
398
399 if (fence) {
400 ret = nouveau_fence_sync(fence, chan);
401 nouveau_fence_unref(&fence);
402 }
403
404 return ret;
405}
406
407static int
Ben Skeggs6ee73862009-12-11 19:24:15 +1000408validate_list(struct nouveau_channel *chan, struct list_head *list,
409 struct drm_nouveau_gem_pushbuf_bo *pbbo, uint64_t user_pbbo_ptr)
410{
Ben Skeggsa3fcd0a2011-06-07 11:12:39 +1000411 struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000412 struct drm_nouveau_gem_pushbuf_bo __user *upbbo =
413 (void __force __user *)(uintptr_t)user_pbbo_ptr;
Ben Skeggsa1606a92010-02-12 10:27:35 +1000414 struct drm_device *dev = chan->dev;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000415 struct nouveau_bo *nvbo;
416 int ret, relocs = 0;
417
418 list_for_each_entry(nvbo, list, entry) {
419 struct drm_nouveau_gem_pushbuf_bo *b = &pbbo[nvbo->pbbo_index];
Ben Skeggs6ee73862009-12-11 19:24:15 +1000420
Ben Skeggs525895b2012-01-10 10:18:28 +1000421 ret = validate_sync(chan, nvbo);
Ben Skeggs415e6182010-07-23 09:06:52 +1000422 if (unlikely(ret)) {
423 NV_ERROR(dev, "fail pre-validate sync\n");
424 return ret;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000425 }
426
427 ret = nouveau_gem_set_domain(nvbo->gem, b->read_domains,
428 b->write_domains,
429 b->valid_domains);
Ben Skeggsa1606a92010-02-12 10:27:35 +1000430 if (unlikely(ret)) {
431 NV_ERROR(dev, "fail set_domain\n");
Ben Skeggs6ee73862009-12-11 19:24:15 +1000432 return ret;
Ben Skeggsa1606a92010-02-12 10:27:35 +1000433 }
Ben Skeggs6ee73862009-12-11 19:24:15 +1000434
Ben Skeggs7a45d762010-11-22 08:50:27 +1000435 ret = nouveau_bo_validate(nvbo, true, false, false);
Ben Skeggsa1606a92010-02-12 10:27:35 +1000436 if (unlikely(ret)) {
Ben Skeggs938c40e2010-10-12 09:54:54 +1000437 if (ret != -ERESTARTSYS)
438 NV_ERROR(dev, "fail ttm_validate\n");
Ben Skeggs6ee73862009-12-11 19:24:15 +1000439 return ret;
Ben Skeggsa1606a92010-02-12 10:27:35 +1000440 }
Ben Skeggs6ee73862009-12-11 19:24:15 +1000441
Ben Skeggs525895b2012-01-10 10:18:28 +1000442 ret = validate_sync(chan, nvbo);
Ben Skeggs415e6182010-07-23 09:06:52 +1000443 if (unlikely(ret)) {
444 NV_ERROR(dev, "fail post-validate sync\n");
445 return ret;
446 }
447
Ben Skeggsa3fcd0a2011-06-07 11:12:39 +1000448 if (dev_priv->card_type < NV_50) {
449 if (nvbo->bo.offset == b->presumed.offset &&
450 ((nvbo->bo.mem.mem_type == TTM_PL_VRAM &&
451 b->presumed.domain & NOUVEAU_GEM_DOMAIN_VRAM) ||
452 (nvbo->bo.mem.mem_type == TTM_PL_TT &&
453 b->presumed.domain & NOUVEAU_GEM_DOMAIN_GART)))
454 continue;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000455
Ben Skeggsa3fcd0a2011-06-07 11:12:39 +1000456 if (nvbo->bo.mem.mem_type == TTM_PL_TT)
457 b->presumed.domain = NOUVEAU_GEM_DOMAIN_GART;
458 else
459 b->presumed.domain = NOUVEAU_GEM_DOMAIN_VRAM;
460 b->presumed.offset = nvbo->bo.offset;
461 b->presumed.valid = 0;
462 relocs++;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000463
Ben Skeggsa3fcd0a2011-06-07 11:12:39 +1000464 if (DRM_COPY_TO_USER(&upbbo[nvbo->pbbo_index].presumed,
465 &b->presumed, sizeof(b->presumed)))
466 return -EFAULT;
467 }
Ben Skeggs6ee73862009-12-11 19:24:15 +1000468 }
469
470 return relocs;
471}
472
473static int
474nouveau_gem_pushbuf_validate(struct nouveau_channel *chan,
475 struct drm_file *file_priv,
476 struct drm_nouveau_gem_pushbuf_bo *pbbo,
477 uint64_t user_buffers, int nr_buffers,
478 struct validate_op *op, int *apply_relocs)
479{
Ben Skeggsa1606a92010-02-12 10:27:35 +1000480 struct drm_device *dev = chan->dev;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000481 int ret, relocs = 0;
482
483 INIT_LIST_HEAD(&op->vram_list);
484 INIT_LIST_HEAD(&op->gart_list);
485 INIT_LIST_HEAD(&op->both_list);
486
Ben Skeggs6ee73862009-12-11 19:24:15 +1000487 if (nr_buffers == 0)
488 return 0;
489
490 ret = validate_init(chan, file_priv, pbbo, nr_buffers, op);
Ben Skeggsa1606a92010-02-12 10:27:35 +1000491 if (unlikely(ret)) {
Ben Skeggs938c40e2010-10-12 09:54:54 +1000492 if (ret != -ERESTARTSYS)
493 NV_ERROR(dev, "validate_init\n");
Ben Skeggs6ee73862009-12-11 19:24:15 +1000494 return ret;
Ben Skeggsa1606a92010-02-12 10:27:35 +1000495 }
Ben Skeggs6ee73862009-12-11 19:24:15 +1000496
497 ret = validate_list(chan, &op->vram_list, pbbo, user_buffers);
498 if (unlikely(ret < 0)) {
Ben Skeggs938c40e2010-10-12 09:54:54 +1000499 if (ret != -ERESTARTSYS)
500 NV_ERROR(dev, "validate vram_list\n");
Ben Skeggs6ee73862009-12-11 19:24:15 +1000501 validate_fini(op, NULL);
502 return ret;
503 }
504 relocs += ret;
505
506 ret = validate_list(chan, &op->gart_list, pbbo, user_buffers);
507 if (unlikely(ret < 0)) {
Ben Skeggs938c40e2010-10-12 09:54:54 +1000508 if (ret != -ERESTARTSYS)
509 NV_ERROR(dev, "validate gart_list\n");
Ben Skeggs6ee73862009-12-11 19:24:15 +1000510 validate_fini(op, NULL);
511 return ret;
512 }
513 relocs += ret;
514
515 ret = validate_list(chan, &op->both_list, pbbo, user_buffers);
516 if (unlikely(ret < 0)) {
Ben Skeggs938c40e2010-10-12 09:54:54 +1000517 if (ret != -ERESTARTSYS)
518 NV_ERROR(dev, "validate both_list\n");
Ben Skeggs6ee73862009-12-11 19:24:15 +1000519 validate_fini(op, NULL);
520 return ret;
521 }
522 relocs += ret;
523
524 *apply_relocs = relocs;
525 return 0;
526}
527
528static inline void *
529u_memcpya(uint64_t user, unsigned nmemb, unsigned size)
530{
531 void *mem;
532 void __user *userptr = (void __force __user *)(uintptr_t)user;
533
534 mem = kmalloc(nmemb * size, GFP_KERNEL);
535 if (!mem)
536 return ERR_PTR(-ENOMEM);
537
538 if (DRM_COPY_FROM_USER(mem, userptr, nmemb * size)) {
539 kfree(mem);
540 return ERR_PTR(-EFAULT);
541 }
542
543 return mem;
544}
545
546static int
Ben Skeggsa1606a92010-02-12 10:27:35 +1000547nouveau_gem_pushbuf_reloc_apply(struct drm_device *dev,
548 struct drm_nouveau_gem_pushbuf *req,
549 struct drm_nouveau_gem_pushbuf_bo *bo)
Ben Skeggs6ee73862009-12-11 19:24:15 +1000550{
551 struct drm_nouveau_gem_pushbuf_reloc *reloc = NULL;
Luca Barbieri12f735b2010-01-10 20:10:53 +0100552 int ret = 0;
553 unsigned i;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000554
Ben Skeggsa1606a92010-02-12 10:27:35 +1000555 reloc = u_memcpya(req->relocs, req->nr_relocs, sizeof(*reloc));
Ben Skeggs6ee73862009-12-11 19:24:15 +1000556 if (IS_ERR(reloc))
557 return PTR_ERR(reloc);
558
Ben Skeggsa1606a92010-02-12 10:27:35 +1000559 for (i = 0; i < req->nr_relocs; i++) {
Ben Skeggs6ee73862009-12-11 19:24:15 +1000560 struct drm_nouveau_gem_pushbuf_reloc *r = &reloc[i];
561 struct drm_nouveau_gem_pushbuf_bo *b;
Ben Skeggsa1606a92010-02-12 10:27:35 +1000562 struct nouveau_bo *nvbo;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000563 uint32_t data;
564
Ben Skeggsa1606a92010-02-12 10:27:35 +1000565 if (unlikely(r->bo_index > req->nr_buffers)) {
566 NV_ERROR(dev, "reloc bo index invalid\n");
Ben Skeggs6ee73862009-12-11 19:24:15 +1000567 ret = -EINVAL;
568 break;
569 }
570
571 b = &bo[r->bo_index];
Ben Skeggsa1606a92010-02-12 10:27:35 +1000572 if (b->presumed.valid)
Ben Skeggs6ee73862009-12-11 19:24:15 +1000573 continue;
574
Ben Skeggsa1606a92010-02-12 10:27:35 +1000575 if (unlikely(r->reloc_bo_index > req->nr_buffers)) {
576 NV_ERROR(dev, "reloc container bo index invalid\n");
577 ret = -EINVAL;
578 break;
579 }
580 nvbo = (void *)(unsigned long)bo[r->reloc_bo_index].user_priv;
581
582 if (unlikely(r->reloc_bo_offset + 4 >
583 nvbo->bo.mem.num_pages << PAGE_SHIFT)) {
584 NV_ERROR(dev, "reloc outside of bo\n");
585 ret = -EINVAL;
586 break;
587 }
588
589 if (!nvbo->kmap.virtual) {
590 ret = ttm_bo_kmap(&nvbo->bo, 0, nvbo->bo.mem.num_pages,
591 &nvbo->kmap);
592 if (ret) {
593 NV_ERROR(dev, "failed kmap for reloc\n");
594 break;
595 }
596 nvbo->validate_mapped = true;
597 }
598
Ben Skeggs6ee73862009-12-11 19:24:15 +1000599 if (r->flags & NOUVEAU_GEM_RELOC_LOW)
Ben Skeggsa1606a92010-02-12 10:27:35 +1000600 data = b->presumed.offset + r->data;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000601 else
602 if (r->flags & NOUVEAU_GEM_RELOC_HIGH)
Ben Skeggsa1606a92010-02-12 10:27:35 +1000603 data = (b->presumed.offset + r->data) >> 32;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000604 else
605 data = r->data;
606
607 if (r->flags & NOUVEAU_GEM_RELOC_OR) {
Ben Skeggsa1606a92010-02-12 10:27:35 +1000608 if (b->presumed.domain == NOUVEAU_GEM_DOMAIN_GART)
Ben Skeggs6ee73862009-12-11 19:24:15 +1000609 data |= r->tor;
610 else
611 data |= r->vor;
612 }
613
Thomas Hellstrom702adba2010-11-17 12:28:29 +0000614 spin_lock(&nvbo->bo.bdev->fence_lock);
Ben Skeggsa1606a92010-02-12 10:27:35 +1000615 ret = ttm_bo_wait(&nvbo->bo, false, false, false);
Thomas Hellstrom702adba2010-11-17 12:28:29 +0000616 spin_unlock(&nvbo->bo.bdev->fence_lock);
Ben Skeggsa1606a92010-02-12 10:27:35 +1000617 if (ret) {
618 NV_ERROR(dev, "reloc wait_idle failed: %d\n", ret);
619 break;
620 }
Ben Skeggsa1606a92010-02-12 10:27:35 +1000621
622 nouveau_bo_wr32(nvbo, r->reloc_bo_offset >> 2, data);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000623 }
624
625 kfree(reloc);
626 return ret;
627}
628
629int
630nouveau_gem_ioctl_pushbuf(struct drm_device *dev, void *data,
631 struct drm_file *file_priv)
632{
Ben Skeggsa1606a92010-02-12 10:27:35 +1000633 struct drm_nouveau_private *dev_priv = dev->dev_private;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000634 struct drm_nouveau_gem_pushbuf *req = data;
Ben Skeggsa1606a92010-02-12 10:27:35 +1000635 struct drm_nouveau_gem_pushbuf_push *push;
636 struct drm_nouveau_gem_pushbuf_bo *bo;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000637 struct nouveau_channel *chan;
638 struct validate_op op;
Francisco Jerez6e86e042010-07-03 18:36:39 +0200639 struct nouveau_fence *fence = NULL;
Ben Skeggsa1606a92010-02-12 10:27:35 +1000640 int i, j, ret = 0, do_reloc = 0;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000641
Ben Skeggse8a863c2011-06-01 19:18:48 +1000642 chan = nouveau_channel_get(file_priv, req->channel);
Ben Skeggscff5c132010-10-06 16:16:59 +1000643 if (IS_ERR(chan))
644 return PTR_ERR(chan);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000645
Ben Skeggsa1606a92010-02-12 10:27:35 +1000646 req->vram_available = dev_priv->fb_aper_free;
647 req->gart_available = dev_priv->gart_info.aper_free;
648 if (unlikely(req->nr_push == 0))
649 goto out_next;
650
651 if (unlikely(req->nr_push > NOUVEAU_GEM_MAX_PUSH)) {
652 NV_ERROR(dev, "pushbuf push count exceeds limit: %d max %d\n",
653 req->nr_push, NOUVEAU_GEM_MAX_PUSH);
Ben Skeggscff5c132010-10-06 16:16:59 +1000654 nouveau_channel_put(&chan);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000655 return -EINVAL;
656 }
657
Ben Skeggsa1606a92010-02-12 10:27:35 +1000658 if (unlikely(req->nr_buffers > NOUVEAU_GEM_MAX_BUFFERS)) {
659 NV_ERROR(dev, "pushbuf bo count exceeds limit: %d max %d\n",
660 req->nr_buffers, NOUVEAU_GEM_MAX_BUFFERS);
Ben Skeggscff5c132010-10-06 16:16:59 +1000661 nouveau_channel_put(&chan);
Ben Skeggsa1606a92010-02-12 10:27:35 +1000662 return -EINVAL;
663 }
664
665 if (unlikely(req->nr_relocs > NOUVEAU_GEM_MAX_RELOCS)) {
666 NV_ERROR(dev, "pushbuf reloc count exceeds limit: %d max %d\n",
667 req->nr_relocs, NOUVEAU_GEM_MAX_RELOCS);
Ben Skeggscff5c132010-10-06 16:16:59 +1000668 nouveau_channel_put(&chan);
Ben Skeggsa1606a92010-02-12 10:27:35 +1000669 return -EINVAL;
670 }
671
672 push = u_memcpya(req->push, req->nr_push, sizeof(*push));
Ben Skeggscff5c132010-10-06 16:16:59 +1000673 if (IS_ERR(push)) {
674 nouveau_channel_put(&chan);
Ben Skeggsa1606a92010-02-12 10:27:35 +1000675 return PTR_ERR(push);
Ben Skeggscff5c132010-10-06 16:16:59 +1000676 }
Ben Skeggs6ee73862009-12-11 19:24:15 +1000677
678 bo = u_memcpya(req->buffers, req->nr_buffers, sizeof(*bo));
679 if (IS_ERR(bo)) {
Ben Skeggsa1606a92010-02-12 10:27:35 +1000680 kfree(push);
Ben Skeggscff5c132010-10-06 16:16:59 +1000681 nouveau_channel_put(&chan);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000682 return PTR_ERR(bo);
683 }
684
Ben Skeggsaccf9492012-03-16 12:40:17 +1000685 /* Ensure all push buffers are on validate list */
Ben Skeggs415e6182010-07-23 09:06:52 +1000686 for (i = 0; i < req->nr_push; i++) {
687 if (push[i].bo_index >= req->nr_buffers) {
688 NV_ERROR(dev, "push %d buffer not in list\n", i);
689 ret = -EINVAL;
Marcin Slusarz7fa0cba22011-03-07 12:31:35 +0100690 goto out_prevalid;
Ben Skeggs415e6182010-07-23 09:06:52 +1000691 }
Ben Skeggs415e6182010-07-23 09:06:52 +1000692 }
693
Ben Skeggs6ee73862009-12-11 19:24:15 +1000694 /* Validate buffer list */
695 ret = nouveau_gem_pushbuf_validate(chan, file_priv, bo, req->buffers,
696 req->nr_buffers, &op, &do_reloc);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000697 if (ret) {
Ben Skeggs938c40e2010-10-12 09:54:54 +1000698 if (ret != -ERESTARTSYS)
699 NV_ERROR(dev, "validate: %d\n", ret);
Marcin Slusarz7fa0cba22011-03-07 12:31:35 +0100700 goto out_prevalid;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000701 }
702
Ben Skeggs6ee73862009-12-11 19:24:15 +1000703 /* Apply any relocations that are required */
704 if (do_reloc) {
Ben Skeggsa1606a92010-02-12 10:27:35 +1000705 ret = nouveau_gem_pushbuf_reloc_apply(dev, req, bo);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000706 if (ret) {
707 NV_ERROR(dev, "reloc apply: %d\n", ret);
708 goto out;
709 }
710 }
711
Ben Skeggs9a391ad2010-02-11 16:37:26 +1000712 if (chan->dma.ib_max) {
Ben Skeggs5e120f62012-04-30 13:55:29 +1000713 ret = nouveau_dma_wait(chan, req->nr_push + 1, 16);
Ben Skeggs9a391ad2010-02-11 16:37:26 +1000714 if (ret) {
715 NV_INFO(dev, "nv50cal_space: %d\n", ret);
716 goto out;
717 }
718
Ben Skeggsa1606a92010-02-12 10:27:35 +1000719 for (i = 0; i < req->nr_push; i++) {
720 struct nouveau_bo *nvbo = (void *)(unsigned long)
721 bo[push[i].bo_index].user_priv;
722
723 nv50_dma_push(chan, nvbo, push[i].offset,
724 push[i].length);
725 }
Ben Skeggs9a391ad2010-02-11 16:37:26 +1000726 } else
Francisco Jerezee508b82010-08-25 12:54:53 +0200727 if (dev_priv->chipset >= 0x25) {
Ben Skeggsa1606a92010-02-12 10:27:35 +1000728 ret = RING_SPACE(chan, req->nr_push * 2);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000729 if (ret) {
730 NV_ERROR(dev, "cal_space: %d\n", ret);
731 goto out;
732 }
Ben Skeggsa1606a92010-02-12 10:27:35 +1000733
734 for (i = 0; i < req->nr_push; i++) {
735 struct nouveau_bo *nvbo = (void *)(unsigned long)
736 bo[push[i].bo_index].user_priv;
737 struct drm_mm_node *mem = nvbo->bo.mem.mm_node;
738
739 OUT_RING(chan, ((mem->start << PAGE_SHIFT) +
740 push[i].offset) | 2);
741 OUT_RING(chan, 0);
742 }
Ben Skeggs6ee73862009-12-11 19:24:15 +1000743 } else {
Ben Skeggsa1606a92010-02-12 10:27:35 +1000744 ret = RING_SPACE(chan, req->nr_push * (2 + NOUVEAU_DMA_SKIPS));
Ben Skeggs6ee73862009-12-11 19:24:15 +1000745 if (ret) {
746 NV_ERROR(dev, "jmp_space: %d\n", ret);
747 goto out;
748 }
Ben Skeggs6ee73862009-12-11 19:24:15 +1000749
Ben Skeggsa1606a92010-02-12 10:27:35 +1000750 for (i = 0; i < req->nr_push; i++) {
751 struct nouveau_bo *nvbo = (void *)(unsigned long)
752 bo[push[i].bo_index].user_priv;
753 struct drm_mm_node *mem = nvbo->bo.mem.mm_node;
754 uint32_t cmd;
755
756 cmd = chan->pushbuf_base + ((chan->dma.cur + 2) << 2);
757 cmd |= 0x20000000;
758 if (unlikely(cmd != req->suffix0)) {
759 if (!nvbo->kmap.virtual) {
760 ret = ttm_bo_kmap(&nvbo->bo, 0,
761 nvbo->bo.mem.
762 num_pages,
763 &nvbo->kmap);
764 if (ret) {
765 WIND_RING(chan);
766 goto out;
767 }
768 nvbo->validate_mapped = true;
769 }
770
771 nouveau_bo_wr32(nvbo, (push[i].offset +
772 push[i].length - 8) / 4, cmd);
773 }
774
775 OUT_RING(chan, ((mem->start << PAGE_SHIFT) +
776 push[i].offset) | 0x20000000);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000777 OUT_RING(chan, 0);
Ben Skeggsa1606a92010-02-12 10:27:35 +1000778 for (j = 0; j < NOUVEAU_DMA_SKIPS; j++)
779 OUT_RING(chan, 0);
780 }
Ben Skeggs6ee73862009-12-11 19:24:15 +1000781 }
782
Ben Skeggsd375e7d52012-04-30 13:30:00 +1000783 ret = nouveau_fence_new(chan, &fence);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000784 if (ret) {
785 NV_ERROR(dev, "error fencing pushbuf: %d\n", ret);
786 WIND_RING(chan);
787 goto out;
788 }
789
790out:
Luca Barbieri234896a2010-01-06 04:02:45 +0100791 validate_fini(&op, fence);
Marcin Slusarz382d62e2010-10-20 21:50:24 +0200792 nouveau_fence_unref(&fence);
Marcin Slusarz7fa0cba22011-03-07 12:31:35 +0100793
794out_prevalid:
Ben Skeggs6ee73862009-12-11 19:24:15 +1000795 kfree(bo);
Ben Skeggsa1606a92010-02-12 10:27:35 +1000796 kfree(push);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000797
798out_next:
Ben Skeggs9a391ad2010-02-11 16:37:26 +1000799 if (chan->dma.ib_max) {
800 req->suffix0 = 0x00000000;
801 req->suffix1 = 0x00000000;
802 } else
Francisco Jerezee508b82010-08-25 12:54:53 +0200803 if (dev_priv->chipset >= 0x25) {
Ben Skeggs6ee73862009-12-11 19:24:15 +1000804 req->suffix0 = 0x00020000;
805 req->suffix1 = 0x00000000;
806 } else {
807 req->suffix0 = 0x20000000 |
808 (chan->pushbuf_base + ((chan->dma.cur + 2) << 2));
809 req->suffix1 = 0x00000000;
810 }
811
Ben Skeggscff5c132010-10-06 16:16:59 +1000812 nouveau_channel_put(&chan);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000813 return ret;
814}
815
Ben Skeggs6ee73862009-12-11 19:24:15 +1000816static inline uint32_t
817domain_to_ttm(struct nouveau_bo *nvbo, uint32_t domain)
818{
819 uint32_t flags = 0;
820
821 if (domain & NOUVEAU_GEM_DOMAIN_VRAM)
822 flags |= TTM_PL_FLAG_VRAM;
823 if (domain & NOUVEAU_GEM_DOMAIN_GART)
824 flags |= TTM_PL_FLAG_TT;
825
826 return flags;
827}
828
829int
Ben Skeggs6ee73862009-12-11 19:24:15 +1000830nouveau_gem_ioctl_cpu_prep(struct drm_device *dev, void *data,
831 struct drm_file *file_priv)
832{
833 struct drm_nouveau_gem_cpu_prep *req = data;
834 struct drm_gem_object *gem;
835 struct nouveau_bo *nvbo;
836 bool no_wait = !!(req->flags & NOUVEAU_GEM_CPU_PREP_NOWAIT);
837 int ret = -EINVAL;
838
Ben Skeggs6ee73862009-12-11 19:24:15 +1000839 gem = drm_gem_object_lookup(dev, file_priv, req->handle);
840 if (!gem)
Chris Wilsonbf79cb92010-08-04 14:19:46 +0100841 return -ENOENT;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000842 nvbo = nouveau_gem_object(gem);
843
Ben Skeggs21e86c12010-10-11 11:48:45 +1000844 spin_lock(&nvbo->bo.bdev->fence_lock);
845 ret = ttm_bo_wait(&nvbo->bo, true, true, no_wait);
846 spin_unlock(&nvbo->bo.bdev->fence_lock);
Luca Barbieribc9025b2010-02-09 05:49:12 +0000847 drm_gem_object_unreference_unlocked(gem);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000848 return ret;
849}
850
851int
852nouveau_gem_ioctl_cpu_fini(struct drm_device *dev, void *data,
853 struct drm_file *file_priv)
854{
Ben Skeggs21e86c12010-10-11 11:48:45 +1000855 return 0;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000856}
857
858int
859nouveau_gem_ioctl_info(struct drm_device *dev, void *data,
860 struct drm_file *file_priv)
861{
862 struct drm_nouveau_gem_info *req = data;
863 struct drm_gem_object *gem;
864 int ret;
865
Ben Skeggs6ee73862009-12-11 19:24:15 +1000866 gem = drm_gem_object_lookup(dev, file_priv, req->handle);
867 if (!gem)
Chris Wilsonbf79cb92010-08-04 14:19:46 +0100868 return -ENOENT;
Ben Skeggs6ee73862009-12-11 19:24:15 +1000869
Ben Skeggse758a312011-06-07 13:28:11 +1000870 ret = nouveau_gem_info(file_priv, gem, req);
Luca Barbieribc9025b2010-02-09 05:49:12 +0000871 drm_gem_object_unreference_unlocked(gem);
Ben Skeggs6ee73862009-12-11 19:24:15 +1000872 return ret;
873}
874