Merge commit 'v2.6.28-rc8' into x86/uv
[linux-2.6] / drivers / gpu / drm / i915 / i915_gem.c
1 /*
2  * Copyright © 2008 Intel Corporation
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 (including the next
12  * paragraph) shall be included in all copies or substantial portions of the
13  * Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21  * IN THE SOFTWARE.
22  *
23  * Authors:
24  *    Eric Anholt <eric@anholt.net>
25  *
26  */
27
28 #include "drmP.h"
29 #include "drm.h"
30 #include "i915_drm.h"
31 #include "i915_drv.h"
32 #include <linux/swap.h>
33
34 #define I915_GEM_GPU_DOMAINS    (~(I915_GEM_DOMAIN_CPU | I915_GEM_DOMAIN_GTT))
35
36 static void
37 i915_gem_object_set_to_gpu_domain(struct drm_gem_object *obj,
38                                   uint32_t read_domains,
39                                   uint32_t write_domain);
40 static void i915_gem_object_flush_gpu_write_domain(struct drm_gem_object *obj);
41 static void i915_gem_object_flush_gtt_write_domain(struct drm_gem_object *obj);
42 static void i915_gem_object_flush_cpu_write_domain(struct drm_gem_object *obj);
43 static int i915_gem_object_set_to_gtt_domain(struct drm_gem_object *obj,
44                                              int write);
45 static int i915_gem_object_set_to_cpu_domain(struct drm_gem_object *obj,
46                                              int write);
47 static int i915_gem_object_set_cpu_read_domain_range(struct drm_gem_object *obj,
48                                                      uint64_t offset,
49                                                      uint64_t size);
50 static void i915_gem_object_set_to_full_cpu_read_domain(struct drm_gem_object *obj);
51 static int i915_gem_object_get_page_list(struct drm_gem_object *obj);
52 static void i915_gem_object_free_page_list(struct drm_gem_object *obj);
53 static int i915_gem_object_wait_rendering(struct drm_gem_object *obj);
54
55 static void
56 i915_gem_cleanup_ringbuffer(struct drm_device *dev);
57
58 int
59 i915_gem_init_ioctl(struct drm_device *dev, void *data,
60                     struct drm_file *file_priv)
61 {
62         drm_i915_private_t *dev_priv = dev->dev_private;
63         struct drm_i915_gem_init *args = data;
64
65         mutex_lock(&dev->struct_mutex);
66
67         if (args->gtt_start >= args->gtt_end ||
68             (args->gtt_start & (PAGE_SIZE - 1)) != 0 ||
69             (args->gtt_end & (PAGE_SIZE - 1)) != 0) {
70                 mutex_unlock(&dev->struct_mutex);
71                 return -EINVAL;
72         }
73
74         drm_mm_init(&dev_priv->mm.gtt_space, args->gtt_start,
75             args->gtt_end - args->gtt_start);
76
77         dev->gtt_total = (uint32_t) (args->gtt_end - args->gtt_start);
78
79         mutex_unlock(&dev->struct_mutex);
80
81         return 0;
82 }
83
84 int
85 i915_gem_get_aperture_ioctl(struct drm_device *dev, void *data,
86                             struct drm_file *file_priv)
87 {
88         struct drm_i915_gem_get_aperture *args = data;
89
90         if (!(dev->driver->driver_features & DRIVER_GEM))
91                 return -ENODEV;
92
93         args->aper_size = dev->gtt_total;
94         args->aper_available_size = (args->aper_size -
95                                      atomic_read(&dev->pin_memory));
96
97         return 0;
98 }
99
100
101 /**
102  * Creates a new mm object and returns a handle to it.
103  */
104 int
105 i915_gem_create_ioctl(struct drm_device *dev, void *data,
106                       struct drm_file *file_priv)
107 {
108         struct drm_i915_gem_create *args = data;
109         struct drm_gem_object *obj;
110         int handle, ret;
111
112         args->size = roundup(args->size, PAGE_SIZE);
113
114         /* Allocate the new object */
115         obj = drm_gem_object_alloc(dev, args->size);
116         if (obj == NULL)
117                 return -ENOMEM;
118
119         ret = drm_gem_handle_create(file_priv, obj, &handle);
120         mutex_lock(&dev->struct_mutex);
121         drm_gem_object_handle_unreference(obj);
122         mutex_unlock(&dev->struct_mutex);
123
124         if (ret)
125                 return ret;
126
127         args->handle = handle;
128
129         return 0;
130 }
131
132 /**
133  * Reads data from the object referenced by handle.
134  *
135  * On error, the contents of *data are undefined.
136  */
137 int
138 i915_gem_pread_ioctl(struct drm_device *dev, void *data,
139                      struct drm_file *file_priv)
140 {
141         struct drm_i915_gem_pread *args = data;
142         struct drm_gem_object *obj;
143         struct drm_i915_gem_object *obj_priv;
144         ssize_t read;
145         loff_t offset;
146         int ret;
147
148         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
149         if (obj == NULL)
150                 return -EBADF;
151         obj_priv = obj->driver_private;
152
153         /* Bounds check source.
154          *
155          * XXX: This could use review for overflow issues...
156          */
157         if (args->offset > obj->size || args->size > obj->size ||
158             args->offset + args->size > obj->size) {
159                 drm_gem_object_unreference(obj);
160                 return -EINVAL;
161         }
162
163         mutex_lock(&dev->struct_mutex);
164
165         ret = i915_gem_object_set_cpu_read_domain_range(obj, args->offset,
166                                                         args->size);
167         if (ret != 0) {
168                 drm_gem_object_unreference(obj);
169                 mutex_unlock(&dev->struct_mutex);
170                 return ret;
171         }
172
173         offset = args->offset;
174
175         read = vfs_read(obj->filp, (char __user *)(uintptr_t)args->data_ptr,
176                         args->size, &offset);
177         if (read != args->size) {
178                 drm_gem_object_unreference(obj);
179                 mutex_unlock(&dev->struct_mutex);
180                 if (read < 0)
181                         return read;
182                 else
183                         return -EINVAL;
184         }
185
186         drm_gem_object_unreference(obj);
187         mutex_unlock(&dev->struct_mutex);
188
189         return 0;
190 }
191
192 /* This is the fast write path which cannot handle
193  * page faults in the source data
194  */
195
196 static inline int
197 fast_user_write(struct io_mapping *mapping,
198                 loff_t page_base, int page_offset,
199                 char __user *user_data,
200                 int length)
201 {
202         char *vaddr_atomic;
203         unsigned long unwritten;
204
205         vaddr_atomic = io_mapping_map_atomic_wc(mapping, page_base);
206         unwritten = __copy_from_user_inatomic_nocache(vaddr_atomic + page_offset,
207                                                       user_data, length);
208         io_mapping_unmap_atomic(vaddr_atomic);
209         if (unwritten)
210                 return -EFAULT;
211         return 0;
212 }
213
214 /* Here's the write path which can sleep for
215  * page faults
216  */
217
218 static inline int
219 slow_user_write(struct io_mapping *mapping,
220                 loff_t page_base, int page_offset,
221                 char __user *user_data,
222                 int length)
223 {
224         char __iomem *vaddr;
225         unsigned long unwritten;
226
227         vaddr = io_mapping_map_wc(mapping, page_base);
228         if (vaddr == NULL)
229                 return -EFAULT;
230         unwritten = __copy_from_user(vaddr + page_offset,
231                                      user_data, length);
232         io_mapping_unmap(vaddr);
233         if (unwritten)
234                 return -EFAULT;
235         return 0;
236 }
237
238 static int
239 i915_gem_gtt_pwrite(struct drm_device *dev, struct drm_gem_object *obj,
240                     struct drm_i915_gem_pwrite *args,
241                     struct drm_file *file_priv)
242 {
243         struct drm_i915_gem_object *obj_priv = obj->driver_private;
244         drm_i915_private_t *dev_priv = dev->dev_private;
245         ssize_t remain;
246         loff_t offset, page_base;
247         char __user *user_data;
248         int page_offset, page_length;
249         int ret;
250
251         user_data = (char __user *) (uintptr_t) args->data_ptr;
252         remain = args->size;
253         if (!access_ok(VERIFY_READ, user_data, remain))
254                 return -EFAULT;
255
256
257         mutex_lock(&dev->struct_mutex);
258         ret = i915_gem_object_pin(obj, 0);
259         if (ret) {
260                 mutex_unlock(&dev->struct_mutex);
261                 return ret;
262         }
263         ret = i915_gem_object_set_to_gtt_domain(obj, 1);
264         if (ret)
265                 goto fail;
266
267         obj_priv = obj->driver_private;
268         offset = obj_priv->gtt_offset + args->offset;
269         obj_priv->dirty = 1;
270
271         while (remain > 0) {
272                 /* Operation in this page
273                  *
274                  * page_base = page offset within aperture
275                  * page_offset = offset within page
276                  * page_length = bytes to copy for this page
277                  */
278                 page_base = (offset & ~(PAGE_SIZE-1));
279                 page_offset = offset & (PAGE_SIZE-1);
280                 page_length = remain;
281                 if ((page_offset + remain) > PAGE_SIZE)
282                         page_length = PAGE_SIZE - page_offset;
283
284                 ret = fast_user_write (dev_priv->mm.gtt_mapping, page_base,
285                                        page_offset, user_data, page_length);
286
287                 /* If we get a fault while copying data, then (presumably) our
288                  * source page isn't available. In this case, use the
289                  * non-atomic function
290                  */
291                 if (ret) {
292                         ret = slow_user_write (dev_priv->mm.gtt_mapping,
293                                                page_base, page_offset,
294                                                user_data, page_length);
295                         if (ret)
296                                 goto fail;
297                 }
298
299                 remain -= page_length;
300                 user_data += page_length;
301                 offset += page_length;
302         }
303
304 fail:
305         i915_gem_object_unpin(obj);
306         mutex_unlock(&dev->struct_mutex);
307
308         return ret;
309 }
310
311 static int
312 i915_gem_shmem_pwrite(struct drm_device *dev, struct drm_gem_object *obj,
313                       struct drm_i915_gem_pwrite *args,
314                       struct drm_file *file_priv)
315 {
316         int ret;
317         loff_t offset;
318         ssize_t written;
319
320         mutex_lock(&dev->struct_mutex);
321
322         ret = i915_gem_object_set_to_cpu_domain(obj, 1);
323         if (ret) {
324                 mutex_unlock(&dev->struct_mutex);
325                 return ret;
326         }
327
328         offset = args->offset;
329
330         written = vfs_write(obj->filp,
331                             (char __user *)(uintptr_t) args->data_ptr,
332                             args->size, &offset);
333         if (written != args->size) {
334                 mutex_unlock(&dev->struct_mutex);
335                 if (written < 0)
336                         return written;
337                 else
338                         return -EINVAL;
339         }
340
341         mutex_unlock(&dev->struct_mutex);
342
343         return 0;
344 }
345
346 /**
347  * Writes data to the object referenced by handle.
348  *
349  * On error, the contents of the buffer that were to be modified are undefined.
350  */
351 int
352 i915_gem_pwrite_ioctl(struct drm_device *dev, void *data,
353                       struct drm_file *file_priv)
354 {
355         struct drm_i915_gem_pwrite *args = data;
356         struct drm_gem_object *obj;
357         struct drm_i915_gem_object *obj_priv;
358         int ret = 0;
359
360         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
361         if (obj == NULL)
362                 return -EBADF;
363         obj_priv = obj->driver_private;
364
365         /* Bounds check destination.
366          *
367          * XXX: This could use review for overflow issues...
368          */
369         if (args->offset > obj->size || args->size > obj->size ||
370             args->offset + args->size > obj->size) {
371                 drm_gem_object_unreference(obj);
372                 return -EINVAL;
373         }
374
375         /* We can only do the GTT pwrite on untiled buffers, as otherwise
376          * it would end up going through the fenced access, and we'll get
377          * different detiling behavior between reading and writing.
378          * pread/pwrite currently are reading and writing from the CPU
379          * perspective, requiring manual detiling by the client.
380          */
381         if (obj_priv->tiling_mode == I915_TILING_NONE &&
382             dev->gtt_total != 0)
383                 ret = i915_gem_gtt_pwrite(dev, obj, args, file_priv);
384         else
385                 ret = i915_gem_shmem_pwrite(dev, obj, args, file_priv);
386
387 #if WATCH_PWRITE
388         if (ret)
389                 DRM_INFO("pwrite failed %d\n", ret);
390 #endif
391
392         drm_gem_object_unreference(obj);
393
394         return ret;
395 }
396
397 /**
398  * Called when user space prepares to use an object with the CPU, either
399  * through the mmap ioctl's mapping or a GTT mapping.
400  */
401 int
402 i915_gem_set_domain_ioctl(struct drm_device *dev, void *data,
403                           struct drm_file *file_priv)
404 {
405         struct drm_i915_gem_set_domain *args = data;
406         struct drm_gem_object *obj;
407         uint32_t read_domains = args->read_domains;
408         uint32_t write_domain = args->write_domain;
409         int ret;
410
411         if (!(dev->driver->driver_features & DRIVER_GEM))
412                 return -ENODEV;
413
414         /* Only handle setting domains to types used by the CPU. */
415         if (write_domain & ~(I915_GEM_DOMAIN_CPU | I915_GEM_DOMAIN_GTT))
416                 return -EINVAL;
417
418         if (read_domains & ~(I915_GEM_DOMAIN_CPU | I915_GEM_DOMAIN_GTT))
419                 return -EINVAL;
420
421         /* Having something in the write domain implies it's in the read
422          * domain, and only that read domain.  Enforce that in the request.
423          */
424         if (write_domain != 0 && read_domains != write_domain)
425                 return -EINVAL;
426
427         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
428         if (obj == NULL)
429                 return -EBADF;
430
431         mutex_lock(&dev->struct_mutex);
432 #if WATCH_BUF
433         DRM_INFO("set_domain_ioctl %p(%d), %08x %08x\n",
434                  obj, obj->size, read_domains, write_domain);
435 #endif
436         if (read_domains & I915_GEM_DOMAIN_GTT) {
437                 ret = i915_gem_object_set_to_gtt_domain(obj, write_domain != 0);
438
439                 /* Silently promote "you're not bound, there was nothing to do"
440                  * to success, since the client was just asking us to
441                  * make sure everything was done.
442                  */
443                 if (ret == -EINVAL)
444                         ret = 0;
445         } else {
446                 ret = i915_gem_object_set_to_cpu_domain(obj, write_domain != 0);
447         }
448
449         drm_gem_object_unreference(obj);
450         mutex_unlock(&dev->struct_mutex);
451         return ret;
452 }
453
454 /**
455  * Called when user space has done writes to this buffer
456  */
457 int
458 i915_gem_sw_finish_ioctl(struct drm_device *dev, void *data,
459                       struct drm_file *file_priv)
460 {
461         struct drm_i915_gem_sw_finish *args = data;
462         struct drm_gem_object *obj;
463         struct drm_i915_gem_object *obj_priv;
464         int ret = 0;
465
466         if (!(dev->driver->driver_features & DRIVER_GEM))
467                 return -ENODEV;
468
469         mutex_lock(&dev->struct_mutex);
470         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
471         if (obj == NULL) {
472                 mutex_unlock(&dev->struct_mutex);
473                 return -EBADF;
474         }
475
476 #if WATCH_BUF
477         DRM_INFO("%s: sw_finish %d (%p %d)\n",
478                  __func__, args->handle, obj, obj->size);
479 #endif
480         obj_priv = obj->driver_private;
481
482         /* Pinned buffers may be scanout, so flush the cache */
483         if (obj_priv->pin_count)
484                 i915_gem_object_flush_cpu_write_domain(obj);
485
486         drm_gem_object_unreference(obj);
487         mutex_unlock(&dev->struct_mutex);
488         return ret;
489 }
490
491 /**
492  * Maps the contents of an object, returning the address it is mapped
493  * into.
494  *
495  * While the mapping holds a reference on the contents of the object, it doesn't
496  * imply a ref on the object itself.
497  */
498 int
499 i915_gem_mmap_ioctl(struct drm_device *dev, void *data,
500                    struct drm_file *file_priv)
501 {
502         struct drm_i915_gem_mmap *args = data;
503         struct drm_gem_object *obj;
504         loff_t offset;
505         unsigned long addr;
506
507         if (!(dev->driver->driver_features & DRIVER_GEM))
508                 return -ENODEV;
509
510         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
511         if (obj == NULL)
512                 return -EBADF;
513
514         offset = args->offset;
515
516         down_write(&current->mm->mmap_sem);
517         addr = do_mmap(obj->filp, 0, args->size,
518                        PROT_READ | PROT_WRITE, MAP_SHARED,
519                        args->offset);
520         up_write(&current->mm->mmap_sem);
521         mutex_lock(&dev->struct_mutex);
522         drm_gem_object_unreference(obj);
523         mutex_unlock(&dev->struct_mutex);
524         if (IS_ERR((void *)addr))
525                 return addr;
526
527         args->addr_ptr = (uint64_t) addr;
528
529         return 0;
530 }
531
532 static void
533 i915_gem_object_free_page_list(struct drm_gem_object *obj)
534 {
535         struct drm_i915_gem_object *obj_priv = obj->driver_private;
536         int page_count = obj->size / PAGE_SIZE;
537         int i;
538
539         if (obj_priv->page_list == NULL)
540                 return;
541
542
543         for (i = 0; i < page_count; i++)
544                 if (obj_priv->page_list[i] != NULL) {
545                         if (obj_priv->dirty)
546                                 set_page_dirty(obj_priv->page_list[i]);
547                         mark_page_accessed(obj_priv->page_list[i]);
548                         page_cache_release(obj_priv->page_list[i]);
549                 }
550         obj_priv->dirty = 0;
551
552         drm_free(obj_priv->page_list,
553                  page_count * sizeof(struct page *),
554                  DRM_MEM_DRIVER);
555         obj_priv->page_list = NULL;
556 }
557
558 static void
559 i915_gem_object_move_to_active(struct drm_gem_object *obj, uint32_t seqno)
560 {
561         struct drm_device *dev = obj->dev;
562         drm_i915_private_t *dev_priv = dev->dev_private;
563         struct drm_i915_gem_object *obj_priv = obj->driver_private;
564
565         /* Add a reference if we're newly entering the active list. */
566         if (!obj_priv->active) {
567                 drm_gem_object_reference(obj);
568                 obj_priv->active = 1;
569         }
570         /* Move from whatever list we were on to the tail of execution. */
571         list_move_tail(&obj_priv->list,
572                        &dev_priv->mm.active_list);
573         obj_priv->last_rendering_seqno = seqno;
574 }
575
576 static void
577 i915_gem_object_move_to_flushing(struct drm_gem_object *obj)
578 {
579         struct drm_device *dev = obj->dev;
580         drm_i915_private_t *dev_priv = dev->dev_private;
581         struct drm_i915_gem_object *obj_priv = obj->driver_private;
582
583         BUG_ON(!obj_priv->active);
584         list_move_tail(&obj_priv->list, &dev_priv->mm.flushing_list);
585         obj_priv->last_rendering_seqno = 0;
586 }
587
588 static void
589 i915_gem_object_move_to_inactive(struct drm_gem_object *obj)
590 {
591         struct drm_device *dev = obj->dev;
592         drm_i915_private_t *dev_priv = dev->dev_private;
593         struct drm_i915_gem_object *obj_priv = obj->driver_private;
594
595         i915_verify_inactive(dev, __FILE__, __LINE__);
596         if (obj_priv->pin_count != 0)
597                 list_del_init(&obj_priv->list);
598         else
599                 list_move_tail(&obj_priv->list, &dev_priv->mm.inactive_list);
600
601         obj_priv->last_rendering_seqno = 0;
602         if (obj_priv->active) {
603                 obj_priv->active = 0;
604                 drm_gem_object_unreference(obj);
605         }
606         i915_verify_inactive(dev, __FILE__, __LINE__);
607 }
608
609 /**
610  * Creates a new sequence number, emitting a write of it to the status page
611  * plus an interrupt, which will trigger i915_user_interrupt_handler.
612  *
613  * Must be called with struct_lock held.
614  *
615  * Returned sequence numbers are nonzero on success.
616  */
617 static uint32_t
618 i915_add_request(struct drm_device *dev, uint32_t flush_domains)
619 {
620         drm_i915_private_t *dev_priv = dev->dev_private;
621         struct drm_i915_gem_request *request;
622         uint32_t seqno;
623         int was_empty;
624         RING_LOCALS;
625
626         request = drm_calloc(1, sizeof(*request), DRM_MEM_DRIVER);
627         if (request == NULL)
628                 return 0;
629
630         /* Grab the seqno we're going to make this request be, and bump the
631          * next (skipping 0 so it can be the reserved no-seqno value).
632          */
633         seqno = dev_priv->mm.next_gem_seqno;
634         dev_priv->mm.next_gem_seqno++;
635         if (dev_priv->mm.next_gem_seqno == 0)
636                 dev_priv->mm.next_gem_seqno++;
637
638         BEGIN_LP_RING(4);
639         OUT_RING(MI_STORE_DWORD_INDEX);
640         OUT_RING(I915_GEM_HWS_INDEX << MI_STORE_DWORD_INDEX_SHIFT);
641         OUT_RING(seqno);
642
643         OUT_RING(MI_USER_INTERRUPT);
644         ADVANCE_LP_RING();
645
646         DRM_DEBUG("%d\n", seqno);
647
648         request->seqno = seqno;
649         request->emitted_jiffies = jiffies;
650         was_empty = list_empty(&dev_priv->mm.request_list);
651         list_add_tail(&request->list, &dev_priv->mm.request_list);
652
653         /* Associate any objects on the flushing list matching the write
654          * domain we're flushing with our flush.
655          */
656         if (flush_domains != 0) {
657                 struct drm_i915_gem_object *obj_priv, *next;
658
659                 list_for_each_entry_safe(obj_priv, next,
660                                          &dev_priv->mm.flushing_list, list) {
661                         struct drm_gem_object *obj = obj_priv->obj;
662
663                         if ((obj->write_domain & flush_domains) ==
664                             obj->write_domain) {
665                                 obj->write_domain = 0;
666                                 i915_gem_object_move_to_active(obj, seqno);
667                         }
668                 }
669
670         }
671
672         if (was_empty && !dev_priv->mm.suspended)
673                 schedule_delayed_work(&dev_priv->mm.retire_work, HZ);
674         return seqno;
675 }
676
677 /**
678  * Command execution barrier
679  *
680  * Ensures that all commands in the ring are finished
681  * before signalling the CPU
682  */
683 static uint32_t
684 i915_retire_commands(struct drm_device *dev)
685 {
686         drm_i915_private_t *dev_priv = dev->dev_private;
687         uint32_t cmd = MI_FLUSH | MI_NO_WRITE_FLUSH;
688         uint32_t flush_domains = 0;
689         RING_LOCALS;
690
691         /* The sampler always gets flushed on i965 (sigh) */
692         if (IS_I965G(dev))
693                 flush_domains |= I915_GEM_DOMAIN_SAMPLER;
694         BEGIN_LP_RING(2);
695         OUT_RING(cmd);
696         OUT_RING(0); /* noop */
697         ADVANCE_LP_RING();
698         return flush_domains;
699 }
700
701 /**
702  * Moves buffers associated only with the given active seqno from the active
703  * to inactive list, potentially freeing them.
704  */
705 static void
706 i915_gem_retire_request(struct drm_device *dev,
707                         struct drm_i915_gem_request *request)
708 {
709         drm_i915_private_t *dev_priv = dev->dev_private;
710
711         /* Move any buffers on the active list that are no longer referenced
712          * by the ringbuffer to the flushing/inactive lists as appropriate.
713          */
714         while (!list_empty(&dev_priv->mm.active_list)) {
715                 struct drm_gem_object *obj;
716                 struct drm_i915_gem_object *obj_priv;
717
718                 obj_priv = list_first_entry(&dev_priv->mm.active_list,
719                                             struct drm_i915_gem_object,
720                                             list);
721                 obj = obj_priv->obj;
722
723                 /* If the seqno being retired doesn't match the oldest in the
724                  * list, then the oldest in the list must still be newer than
725                  * this seqno.
726                  */
727                 if (obj_priv->last_rendering_seqno != request->seqno)
728                         return;
729 #if WATCH_LRU
730                 DRM_INFO("%s: retire %d moves to inactive list %p\n",
731                          __func__, request->seqno, obj);
732 #endif
733
734                 if (obj->write_domain != 0)
735                         i915_gem_object_move_to_flushing(obj);
736                 else
737                         i915_gem_object_move_to_inactive(obj);
738         }
739 }
740
741 /**
742  * Returns true if seq1 is later than seq2.
743  */
744 static int
745 i915_seqno_passed(uint32_t seq1, uint32_t seq2)
746 {
747         return (int32_t)(seq1 - seq2) >= 0;
748 }
749
750 uint32_t
751 i915_get_gem_seqno(struct drm_device *dev)
752 {
753         drm_i915_private_t *dev_priv = dev->dev_private;
754
755         return READ_HWSP(dev_priv, I915_GEM_HWS_INDEX);
756 }
757
758 /**
759  * This function clears the request list as sequence numbers are passed.
760  */
761 void
762 i915_gem_retire_requests(struct drm_device *dev)
763 {
764         drm_i915_private_t *dev_priv = dev->dev_private;
765         uint32_t seqno;
766
767         seqno = i915_get_gem_seqno(dev);
768
769         while (!list_empty(&dev_priv->mm.request_list)) {
770                 struct drm_i915_gem_request *request;
771                 uint32_t retiring_seqno;
772
773                 request = list_first_entry(&dev_priv->mm.request_list,
774                                            struct drm_i915_gem_request,
775                                            list);
776                 retiring_seqno = request->seqno;
777
778                 if (i915_seqno_passed(seqno, retiring_seqno) ||
779                     dev_priv->mm.wedged) {
780                         i915_gem_retire_request(dev, request);
781
782                         list_del(&request->list);
783                         drm_free(request, sizeof(*request), DRM_MEM_DRIVER);
784                 } else
785                         break;
786         }
787 }
788
789 void
790 i915_gem_retire_work_handler(struct work_struct *work)
791 {
792         drm_i915_private_t *dev_priv;
793         struct drm_device *dev;
794
795         dev_priv = container_of(work, drm_i915_private_t,
796                                 mm.retire_work.work);
797         dev = dev_priv->dev;
798
799         mutex_lock(&dev->struct_mutex);
800         i915_gem_retire_requests(dev);
801         if (!dev_priv->mm.suspended &&
802             !list_empty(&dev_priv->mm.request_list))
803                 schedule_delayed_work(&dev_priv->mm.retire_work, HZ);
804         mutex_unlock(&dev->struct_mutex);
805 }
806
807 /**
808  * Waits for a sequence number to be signaled, and cleans up the
809  * request and object lists appropriately for that event.
810  */
811 static int
812 i915_wait_request(struct drm_device *dev, uint32_t seqno)
813 {
814         drm_i915_private_t *dev_priv = dev->dev_private;
815         int ret = 0;
816
817         BUG_ON(seqno == 0);
818
819         if (!i915_seqno_passed(i915_get_gem_seqno(dev), seqno)) {
820                 dev_priv->mm.waiting_gem_seqno = seqno;
821                 i915_user_irq_get(dev);
822                 ret = wait_event_interruptible(dev_priv->irq_queue,
823                                                i915_seqno_passed(i915_get_gem_seqno(dev),
824                                                                  seqno) ||
825                                                dev_priv->mm.wedged);
826                 i915_user_irq_put(dev);
827                 dev_priv->mm.waiting_gem_seqno = 0;
828         }
829         if (dev_priv->mm.wedged)
830                 ret = -EIO;
831
832         if (ret && ret != -ERESTARTSYS)
833                 DRM_ERROR("%s returns %d (awaiting %d at %d)\n",
834                           __func__, ret, seqno, i915_get_gem_seqno(dev));
835
836         /* Directly dispatch request retiring.  While we have the work queue
837          * to handle this, the waiter on a request often wants an associated
838          * buffer to have made it to the inactive list, and we would need
839          * a separate wait queue to handle that.
840          */
841         if (ret == 0)
842                 i915_gem_retire_requests(dev);
843
844         return ret;
845 }
846
847 static void
848 i915_gem_flush(struct drm_device *dev,
849                uint32_t invalidate_domains,
850                uint32_t flush_domains)
851 {
852         drm_i915_private_t *dev_priv = dev->dev_private;
853         uint32_t cmd;
854         RING_LOCALS;
855
856 #if WATCH_EXEC
857         DRM_INFO("%s: invalidate %08x flush %08x\n", __func__,
858                   invalidate_domains, flush_domains);
859 #endif
860
861         if (flush_domains & I915_GEM_DOMAIN_CPU)
862                 drm_agp_chipset_flush(dev);
863
864         if ((invalidate_domains | flush_domains) & ~(I915_GEM_DOMAIN_CPU |
865                                                      I915_GEM_DOMAIN_GTT)) {
866                 /*
867                  * read/write caches:
868                  *
869                  * I915_GEM_DOMAIN_RENDER is always invalidated, but is
870                  * only flushed if MI_NO_WRITE_FLUSH is unset.  On 965, it is
871                  * also flushed at 2d versus 3d pipeline switches.
872                  *
873                  * read-only caches:
874                  *
875                  * I915_GEM_DOMAIN_SAMPLER is flushed on pre-965 if
876                  * MI_READ_FLUSH is set, and is always flushed on 965.
877                  *
878                  * I915_GEM_DOMAIN_COMMAND may not exist?
879                  *
880                  * I915_GEM_DOMAIN_INSTRUCTION, which exists on 965, is
881                  * invalidated when MI_EXE_FLUSH is set.
882                  *
883                  * I915_GEM_DOMAIN_VERTEX, which exists on 965, is
884                  * invalidated with every MI_FLUSH.
885                  *
886                  * TLBs:
887                  *
888                  * On 965, TLBs associated with I915_GEM_DOMAIN_COMMAND
889                  * and I915_GEM_DOMAIN_CPU in are invalidated at PTE write and
890                  * I915_GEM_DOMAIN_RENDER and I915_GEM_DOMAIN_SAMPLER
891                  * are flushed at any MI_FLUSH.
892                  */
893
894                 cmd = MI_FLUSH | MI_NO_WRITE_FLUSH;
895                 if ((invalidate_domains|flush_domains) &
896                     I915_GEM_DOMAIN_RENDER)
897                         cmd &= ~MI_NO_WRITE_FLUSH;
898                 if (!IS_I965G(dev)) {
899                         /*
900                          * On the 965, the sampler cache always gets flushed
901                          * and this bit is reserved.
902                          */
903                         if (invalidate_domains & I915_GEM_DOMAIN_SAMPLER)
904                                 cmd |= MI_READ_FLUSH;
905                 }
906                 if (invalidate_domains & I915_GEM_DOMAIN_INSTRUCTION)
907                         cmd |= MI_EXE_FLUSH;
908
909 #if WATCH_EXEC
910                 DRM_INFO("%s: queue flush %08x to ring\n", __func__, cmd);
911 #endif
912                 BEGIN_LP_RING(2);
913                 OUT_RING(cmd);
914                 OUT_RING(0); /* noop */
915                 ADVANCE_LP_RING();
916         }
917 }
918
919 /**
920  * Ensures that all rendering to the object has completed and the object is
921  * safe to unbind from the GTT or access from the CPU.
922  */
923 static int
924 i915_gem_object_wait_rendering(struct drm_gem_object *obj)
925 {
926         struct drm_device *dev = obj->dev;
927         struct drm_i915_gem_object *obj_priv = obj->driver_private;
928         int ret;
929
930         /* This function only exists to support waiting for existing rendering,
931          * not for emitting required flushes.
932          */
933         BUG_ON((obj->write_domain & I915_GEM_GPU_DOMAINS) != 0);
934
935         /* If there is rendering queued on the buffer being evicted, wait for
936          * it.
937          */
938         if (obj_priv->active) {
939 #if WATCH_BUF
940                 DRM_INFO("%s: object %p wait for seqno %08x\n",
941                           __func__, obj, obj_priv->last_rendering_seqno);
942 #endif
943                 ret = i915_wait_request(dev, obj_priv->last_rendering_seqno);
944                 if (ret != 0)
945                         return ret;
946         }
947
948         return 0;
949 }
950
951 /**
952  * Unbinds an object from the GTT aperture.
953  */
954 static int
955 i915_gem_object_unbind(struct drm_gem_object *obj)
956 {
957         struct drm_device *dev = obj->dev;
958         struct drm_i915_gem_object *obj_priv = obj->driver_private;
959         int ret = 0;
960
961 #if WATCH_BUF
962         DRM_INFO("%s:%d %p\n", __func__, __LINE__, obj);
963         DRM_INFO("gtt_space %p\n", obj_priv->gtt_space);
964 #endif
965         if (obj_priv->gtt_space == NULL)
966                 return 0;
967
968         if (obj_priv->pin_count != 0) {
969                 DRM_ERROR("Attempting to unbind pinned buffer\n");
970                 return -EINVAL;
971         }
972
973         /* Move the object to the CPU domain to ensure that
974          * any possible CPU writes while it's not in the GTT
975          * are flushed when we go to remap it. This will
976          * also ensure that all pending GPU writes are finished
977          * before we unbind.
978          */
979         ret = i915_gem_object_set_to_cpu_domain(obj, 1);
980         if (ret) {
981                 if (ret != -ERESTARTSYS)
982                         DRM_ERROR("set_domain failed: %d\n", ret);
983                 return ret;
984         }
985
986         if (obj_priv->agp_mem != NULL) {
987                 drm_unbind_agp(obj_priv->agp_mem);
988                 drm_free_agp(obj_priv->agp_mem, obj->size / PAGE_SIZE);
989                 obj_priv->agp_mem = NULL;
990         }
991
992         BUG_ON(obj_priv->active);
993
994         i915_gem_object_free_page_list(obj);
995
996         if (obj_priv->gtt_space) {
997                 atomic_dec(&dev->gtt_count);
998                 atomic_sub(obj->size, &dev->gtt_memory);
999
1000                 drm_mm_put_block(obj_priv->gtt_space);
1001                 obj_priv->gtt_space = NULL;
1002         }
1003
1004         /* Remove ourselves from the LRU list if present. */
1005         if (!list_empty(&obj_priv->list))
1006                 list_del_init(&obj_priv->list);
1007
1008         return 0;
1009 }
1010
1011 static int
1012 i915_gem_evict_something(struct drm_device *dev)
1013 {
1014         drm_i915_private_t *dev_priv = dev->dev_private;
1015         struct drm_gem_object *obj;
1016         struct drm_i915_gem_object *obj_priv;
1017         int ret = 0;
1018
1019         for (;;) {
1020                 /* If there's an inactive buffer available now, grab it
1021                  * and be done.
1022                  */
1023                 if (!list_empty(&dev_priv->mm.inactive_list)) {
1024                         obj_priv = list_first_entry(&dev_priv->mm.inactive_list,
1025                                                     struct drm_i915_gem_object,
1026                                                     list);
1027                         obj = obj_priv->obj;
1028                         BUG_ON(obj_priv->pin_count != 0);
1029 #if WATCH_LRU
1030                         DRM_INFO("%s: evicting %p\n", __func__, obj);
1031 #endif
1032                         BUG_ON(obj_priv->active);
1033
1034                         /* Wait on the rendering and unbind the buffer. */
1035                         ret = i915_gem_object_unbind(obj);
1036                         break;
1037                 }
1038
1039                 /* If we didn't get anything, but the ring is still processing
1040                  * things, wait for one of those things to finish and hopefully
1041                  * leave us a buffer to evict.
1042                  */
1043                 if (!list_empty(&dev_priv->mm.request_list)) {
1044                         struct drm_i915_gem_request *request;
1045
1046                         request = list_first_entry(&dev_priv->mm.request_list,
1047                                                    struct drm_i915_gem_request,
1048                                                    list);
1049
1050                         ret = i915_wait_request(dev, request->seqno);
1051                         if (ret)
1052                                 break;
1053
1054                         /* if waiting caused an object to become inactive,
1055                          * then loop around and wait for it. Otherwise, we
1056                          * assume that waiting freed and unbound something,
1057                          * so there should now be some space in the GTT
1058                          */
1059                         if (!list_empty(&dev_priv->mm.inactive_list))
1060                                 continue;
1061                         break;
1062                 }
1063
1064                 /* If we didn't have anything on the request list but there
1065                  * are buffers awaiting a flush, emit one and try again.
1066                  * When we wait on it, those buffers waiting for that flush
1067                  * will get moved to inactive.
1068                  */
1069                 if (!list_empty(&dev_priv->mm.flushing_list)) {
1070                         obj_priv = list_first_entry(&dev_priv->mm.flushing_list,
1071                                                     struct drm_i915_gem_object,
1072                                                     list);
1073                         obj = obj_priv->obj;
1074
1075                         i915_gem_flush(dev,
1076                                        obj->write_domain,
1077                                        obj->write_domain);
1078                         i915_add_request(dev, obj->write_domain);
1079
1080                         obj = NULL;
1081                         continue;
1082                 }
1083
1084                 DRM_ERROR("inactive empty %d request empty %d "
1085                           "flushing empty %d\n",
1086                           list_empty(&dev_priv->mm.inactive_list),
1087                           list_empty(&dev_priv->mm.request_list),
1088                           list_empty(&dev_priv->mm.flushing_list));
1089                 /* If we didn't do any of the above, there's nothing to be done
1090                  * and we just can't fit it in.
1091                  */
1092                 return -ENOMEM;
1093         }
1094         return ret;
1095 }
1096
1097 static int
1098 i915_gem_evict_everything(struct drm_device *dev)
1099 {
1100         int ret;
1101
1102         for (;;) {
1103                 ret = i915_gem_evict_something(dev);
1104                 if (ret != 0)
1105                         break;
1106         }
1107         if (ret == -ENOMEM)
1108                 return 0;
1109         return ret;
1110 }
1111
1112 static int
1113 i915_gem_object_get_page_list(struct drm_gem_object *obj)
1114 {
1115         struct drm_i915_gem_object *obj_priv = obj->driver_private;
1116         int page_count, i;
1117         struct address_space *mapping;
1118         struct inode *inode;
1119         struct page *page;
1120         int ret;
1121
1122         if (obj_priv->page_list)
1123                 return 0;
1124
1125         /* Get the list of pages out of our struct file.  They'll be pinned
1126          * at this point until we release them.
1127          */
1128         page_count = obj->size / PAGE_SIZE;
1129         BUG_ON(obj_priv->page_list != NULL);
1130         obj_priv->page_list = drm_calloc(page_count, sizeof(struct page *),
1131                                          DRM_MEM_DRIVER);
1132         if (obj_priv->page_list == NULL) {
1133                 DRM_ERROR("Faled to allocate page list\n");
1134                 return -ENOMEM;
1135         }
1136
1137         inode = obj->filp->f_path.dentry->d_inode;
1138         mapping = inode->i_mapping;
1139         for (i = 0; i < page_count; i++) {
1140                 page = read_mapping_page(mapping, i, NULL);
1141                 if (IS_ERR(page)) {
1142                         ret = PTR_ERR(page);
1143                         DRM_ERROR("read_mapping_page failed: %d\n", ret);
1144                         i915_gem_object_free_page_list(obj);
1145                         return ret;
1146                 }
1147                 obj_priv->page_list[i] = page;
1148         }
1149         return 0;
1150 }
1151
1152 /**
1153  * Finds free space in the GTT aperture and binds the object there.
1154  */
1155 static int
1156 i915_gem_object_bind_to_gtt(struct drm_gem_object *obj, unsigned alignment)
1157 {
1158         struct drm_device *dev = obj->dev;
1159         drm_i915_private_t *dev_priv = dev->dev_private;
1160         struct drm_i915_gem_object *obj_priv = obj->driver_private;
1161         struct drm_mm_node *free_space;
1162         int page_count, ret;
1163
1164         if (alignment == 0)
1165                 alignment = PAGE_SIZE;
1166         if (alignment & (PAGE_SIZE - 1)) {
1167                 DRM_ERROR("Invalid object alignment requested %u\n", alignment);
1168                 return -EINVAL;
1169         }
1170
1171  search_free:
1172         free_space = drm_mm_search_free(&dev_priv->mm.gtt_space,
1173                                         obj->size, alignment, 0);
1174         if (free_space != NULL) {
1175                 obj_priv->gtt_space = drm_mm_get_block(free_space, obj->size,
1176                                                        alignment);
1177                 if (obj_priv->gtt_space != NULL) {
1178                         obj_priv->gtt_space->private = obj;
1179                         obj_priv->gtt_offset = obj_priv->gtt_space->start;
1180                 }
1181         }
1182         if (obj_priv->gtt_space == NULL) {
1183                 /* If the gtt is empty and we're still having trouble
1184                  * fitting our object in, we're out of memory.
1185                  */
1186 #if WATCH_LRU
1187                 DRM_INFO("%s: GTT full, evicting something\n", __func__);
1188 #endif
1189                 if (list_empty(&dev_priv->mm.inactive_list) &&
1190                     list_empty(&dev_priv->mm.flushing_list) &&
1191                     list_empty(&dev_priv->mm.active_list)) {
1192                         DRM_ERROR("GTT full, but LRU list empty\n");
1193                         return -ENOMEM;
1194                 }
1195
1196                 ret = i915_gem_evict_something(dev);
1197                 if (ret != 0) {
1198                         if (ret != -ERESTARTSYS)
1199                                 DRM_ERROR("Failed to evict a buffer %d\n", ret);
1200                         return ret;
1201                 }
1202                 goto search_free;
1203         }
1204
1205 #if WATCH_BUF
1206         DRM_INFO("Binding object of size %d at 0x%08x\n",
1207                  obj->size, obj_priv->gtt_offset);
1208 #endif
1209         ret = i915_gem_object_get_page_list(obj);
1210         if (ret) {
1211                 drm_mm_put_block(obj_priv->gtt_space);
1212                 obj_priv->gtt_space = NULL;
1213                 return ret;
1214         }
1215
1216         page_count = obj->size / PAGE_SIZE;
1217         /* Create an AGP memory structure pointing at our pages, and bind it
1218          * into the GTT.
1219          */
1220         obj_priv->agp_mem = drm_agp_bind_pages(dev,
1221                                                obj_priv->page_list,
1222                                                page_count,
1223                                                obj_priv->gtt_offset,
1224                                                obj_priv->agp_type);
1225         if (obj_priv->agp_mem == NULL) {
1226                 i915_gem_object_free_page_list(obj);
1227                 drm_mm_put_block(obj_priv->gtt_space);
1228                 obj_priv->gtt_space = NULL;
1229                 return -ENOMEM;
1230         }
1231         atomic_inc(&dev->gtt_count);
1232         atomic_add(obj->size, &dev->gtt_memory);
1233
1234         /* Assert that the object is not currently in any GPU domain. As it
1235          * wasn't in the GTT, there shouldn't be any way it could have been in
1236          * a GPU cache
1237          */
1238         BUG_ON(obj->read_domains & ~(I915_GEM_DOMAIN_CPU|I915_GEM_DOMAIN_GTT));
1239         BUG_ON(obj->write_domain & ~(I915_GEM_DOMAIN_CPU|I915_GEM_DOMAIN_GTT));
1240
1241         return 0;
1242 }
1243
1244 void
1245 i915_gem_clflush_object(struct drm_gem_object *obj)
1246 {
1247         struct drm_i915_gem_object      *obj_priv = obj->driver_private;
1248
1249         /* If we don't have a page list set up, then we're not pinned
1250          * to GPU, and we can ignore the cache flush because it'll happen
1251          * again at bind time.
1252          */
1253         if (obj_priv->page_list == NULL)
1254                 return;
1255
1256         drm_clflush_pages(obj_priv->page_list, obj->size / PAGE_SIZE);
1257 }
1258
1259 /** Flushes any GPU write domain for the object if it's dirty. */
1260 static void
1261 i915_gem_object_flush_gpu_write_domain(struct drm_gem_object *obj)
1262 {
1263         struct drm_device *dev = obj->dev;
1264         uint32_t seqno;
1265
1266         if ((obj->write_domain & I915_GEM_GPU_DOMAINS) == 0)
1267                 return;
1268
1269         /* Queue the GPU write cache flushing we need. */
1270         i915_gem_flush(dev, 0, obj->write_domain);
1271         seqno = i915_add_request(dev, obj->write_domain);
1272         obj->write_domain = 0;
1273         i915_gem_object_move_to_active(obj, seqno);
1274 }
1275
1276 /** Flushes the GTT write domain for the object if it's dirty. */
1277 static void
1278 i915_gem_object_flush_gtt_write_domain(struct drm_gem_object *obj)
1279 {
1280         if (obj->write_domain != I915_GEM_DOMAIN_GTT)
1281                 return;
1282
1283         /* No actual flushing is required for the GTT write domain.   Writes
1284          * to it immediately go to main memory as far as we know, so there's
1285          * no chipset flush.  It also doesn't land in render cache.
1286          */
1287         obj->write_domain = 0;
1288 }
1289
1290 /** Flushes the CPU write domain for the object if it's dirty. */
1291 static void
1292 i915_gem_object_flush_cpu_write_domain(struct drm_gem_object *obj)
1293 {
1294         struct drm_device *dev = obj->dev;
1295
1296         if (obj->write_domain != I915_GEM_DOMAIN_CPU)
1297                 return;
1298
1299         i915_gem_clflush_object(obj);
1300         drm_agp_chipset_flush(dev);
1301         obj->write_domain = 0;
1302 }
1303
1304 /**
1305  * Moves a single object to the GTT read, and possibly write domain.
1306  *
1307  * This function returns when the move is complete, including waiting on
1308  * flushes to occur.
1309  */
1310 static int
1311 i915_gem_object_set_to_gtt_domain(struct drm_gem_object *obj, int write)
1312 {
1313         struct drm_i915_gem_object *obj_priv = obj->driver_private;
1314         int ret;
1315
1316         /* Not valid to be called on unbound objects. */
1317         if (obj_priv->gtt_space == NULL)
1318                 return -EINVAL;
1319
1320         i915_gem_object_flush_gpu_write_domain(obj);
1321         /* Wait on any GPU rendering and flushing to occur. */
1322         ret = i915_gem_object_wait_rendering(obj);
1323         if (ret != 0)
1324                 return ret;
1325
1326         /* If we're writing through the GTT domain, then CPU and GPU caches
1327          * will need to be invalidated at next use.
1328          */
1329         if (write)
1330                 obj->read_domains &= I915_GEM_DOMAIN_GTT;
1331
1332         i915_gem_object_flush_cpu_write_domain(obj);
1333
1334         /* It should now be out of any other write domains, and we can update
1335          * the domain values for our changes.
1336          */
1337         BUG_ON((obj->write_domain & ~I915_GEM_DOMAIN_GTT) != 0);
1338         obj->read_domains |= I915_GEM_DOMAIN_GTT;
1339         if (write) {
1340                 obj->write_domain = I915_GEM_DOMAIN_GTT;
1341                 obj_priv->dirty = 1;
1342         }
1343
1344         return 0;
1345 }
1346
1347 /**
1348  * Moves a single object to the CPU read, and possibly write domain.
1349  *
1350  * This function returns when the move is complete, including waiting on
1351  * flushes to occur.
1352  */
1353 static int
1354 i915_gem_object_set_to_cpu_domain(struct drm_gem_object *obj, int write)
1355 {
1356         struct drm_device *dev = obj->dev;
1357         int ret;
1358
1359         i915_gem_object_flush_gpu_write_domain(obj);
1360         /* Wait on any GPU rendering and flushing to occur. */
1361         ret = i915_gem_object_wait_rendering(obj);
1362         if (ret != 0)
1363                 return ret;
1364
1365         i915_gem_object_flush_gtt_write_domain(obj);
1366
1367         /* If we have a partially-valid cache of the object in the CPU,
1368          * finish invalidating it and free the per-page flags.
1369          */
1370         i915_gem_object_set_to_full_cpu_read_domain(obj);
1371
1372         /* Flush the CPU cache if it's still invalid. */
1373         if ((obj->read_domains & I915_GEM_DOMAIN_CPU) == 0) {
1374                 i915_gem_clflush_object(obj);
1375                 drm_agp_chipset_flush(dev);
1376
1377                 obj->read_domains |= I915_GEM_DOMAIN_CPU;
1378         }
1379
1380         /* It should now be out of any other write domains, and we can update
1381          * the domain values for our changes.
1382          */
1383         BUG_ON((obj->write_domain & ~I915_GEM_DOMAIN_CPU) != 0);
1384
1385         /* If we're writing through the CPU, then the GPU read domains will
1386          * need to be invalidated at next use.
1387          */
1388         if (write) {
1389                 obj->read_domains &= I915_GEM_DOMAIN_CPU;
1390                 obj->write_domain = I915_GEM_DOMAIN_CPU;
1391         }
1392
1393         return 0;
1394 }
1395
1396 /*
1397  * Set the next domain for the specified object. This
1398  * may not actually perform the necessary flushing/invaliding though,
1399  * as that may want to be batched with other set_domain operations
1400  *
1401  * This is (we hope) the only really tricky part of gem. The goal
1402  * is fairly simple -- track which caches hold bits of the object
1403  * and make sure they remain coherent. A few concrete examples may
1404  * help to explain how it works. For shorthand, we use the notation
1405  * (read_domains, write_domain), e.g. (CPU, CPU) to indicate the
1406  * a pair of read and write domain masks.
1407  *
1408  * Case 1: the batch buffer
1409  *
1410  *      1. Allocated
1411  *      2. Written by CPU
1412  *      3. Mapped to GTT
1413  *      4. Read by GPU
1414  *      5. Unmapped from GTT
1415  *      6. Freed
1416  *
1417  *      Let's take these a step at a time
1418  *
1419  *      1. Allocated
1420  *              Pages allocated from the kernel may still have
1421  *              cache contents, so we set them to (CPU, CPU) always.
1422  *      2. Written by CPU (using pwrite)
1423  *              The pwrite function calls set_domain (CPU, CPU) and
1424  *              this function does nothing (as nothing changes)
1425  *      3. Mapped by GTT
1426  *              This function asserts that the object is not
1427  *              currently in any GPU-based read or write domains
1428  *      4. Read by GPU
1429  *              i915_gem_execbuffer calls set_domain (COMMAND, 0).
1430  *              As write_domain is zero, this function adds in the
1431  *              current read domains (CPU+COMMAND, 0).
1432  *              flush_domains is set to CPU.
1433  *              invalidate_domains is set to COMMAND
1434  *              clflush is run to get data out of the CPU caches
1435  *              then i915_dev_set_domain calls i915_gem_flush to
1436  *              emit an MI_FLUSH and drm_agp_chipset_flush
1437  *      5. Unmapped from GTT
1438  *              i915_gem_object_unbind calls set_domain (CPU, CPU)
1439  *              flush_domains and invalidate_domains end up both zero
1440  *              so no flushing/invalidating happens
1441  *      6. Freed
1442  *              yay, done
1443  *
1444  * Case 2: The shared render buffer
1445  *
1446  *      1. Allocated
1447  *      2. Mapped to GTT
1448  *      3. Read/written by GPU
1449  *      4. set_domain to (CPU,CPU)
1450  *      5. Read/written by CPU
1451  *      6. Read/written by GPU
1452  *
1453  *      1. Allocated
1454  *              Same as last example, (CPU, CPU)
1455  *      2. Mapped to GTT
1456  *              Nothing changes (assertions find that it is not in the GPU)
1457  *      3. Read/written by GPU
1458  *              execbuffer calls set_domain (RENDER, RENDER)
1459  *              flush_domains gets CPU
1460  *              invalidate_domains gets GPU
1461  *              clflush (obj)
1462  *              MI_FLUSH and drm_agp_chipset_flush
1463  *      4. set_domain (CPU, CPU)
1464  *              flush_domains gets GPU
1465  *              invalidate_domains gets CPU
1466  *              wait_rendering (obj) to make sure all drawing is complete.
1467  *              This will include an MI_FLUSH to get the data from GPU
1468  *              to memory
1469  *              clflush (obj) to invalidate the CPU cache
1470  *              Another MI_FLUSH in i915_gem_flush (eliminate this somehow?)
1471  *      5. Read/written by CPU
1472  *              cache lines are loaded and dirtied
1473  *      6. Read written by GPU
1474  *              Same as last GPU access
1475  *
1476  * Case 3: The constant buffer
1477  *
1478  *      1. Allocated
1479  *      2. Written by CPU
1480  *      3. Read by GPU
1481  *      4. Updated (written) by CPU again
1482  *      5. Read by GPU
1483  *
1484  *      1. Allocated
1485  *              (CPU, CPU)
1486  *      2. Written by CPU
1487  *              (CPU, CPU)
1488  *      3. Read by GPU
1489  *              (CPU+RENDER, 0)
1490  *              flush_domains = CPU
1491  *              invalidate_domains = RENDER
1492  *              clflush (obj)
1493  *              MI_FLUSH
1494  *              drm_agp_chipset_flush
1495  *      4. Updated (written) by CPU again
1496  *              (CPU, CPU)
1497  *              flush_domains = 0 (no previous write domain)
1498  *              invalidate_domains = 0 (no new read domains)
1499  *      5. Read by GPU
1500  *              (CPU+RENDER, 0)
1501  *              flush_domains = CPU
1502  *              invalidate_domains = RENDER
1503  *              clflush (obj)
1504  *              MI_FLUSH
1505  *              drm_agp_chipset_flush
1506  */
1507 static void
1508 i915_gem_object_set_to_gpu_domain(struct drm_gem_object *obj,
1509                                   uint32_t read_domains,
1510                                   uint32_t write_domain)
1511 {
1512         struct drm_device               *dev = obj->dev;
1513         struct drm_i915_gem_object      *obj_priv = obj->driver_private;
1514         uint32_t                        invalidate_domains = 0;
1515         uint32_t                        flush_domains = 0;
1516
1517         BUG_ON(read_domains & I915_GEM_DOMAIN_CPU);
1518         BUG_ON(write_domain == I915_GEM_DOMAIN_CPU);
1519
1520 #if WATCH_BUF
1521         DRM_INFO("%s: object %p read %08x -> %08x write %08x -> %08x\n",
1522                  __func__, obj,
1523                  obj->read_domains, read_domains,
1524                  obj->write_domain, write_domain);
1525 #endif
1526         /*
1527          * If the object isn't moving to a new write domain,
1528          * let the object stay in multiple read domains
1529          */
1530         if (write_domain == 0)
1531                 read_domains |= obj->read_domains;
1532         else
1533                 obj_priv->dirty = 1;
1534
1535         /*
1536          * Flush the current write domain if
1537          * the new read domains don't match. Invalidate
1538          * any read domains which differ from the old
1539          * write domain
1540          */
1541         if (obj->write_domain && obj->write_domain != read_domains) {
1542                 flush_domains |= obj->write_domain;
1543                 invalidate_domains |= read_domains & ~obj->write_domain;
1544         }
1545         /*
1546          * Invalidate any read caches which may have
1547          * stale data. That is, any new read domains.
1548          */
1549         invalidate_domains |= read_domains & ~obj->read_domains;
1550         if ((flush_domains | invalidate_domains) & I915_GEM_DOMAIN_CPU) {
1551 #if WATCH_BUF
1552                 DRM_INFO("%s: CPU domain flush %08x invalidate %08x\n",
1553                          __func__, flush_domains, invalidate_domains);
1554 #endif
1555                 i915_gem_clflush_object(obj);
1556         }
1557
1558         if ((write_domain | flush_domains) != 0)
1559                 obj->write_domain = write_domain;
1560         obj->read_domains = read_domains;
1561
1562         dev->invalidate_domains |= invalidate_domains;
1563         dev->flush_domains |= flush_domains;
1564 #if WATCH_BUF
1565         DRM_INFO("%s: read %08x write %08x invalidate %08x flush %08x\n",
1566                  __func__,
1567                  obj->read_domains, obj->write_domain,
1568                  dev->invalidate_domains, dev->flush_domains);
1569 #endif
1570 }
1571
1572 /**
1573  * Moves the object from a partially CPU read to a full one.
1574  *
1575  * Note that this only resolves i915_gem_object_set_cpu_read_domain_range(),
1576  * and doesn't handle transitioning from !(read_domains & I915_GEM_DOMAIN_CPU).
1577  */
1578 static void
1579 i915_gem_object_set_to_full_cpu_read_domain(struct drm_gem_object *obj)
1580 {
1581         struct drm_device *dev = obj->dev;
1582         struct drm_i915_gem_object *obj_priv = obj->driver_private;
1583
1584         if (!obj_priv->page_cpu_valid)
1585                 return;
1586
1587         /* If we're partially in the CPU read domain, finish moving it in.
1588          */
1589         if (obj->read_domains & I915_GEM_DOMAIN_CPU) {
1590                 int i;
1591
1592                 for (i = 0; i <= (obj->size - 1) / PAGE_SIZE; i++) {
1593                         if (obj_priv->page_cpu_valid[i])
1594                                 continue;
1595                         drm_clflush_pages(obj_priv->page_list + i, 1);
1596                 }
1597                 drm_agp_chipset_flush(dev);
1598         }
1599
1600         /* Free the page_cpu_valid mappings which are now stale, whether
1601          * or not we've got I915_GEM_DOMAIN_CPU.
1602          */
1603         drm_free(obj_priv->page_cpu_valid, obj->size / PAGE_SIZE,
1604                  DRM_MEM_DRIVER);
1605         obj_priv->page_cpu_valid = NULL;
1606 }
1607
1608 /**
1609  * Set the CPU read domain on a range of the object.
1610  *
1611  * The object ends up with I915_GEM_DOMAIN_CPU in its read flags although it's
1612  * not entirely valid.  The page_cpu_valid member of the object flags which
1613  * pages have been flushed, and will be respected by
1614  * i915_gem_object_set_to_cpu_domain() if it's called on to get a valid mapping
1615  * of the whole object.
1616  *
1617  * This function returns when the move is complete, including waiting on
1618  * flushes to occur.
1619  */
1620 static int
1621 i915_gem_object_set_cpu_read_domain_range(struct drm_gem_object *obj,
1622                                           uint64_t offset, uint64_t size)
1623 {
1624         struct drm_i915_gem_object *obj_priv = obj->driver_private;
1625         int i, ret;
1626
1627         if (offset == 0 && size == obj->size)
1628                 return i915_gem_object_set_to_cpu_domain(obj, 0);
1629
1630         i915_gem_object_flush_gpu_write_domain(obj);
1631         /* Wait on any GPU rendering and flushing to occur. */
1632         ret = i915_gem_object_wait_rendering(obj);
1633         if (ret != 0)
1634                 return ret;
1635         i915_gem_object_flush_gtt_write_domain(obj);
1636
1637         /* If we're already fully in the CPU read domain, we're done. */
1638         if (obj_priv->page_cpu_valid == NULL &&
1639             (obj->read_domains & I915_GEM_DOMAIN_CPU) != 0)
1640                 return 0;
1641
1642         /* Otherwise, create/clear the per-page CPU read domain flag if we're
1643          * newly adding I915_GEM_DOMAIN_CPU
1644          */
1645         if (obj_priv->page_cpu_valid == NULL) {
1646                 obj_priv->page_cpu_valid = drm_calloc(1, obj->size / PAGE_SIZE,
1647                                                       DRM_MEM_DRIVER);
1648                 if (obj_priv->page_cpu_valid == NULL)
1649                         return -ENOMEM;
1650         } else if ((obj->read_domains & I915_GEM_DOMAIN_CPU) == 0)
1651                 memset(obj_priv->page_cpu_valid, 0, obj->size / PAGE_SIZE);
1652
1653         /* Flush the cache on any pages that are still invalid from the CPU's
1654          * perspective.
1655          */
1656         for (i = offset / PAGE_SIZE; i <= (offset + size - 1) / PAGE_SIZE;
1657              i++) {
1658                 if (obj_priv->page_cpu_valid[i])
1659                         continue;
1660
1661                 drm_clflush_pages(obj_priv->page_list + i, 1);
1662
1663                 obj_priv->page_cpu_valid[i] = 1;
1664         }
1665
1666         /* It should now be out of any other write domains, and we can update
1667          * the domain values for our changes.
1668          */
1669         BUG_ON((obj->write_domain & ~I915_GEM_DOMAIN_CPU) != 0);
1670
1671         obj->read_domains |= I915_GEM_DOMAIN_CPU;
1672
1673         return 0;
1674 }
1675
1676 /**
1677  * Pin an object to the GTT and evaluate the relocations landing in it.
1678  */
1679 static int
1680 i915_gem_object_pin_and_relocate(struct drm_gem_object *obj,
1681                                  struct drm_file *file_priv,
1682                                  struct drm_i915_gem_exec_object *entry)
1683 {
1684         struct drm_device *dev = obj->dev;
1685         drm_i915_private_t *dev_priv = dev->dev_private;
1686         struct drm_i915_gem_relocation_entry reloc;
1687         struct drm_i915_gem_relocation_entry __user *relocs;
1688         struct drm_i915_gem_object *obj_priv = obj->driver_private;
1689         int i, ret;
1690         void __iomem *reloc_page;
1691
1692         /* Choose the GTT offset for our buffer and put it there. */
1693         ret = i915_gem_object_pin(obj, (uint32_t) entry->alignment);
1694         if (ret)
1695                 return ret;
1696
1697         entry->offset = obj_priv->gtt_offset;
1698
1699         relocs = (struct drm_i915_gem_relocation_entry __user *)
1700                  (uintptr_t) entry->relocs_ptr;
1701         /* Apply the relocations, using the GTT aperture to avoid cache
1702          * flushing requirements.
1703          */
1704         for (i = 0; i < entry->relocation_count; i++) {
1705                 struct drm_gem_object *target_obj;
1706                 struct drm_i915_gem_object *target_obj_priv;
1707                 uint32_t reloc_val, reloc_offset;
1708                 uint32_t __iomem *reloc_entry;
1709
1710                 ret = copy_from_user(&reloc, relocs + i, sizeof(reloc));
1711                 if (ret != 0) {
1712                         i915_gem_object_unpin(obj);
1713                         return ret;
1714                 }
1715
1716                 target_obj = drm_gem_object_lookup(obj->dev, file_priv,
1717                                                    reloc.target_handle);
1718                 if (target_obj == NULL) {
1719                         i915_gem_object_unpin(obj);
1720                         return -EBADF;
1721                 }
1722                 target_obj_priv = target_obj->driver_private;
1723
1724                 /* The target buffer should have appeared before us in the
1725                  * exec_object list, so it should have a GTT space bound by now.
1726                  */
1727                 if (target_obj_priv->gtt_space == NULL) {
1728                         DRM_ERROR("No GTT space found for object %d\n",
1729                                   reloc.target_handle);
1730                         drm_gem_object_unreference(target_obj);
1731                         i915_gem_object_unpin(obj);
1732                         return -EINVAL;
1733                 }
1734
1735                 if (reloc.offset > obj->size - 4) {
1736                         DRM_ERROR("Relocation beyond object bounds: "
1737                                   "obj %p target %d offset %d size %d.\n",
1738                                   obj, reloc.target_handle,
1739                                   (int) reloc.offset, (int) obj->size);
1740                         drm_gem_object_unreference(target_obj);
1741                         i915_gem_object_unpin(obj);
1742                         return -EINVAL;
1743                 }
1744                 if (reloc.offset & 3) {
1745                         DRM_ERROR("Relocation not 4-byte aligned: "
1746                                   "obj %p target %d offset %d.\n",
1747                                   obj, reloc.target_handle,
1748                                   (int) reloc.offset);
1749                         drm_gem_object_unreference(target_obj);
1750                         i915_gem_object_unpin(obj);
1751                         return -EINVAL;
1752                 }
1753
1754                 if (reloc.write_domain & I915_GEM_DOMAIN_CPU ||
1755                     reloc.read_domains & I915_GEM_DOMAIN_CPU) {
1756                         DRM_ERROR("reloc with read/write CPU domains: "
1757                                   "obj %p target %d offset %d "
1758                                   "read %08x write %08x",
1759                                   obj, reloc.target_handle,
1760                                   (int) reloc.offset,
1761                                   reloc.read_domains,
1762                                   reloc.write_domain);
1763                         return -EINVAL;
1764                 }
1765
1766                 if (reloc.write_domain && target_obj->pending_write_domain &&
1767                     reloc.write_domain != target_obj->pending_write_domain) {
1768                         DRM_ERROR("Write domain conflict: "
1769                                   "obj %p target %d offset %d "
1770                                   "new %08x old %08x\n",
1771                                   obj, reloc.target_handle,
1772                                   (int) reloc.offset,
1773                                   reloc.write_domain,
1774                                   target_obj->pending_write_domain);
1775                         drm_gem_object_unreference(target_obj);
1776                         i915_gem_object_unpin(obj);
1777                         return -EINVAL;
1778                 }
1779
1780 #if WATCH_RELOC
1781                 DRM_INFO("%s: obj %p offset %08x target %d "
1782                          "read %08x write %08x gtt %08x "
1783                          "presumed %08x delta %08x\n",
1784                          __func__,
1785                          obj,
1786                          (int) reloc.offset,
1787                          (int) reloc.target_handle,
1788                          (int) reloc.read_domains,
1789                          (int) reloc.write_domain,
1790                          (int) target_obj_priv->gtt_offset,
1791                          (int) reloc.presumed_offset,
1792                          reloc.delta);
1793 #endif
1794
1795                 target_obj->pending_read_domains |= reloc.read_domains;
1796                 target_obj->pending_write_domain |= reloc.write_domain;
1797
1798                 /* If the relocation already has the right value in it, no
1799                  * more work needs to be done.
1800                  */
1801                 if (target_obj_priv->gtt_offset == reloc.presumed_offset) {
1802                         drm_gem_object_unreference(target_obj);
1803                         continue;
1804                 }
1805
1806                 ret = i915_gem_object_set_to_gtt_domain(obj, 1);
1807                 if (ret != 0) {
1808                         drm_gem_object_unreference(target_obj);
1809                         i915_gem_object_unpin(obj);
1810                         return -EINVAL;
1811                 }
1812
1813                 /* Map the page containing the relocation we're going to
1814                  * perform.
1815                  */
1816                 reloc_offset = obj_priv->gtt_offset + reloc.offset;
1817                 reloc_page = io_mapping_map_atomic_wc(dev_priv->mm.gtt_mapping,
1818                                                       (reloc_offset &
1819                                                        ~(PAGE_SIZE - 1)));
1820                 reloc_entry = (uint32_t __iomem *)(reloc_page +
1821                                                    (reloc_offset & (PAGE_SIZE - 1)));
1822                 reloc_val = target_obj_priv->gtt_offset + reloc.delta;
1823
1824 #if WATCH_BUF
1825                 DRM_INFO("Applied relocation: %p@0x%08x %08x -> %08x\n",
1826                           obj, (unsigned int) reloc.offset,
1827                           readl(reloc_entry), reloc_val);
1828 #endif
1829                 writel(reloc_val, reloc_entry);
1830                 io_mapping_unmap_atomic(reloc_page);
1831
1832                 /* Write the updated presumed offset for this entry back out
1833                  * to the user.
1834                  */
1835                 reloc.presumed_offset = target_obj_priv->gtt_offset;
1836                 ret = copy_to_user(relocs + i, &reloc, sizeof(reloc));
1837                 if (ret != 0) {
1838                         drm_gem_object_unreference(target_obj);
1839                         i915_gem_object_unpin(obj);
1840                         return ret;
1841                 }
1842
1843                 drm_gem_object_unreference(target_obj);
1844         }
1845
1846 #if WATCH_BUF
1847         if (0)
1848                 i915_gem_dump_object(obj, 128, __func__, ~0);
1849 #endif
1850         return 0;
1851 }
1852
1853 /** Dispatch a batchbuffer to the ring
1854  */
1855 static int
1856 i915_dispatch_gem_execbuffer(struct drm_device *dev,
1857                               struct drm_i915_gem_execbuffer *exec,
1858                               uint64_t exec_offset)
1859 {
1860         drm_i915_private_t *dev_priv = dev->dev_private;
1861         struct drm_clip_rect __user *boxes = (struct drm_clip_rect __user *)
1862                                              (uintptr_t) exec->cliprects_ptr;
1863         int nbox = exec->num_cliprects;
1864         int i = 0, count;
1865         uint32_t        exec_start, exec_len;
1866         RING_LOCALS;
1867
1868         exec_start = (uint32_t) exec_offset + exec->batch_start_offset;
1869         exec_len = (uint32_t) exec->batch_len;
1870
1871         if ((exec_start | exec_len) & 0x7) {
1872                 DRM_ERROR("alignment\n");
1873                 return -EINVAL;
1874         }
1875
1876         if (!exec_start)
1877                 return -EINVAL;
1878
1879         count = nbox ? nbox : 1;
1880
1881         for (i = 0; i < count; i++) {
1882                 if (i < nbox) {
1883                         int ret = i915_emit_box(dev, boxes, i,
1884                                                 exec->DR1, exec->DR4);
1885                         if (ret)
1886                                 return ret;
1887                 }
1888
1889                 if (IS_I830(dev) || IS_845G(dev)) {
1890                         BEGIN_LP_RING(4);
1891                         OUT_RING(MI_BATCH_BUFFER);
1892                         OUT_RING(exec_start | MI_BATCH_NON_SECURE);
1893                         OUT_RING(exec_start + exec_len - 4);
1894                         OUT_RING(0);
1895                         ADVANCE_LP_RING();
1896                 } else {
1897                         BEGIN_LP_RING(2);
1898                         if (IS_I965G(dev)) {
1899                                 OUT_RING(MI_BATCH_BUFFER_START |
1900                                          (2 << 6) |
1901                                          MI_BATCH_NON_SECURE_I965);
1902                                 OUT_RING(exec_start);
1903                         } else {
1904                                 OUT_RING(MI_BATCH_BUFFER_START |
1905                                          (2 << 6));
1906                                 OUT_RING(exec_start | MI_BATCH_NON_SECURE);
1907                         }
1908                         ADVANCE_LP_RING();
1909                 }
1910         }
1911
1912         /* XXX breadcrumb */
1913         return 0;
1914 }
1915
1916 /* Throttle our rendering by waiting until the ring has completed our requests
1917  * emitted over 20 msec ago.
1918  *
1919  * This should get us reasonable parallelism between CPU and GPU but also
1920  * relatively low latency when blocking on a particular request to finish.
1921  */
1922 static int
1923 i915_gem_ring_throttle(struct drm_device *dev, struct drm_file *file_priv)
1924 {
1925         struct drm_i915_file_private *i915_file_priv = file_priv->driver_priv;
1926         int ret = 0;
1927         uint32_t seqno;
1928
1929         mutex_lock(&dev->struct_mutex);
1930         seqno = i915_file_priv->mm.last_gem_throttle_seqno;
1931         i915_file_priv->mm.last_gem_throttle_seqno =
1932                 i915_file_priv->mm.last_gem_seqno;
1933         if (seqno)
1934                 ret = i915_wait_request(dev, seqno);
1935         mutex_unlock(&dev->struct_mutex);
1936         return ret;
1937 }
1938
1939 int
1940 i915_gem_execbuffer(struct drm_device *dev, void *data,
1941                     struct drm_file *file_priv)
1942 {
1943         drm_i915_private_t *dev_priv = dev->dev_private;
1944         struct drm_i915_file_private *i915_file_priv = file_priv->driver_priv;
1945         struct drm_i915_gem_execbuffer *args = data;
1946         struct drm_i915_gem_exec_object *exec_list = NULL;
1947         struct drm_gem_object **object_list = NULL;
1948         struct drm_gem_object *batch_obj;
1949         int ret, i, pinned = 0;
1950         uint64_t exec_offset;
1951         uint32_t seqno, flush_domains;
1952         int pin_tries;
1953
1954 #if WATCH_EXEC
1955         DRM_INFO("buffers_ptr %d buffer_count %d len %08x\n",
1956                   (int) args->buffers_ptr, args->buffer_count, args->batch_len);
1957 #endif
1958
1959         if (args->buffer_count < 1) {
1960                 DRM_ERROR("execbuf with %d buffers\n", args->buffer_count);
1961                 return -EINVAL;
1962         }
1963         /* Copy in the exec list from userland */
1964         exec_list = drm_calloc(sizeof(*exec_list), args->buffer_count,
1965                                DRM_MEM_DRIVER);
1966         object_list = drm_calloc(sizeof(*object_list), args->buffer_count,
1967                                  DRM_MEM_DRIVER);
1968         if (exec_list == NULL || object_list == NULL) {
1969                 DRM_ERROR("Failed to allocate exec or object list "
1970                           "for %d buffers\n",
1971                           args->buffer_count);
1972                 ret = -ENOMEM;
1973                 goto pre_mutex_err;
1974         }
1975         ret = copy_from_user(exec_list,
1976                              (struct drm_i915_relocation_entry __user *)
1977                              (uintptr_t) args->buffers_ptr,
1978                              sizeof(*exec_list) * args->buffer_count);
1979         if (ret != 0) {
1980                 DRM_ERROR("copy %d exec entries failed %d\n",
1981                           args->buffer_count, ret);
1982                 goto pre_mutex_err;
1983         }
1984
1985         mutex_lock(&dev->struct_mutex);
1986
1987         i915_verify_inactive(dev, __FILE__, __LINE__);
1988
1989         if (dev_priv->mm.wedged) {
1990                 DRM_ERROR("Execbuf while wedged\n");
1991                 mutex_unlock(&dev->struct_mutex);
1992                 return -EIO;
1993         }
1994
1995         if (dev_priv->mm.suspended) {
1996                 DRM_ERROR("Execbuf while VT-switched.\n");
1997                 mutex_unlock(&dev->struct_mutex);
1998                 return -EBUSY;
1999         }
2000
2001         /* Look up object handles */
2002         for (i = 0; i < args->buffer_count; i++) {
2003                 object_list[i] = drm_gem_object_lookup(dev, file_priv,
2004                                                        exec_list[i].handle);
2005                 if (object_list[i] == NULL) {
2006                         DRM_ERROR("Invalid object handle %d at index %d\n",
2007                                    exec_list[i].handle, i);
2008                         ret = -EBADF;
2009                         goto err;
2010                 }
2011         }
2012
2013         /* Pin and relocate */
2014         for (pin_tries = 0; ; pin_tries++) {
2015                 ret = 0;
2016                 for (i = 0; i < args->buffer_count; i++) {
2017                         object_list[i]->pending_read_domains = 0;
2018                         object_list[i]->pending_write_domain = 0;
2019                         ret = i915_gem_object_pin_and_relocate(object_list[i],
2020                                                                file_priv,
2021                                                                &exec_list[i]);
2022                         if (ret)
2023                                 break;
2024                         pinned = i + 1;
2025                 }
2026                 /* success */
2027                 if (ret == 0)
2028                         break;
2029
2030                 /* error other than GTT full, or we've already tried again */
2031                 if (ret != -ENOMEM || pin_tries >= 1) {
2032                         DRM_ERROR("Failed to pin buffers %d\n", ret);
2033                         goto err;
2034                 }
2035
2036                 /* unpin all of our buffers */
2037                 for (i = 0; i < pinned; i++)
2038                         i915_gem_object_unpin(object_list[i]);
2039
2040                 /* evict everyone we can from the aperture */
2041                 ret = i915_gem_evict_everything(dev);
2042                 if (ret)
2043                         goto err;
2044         }
2045
2046         /* Set the pending read domains for the batch buffer to COMMAND */
2047         batch_obj = object_list[args->buffer_count-1];
2048         batch_obj->pending_read_domains = I915_GEM_DOMAIN_COMMAND;
2049         batch_obj->pending_write_domain = 0;
2050
2051         i915_verify_inactive(dev, __FILE__, __LINE__);
2052
2053         /* Zero the global flush/invalidate flags. These
2054          * will be modified as new domains are computed
2055          * for each object
2056          */
2057         dev->invalidate_domains = 0;
2058         dev->flush_domains = 0;
2059
2060         for (i = 0; i < args->buffer_count; i++) {
2061                 struct drm_gem_object *obj = object_list[i];
2062
2063                 /* Compute new gpu domains and update invalidate/flush */
2064                 i915_gem_object_set_to_gpu_domain(obj,
2065                                                   obj->pending_read_domains,
2066                                                   obj->pending_write_domain);
2067         }
2068
2069         i915_verify_inactive(dev, __FILE__, __LINE__);
2070
2071         if (dev->invalidate_domains | dev->flush_domains) {
2072 #if WATCH_EXEC
2073                 DRM_INFO("%s: invalidate_domains %08x flush_domains %08x\n",
2074                           __func__,
2075                          dev->invalidate_domains,
2076                          dev->flush_domains);
2077 #endif
2078                 i915_gem_flush(dev,
2079                                dev->invalidate_domains,
2080                                dev->flush_domains);
2081                 if (dev->flush_domains)
2082                         (void)i915_add_request(dev, dev->flush_domains);
2083         }
2084
2085         i915_verify_inactive(dev, __FILE__, __LINE__);
2086
2087 #if WATCH_COHERENCY
2088         for (i = 0; i < args->buffer_count; i++) {
2089                 i915_gem_object_check_coherency(object_list[i],
2090                                                 exec_list[i].handle);
2091         }
2092 #endif
2093
2094         exec_offset = exec_list[args->buffer_count - 1].offset;
2095
2096 #if WATCH_EXEC
2097         i915_gem_dump_object(object_list[args->buffer_count - 1],
2098                               args->batch_len,
2099                               __func__,
2100                               ~0);
2101 #endif
2102
2103         /* Exec the batchbuffer */
2104         ret = i915_dispatch_gem_execbuffer(dev, args, exec_offset);
2105         if (ret) {
2106                 DRM_ERROR("dispatch failed %d\n", ret);
2107                 goto err;
2108         }
2109
2110         /*
2111          * Ensure that the commands in the batch buffer are
2112          * finished before the interrupt fires
2113          */
2114         flush_domains = i915_retire_commands(dev);
2115
2116         i915_verify_inactive(dev, __FILE__, __LINE__);
2117
2118         /*
2119          * Get a seqno representing the execution of the current buffer,
2120          * which we can wait on.  We would like to mitigate these interrupts,
2121          * likely by only creating seqnos occasionally (so that we have
2122          * *some* interrupts representing completion of buffers that we can
2123          * wait on when trying to clear up gtt space).
2124          */
2125         seqno = i915_add_request(dev, flush_domains);
2126         BUG_ON(seqno == 0);
2127         i915_file_priv->mm.last_gem_seqno = seqno;
2128         for (i = 0; i < args->buffer_count; i++) {
2129                 struct drm_gem_object *obj = object_list[i];
2130
2131                 i915_gem_object_move_to_active(obj, seqno);
2132 #if WATCH_LRU
2133                 DRM_INFO("%s: move to exec list %p\n", __func__, obj);
2134 #endif
2135         }
2136 #if WATCH_LRU
2137         i915_dump_lru(dev, __func__);
2138 #endif
2139
2140         i915_verify_inactive(dev, __FILE__, __LINE__);
2141
2142         /* Copy the new buffer offsets back to the user's exec list. */
2143         ret = copy_to_user((struct drm_i915_relocation_entry __user *)
2144                            (uintptr_t) args->buffers_ptr,
2145                            exec_list,
2146                            sizeof(*exec_list) * args->buffer_count);
2147         if (ret)
2148                 DRM_ERROR("failed to copy %d exec entries "
2149                           "back to user (%d)\n",
2150                            args->buffer_count, ret);
2151 err:
2152         if (object_list != NULL) {
2153                 for (i = 0; i < pinned; i++)
2154                         i915_gem_object_unpin(object_list[i]);
2155
2156                 for (i = 0; i < args->buffer_count; i++)
2157                         drm_gem_object_unreference(object_list[i]);
2158         }
2159         mutex_unlock(&dev->struct_mutex);
2160
2161 pre_mutex_err:
2162         drm_free(object_list, sizeof(*object_list) * args->buffer_count,
2163                  DRM_MEM_DRIVER);
2164         drm_free(exec_list, sizeof(*exec_list) * args->buffer_count,
2165                  DRM_MEM_DRIVER);
2166
2167         return ret;
2168 }
2169
2170 int
2171 i915_gem_object_pin(struct drm_gem_object *obj, uint32_t alignment)
2172 {
2173         struct drm_device *dev = obj->dev;
2174         struct drm_i915_gem_object *obj_priv = obj->driver_private;
2175         int ret;
2176
2177         i915_verify_inactive(dev, __FILE__, __LINE__);
2178         if (obj_priv->gtt_space == NULL) {
2179                 ret = i915_gem_object_bind_to_gtt(obj, alignment);
2180                 if (ret != 0) {
2181                         DRM_ERROR("Failure to bind: %d", ret);
2182                         return ret;
2183                 }
2184         }
2185         obj_priv->pin_count++;
2186
2187         /* If the object is not active and not pending a flush,
2188          * remove it from the inactive list
2189          */
2190         if (obj_priv->pin_count == 1) {
2191                 atomic_inc(&dev->pin_count);
2192                 atomic_add(obj->size, &dev->pin_memory);
2193                 if (!obj_priv->active &&
2194                     (obj->write_domain & ~(I915_GEM_DOMAIN_CPU |
2195                                            I915_GEM_DOMAIN_GTT)) == 0 &&
2196                     !list_empty(&obj_priv->list))
2197                         list_del_init(&obj_priv->list);
2198         }
2199         i915_verify_inactive(dev, __FILE__, __LINE__);
2200
2201         return 0;
2202 }
2203
2204 void
2205 i915_gem_object_unpin(struct drm_gem_object *obj)
2206 {
2207         struct drm_device *dev = obj->dev;
2208         drm_i915_private_t *dev_priv = dev->dev_private;
2209         struct drm_i915_gem_object *obj_priv = obj->driver_private;
2210
2211         i915_verify_inactive(dev, __FILE__, __LINE__);
2212         obj_priv->pin_count--;
2213         BUG_ON(obj_priv->pin_count < 0);
2214         BUG_ON(obj_priv->gtt_space == NULL);
2215
2216         /* If the object is no longer pinned, and is
2217          * neither active nor being flushed, then stick it on
2218          * the inactive list
2219          */
2220         if (obj_priv->pin_count == 0) {
2221                 if (!obj_priv->active &&
2222                     (obj->write_domain & ~(I915_GEM_DOMAIN_CPU |
2223                                            I915_GEM_DOMAIN_GTT)) == 0)
2224                         list_move_tail(&obj_priv->list,
2225                                        &dev_priv->mm.inactive_list);
2226                 atomic_dec(&dev->pin_count);
2227                 atomic_sub(obj->size, &dev->pin_memory);
2228         }
2229         i915_verify_inactive(dev, __FILE__, __LINE__);
2230 }
2231
2232 int
2233 i915_gem_pin_ioctl(struct drm_device *dev, void *data,
2234                    struct drm_file *file_priv)
2235 {
2236         struct drm_i915_gem_pin *args = data;
2237         struct drm_gem_object *obj;
2238         struct drm_i915_gem_object *obj_priv;
2239         int ret;
2240
2241         mutex_lock(&dev->struct_mutex);
2242
2243         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
2244         if (obj == NULL) {
2245                 DRM_ERROR("Bad handle in i915_gem_pin_ioctl(): %d\n",
2246                           args->handle);
2247                 mutex_unlock(&dev->struct_mutex);
2248                 return -EBADF;
2249         }
2250         obj_priv = obj->driver_private;
2251
2252         ret = i915_gem_object_pin(obj, args->alignment);
2253         if (ret != 0) {
2254                 drm_gem_object_unreference(obj);
2255                 mutex_unlock(&dev->struct_mutex);
2256                 return ret;
2257         }
2258
2259         /* XXX - flush the CPU caches for pinned objects
2260          * as the X server doesn't manage domains yet
2261          */
2262         i915_gem_object_flush_cpu_write_domain(obj);
2263         args->offset = obj_priv->gtt_offset;
2264         drm_gem_object_unreference(obj);
2265         mutex_unlock(&dev->struct_mutex);
2266
2267         return 0;
2268 }
2269
2270 int
2271 i915_gem_unpin_ioctl(struct drm_device *dev, void *data,
2272                      struct drm_file *file_priv)
2273 {
2274         struct drm_i915_gem_pin *args = data;
2275         struct drm_gem_object *obj;
2276
2277         mutex_lock(&dev->struct_mutex);
2278
2279         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
2280         if (obj == NULL) {
2281                 DRM_ERROR("Bad handle in i915_gem_unpin_ioctl(): %d\n",
2282                           args->handle);
2283                 mutex_unlock(&dev->struct_mutex);
2284                 return -EBADF;
2285         }
2286
2287         i915_gem_object_unpin(obj);
2288
2289         drm_gem_object_unreference(obj);
2290         mutex_unlock(&dev->struct_mutex);
2291         return 0;
2292 }
2293
2294 int
2295 i915_gem_busy_ioctl(struct drm_device *dev, void *data,
2296                     struct drm_file *file_priv)
2297 {
2298         struct drm_i915_gem_busy *args = data;
2299         struct drm_gem_object *obj;
2300         struct drm_i915_gem_object *obj_priv;
2301
2302         mutex_lock(&dev->struct_mutex);
2303         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
2304         if (obj == NULL) {
2305                 DRM_ERROR("Bad handle in i915_gem_busy_ioctl(): %d\n",
2306                           args->handle);
2307                 mutex_unlock(&dev->struct_mutex);
2308                 return -EBADF;
2309         }
2310
2311         obj_priv = obj->driver_private;
2312         args->busy = obj_priv->active;
2313
2314         drm_gem_object_unreference(obj);
2315         mutex_unlock(&dev->struct_mutex);
2316         return 0;
2317 }
2318
2319 int
2320 i915_gem_throttle_ioctl(struct drm_device *dev, void *data,
2321                         struct drm_file *file_priv)
2322 {
2323     return i915_gem_ring_throttle(dev, file_priv);
2324 }
2325
2326 int i915_gem_init_object(struct drm_gem_object *obj)
2327 {
2328         struct drm_i915_gem_object *obj_priv;
2329
2330         obj_priv = drm_calloc(1, sizeof(*obj_priv), DRM_MEM_DRIVER);
2331         if (obj_priv == NULL)
2332                 return -ENOMEM;
2333
2334         /*
2335          * We've just allocated pages from the kernel,
2336          * so they've just been written by the CPU with
2337          * zeros. They'll need to be clflushed before we
2338          * use them with the GPU.
2339          */
2340         obj->write_domain = I915_GEM_DOMAIN_CPU;
2341         obj->read_domains = I915_GEM_DOMAIN_CPU;
2342
2343         obj_priv->agp_type = AGP_USER_MEMORY;
2344
2345         obj->driver_private = obj_priv;
2346         obj_priv->obj = obj;
2347         INIT_LIST_HEAD(&obj_priv->list);
2348         return 0;
2349 }
2350
2351 void i915_gem_free_object(struct drm_gem_object *obj)
2352 {
2353         struct drm_i915_gem_object *obj_priv = obj->driver_private;
2354
2355         while (obj_priv->pin_count > 0)
2356                 i915_gem_object_unpin(obj);
2357
2358         i915_gem_object_unbind(obj);
2359
2360         drm_free(obj_priv->page_cpu_valid, 1, DRM_MEM_DRIVER);
2361         drm_free(obj->driver_private, 1, DRM_MEM_DRIVER);
2362 }
2363
2364 /** Unbinds all objects that are on the given buffer list. */
2365 static int
2366 i915_gem_evict_from_list(struct drm_device *dev, struct list_head *head)
2367 {
2368         struct drm_gem_object *obj;
2369         struct drm_i915_gem_object *obj_priv;
2370         int ret;
2371
2372         while (!list_empty(head)) {
2373                 obj_priv = list_first_entry(head,
2374                                             struct drm_i915_gem_object,
2375                                             list);
2376                 obj = obj_priv->obj;
2377
2378                 if (obj_priv->pin_count != 0) {
2379                         DRM_ERROR("Pinned object in unbind list\n");
2380                         mutex_unlock(&dev->struct_mutex);
2381                         return -EINVAL;
2382                 }
2383
2384                 ret = i915_gem_object_unbind(obj);
2385                 if (ret != 0) {
2386                         DRM_ERROR("Error unbinding object in LeaveVT: %d\n",
2387                                   ret);
2388                         mutex_unlock(&dev->struct_mutex);
2389                         return ret;
2390                 }
2391         }
2392
2393
2394         return 0;
2395 }
2396
2397 static int
2398 i915_gem_idle(struct drm_device *dev)
2399 {
2400         drm_i915_private_t *dev_priv = dev->dev_private;
2401         uint32_t seqno, cur_seqno, last_seqno;
2402         int stuck, ret;
2403
2404         mutex_lock(&dev->struct_mutex);
2405
2406         if (dev_priv->mm.suspended || dev_priv->ring.ring_obj == NULL) {
2407                 mutex_unlock(&dev->struct_mutex);
2408                 return 0;
2409         }
2410
2411         /* Hack!  Don't let anybody do execbuf while we don't control the chip.
2412          * We need to replace this with a semaphore, or something.
2413          */
2414         dev_priv->mm.suspended = 1;
2415
2416         /* Cancel the retire work handler, wait for it to finish if running
2417          */
2418         mutex_unlock(&dev->struct_mutex);
2419         cancel_delayed_work_sync(&dev_priv->mm.retire_work);
2420         mutex_lock(&dev->struct_mutex);
2421
2422         i915_kernel_lost_context(dev);
2423
2424         /* Flush the GPU along with all non-CPU write domains
2425          */
2426         i915_gem_flush(dev, ~(I915_GEM_DOMAIN_CPU|I915_GEM_DOMAIN_GTT),
2427                        ~(I915_GEM_DOMAIN_CPU|I915_GEM_DOMAIN_GTT));
2428         seqno = i915_add_request(dev, ~(I915_GEM_DOMAIN_CPU |
2429                                         I915_GEM_DOMAIN_GTT));
2430
2431         if (seqno == 0) {
2432                 mutex_unlock(&dev->struct_mutex);
2433                 return -ENOMEM;
2434         }
2435
2436         dev_priv->mm.waiting_gem_seqno = seqno;
2437         last_seqno = 0;
2438         stuck = 0;
2439         for (;;) {
2440                 cur_seqno = i915_get_gem_seqno(dev);
2441                 if (i915_seqno_passed(cur_seqno, seqno))
2442                         break;
2443                 if (last_seqno == cur_seqno) {
2444                         if (stuck++ > 100) {
2445                                 DRM_ERROR("hardware wedged\n");
2446                                 dev_priv->mm.wedged = 1;
2447                                 DRM_WAKEUP(&dev_priv->irq_queue);
2448                                 break;
2449                         }
2450                 }
2451                 msleep(10);
2452                 last_seqno = cur_seqno;
2453         }
2454         dev_priv->mm.waiting_gem_seqno = 0;
2455
2456         i915_gem_retire_requests(dev);
2457
2458         if (!dev_priv->mm.wedged) {
2459                 /* Active and flushing should now be empty as we've
2460                  * waited for a sequence higher than any pending execbuffer
2461                  */
2462                 WARN_ON(!list_empty(&dev_priv->mm.active_list));
2463                 WARN_ON(!list_empty(&dev_priv->mm.flushing_list));
2464                 /* Request should now be empty as we've also waited
2465                  * for the last request in the list
2466                  */
2467                 WARN_ON(!list_empty(&dev_priv->mm.request_list));
2468         }
2469
2470         /* Empty the active and flushing lists to inactive.  If there's
2471          * anything left at this point, it means that we're wedged and
2472          * nothing good's going to happen by leaving them there.  So strip
2473          * the GPU domains and just stuff them onto inactive.
2474          */
2475         while (!list_empty(&dev_priv->mm.active_list)) {
2476                 struct drm_i915_gem_object *obj_priv;
2477
2478                 obj_priv = list_first_entry(&dev_priv->mm.active_list,
2479                                             struct drm_i915_gem_object,
2480                                             list);
2481                 obj_priv->obj->write_domain &= ~I915_GEM_GPU_DOMAINS;
2482                 i915_gem_object_move_to_inactive(obj_priv->obj);
2483         }
2484
2485         while (!list_empty(&dev_priv->mm.flushing_list)) {
2486                 struct drm_i915_gem_object *obj_priv;
2487
2488                 obj_priv = list_first_entry(&dev_priv->mm.flushing_list,
2489                                             struct drm_i915_gem_object,
2490                                             list);
2491                 obj_priv->obj->write_domain &= ~I915_GEM_GPU_DOMAINS;
2492                 i915_gem_object_move_to_inactive(obj_priv->obj);
2493         }
2494
2495
2496         /* Move all inactive buffers out of the GTT. */
2497         ret = i915_gem_evict_from_list(dev, &dev_priv->mm.inactive_list);
2498         WARN_ON(!list_empty(&dev_priv->mm.inactive_list));
2499         if (ret) {
2500                 mutex_unlock(&dev->struct_mutex);
2501                 return ret;
2502         }
2503
2504         i915_gem_cleanup_ringbuffer(dev);
2505         mutex_unlock(&dev->struct_mutex);
2506
2507         return 0;
2508 }
2509
2510 static int
2511 i915_gem_init_hws(struct drm_device *dev)
2512 {
2513         drm_i915_private_t *dev_priv = dev->dev_private;
2514         struct drm_gem_object *obj;
2515         struct drm_i915_gem_object *obj_priv;
2516         int ret;
2517
2518         /* If we need a physical address for the status page, it's already
2519          * initialized at driver load time.
2520          */
2521         if (!I915_NEED_GFX_HWS(dev))
2522                 return 0;
2523
2524         obj = drm_gem_object_alloc(dev, 4096);
2525         if (obj == NULL) {
2526                 DRM_ERROR("Failed to allocate status page\n");
2527                 return -ENOMEM;
2528         }
2529         obj_priv = obj->driver_private;
2530         obj_priv->agp_type = AGP_USER_CACHED_MEMORY;
2531
2532         ret = i915_gem_object_pin(obj, 4096);
2533         if (ret != 0) {
2534                 drm_gem_object_unreference(obj);
2535                 return ret;
2536         }
2537
2538         dev_priv->status_gfx_addr = obj_priv->gtt_offset;
2539
2540         dev_priv->hw_status_page = kmap(obj_priv->page_list[0]);
2541         if (dev_priv->hw_status_page == NULL) {
2542                 DRM_ERROR("Failed to map status page.\n");
2543                 memset(&dev_priv->hws_map, 0, sizeof(dev_priv->hws_map));
2544                 drm_gem_object_unreference(obj);
2545                 return -EINVAL;
2546         }
2547         dev_priv->hws_obj = obj;
2548         memset(dev_priv->hw_status_page, 0, PAGE_SIZE);
2549         I915_WRITE(HWS_PGA, dev_priv->status_gfx_addr);
2550         I915_READ(HWS_PGA); /* posting read */
2551         DRM_DEBUG("hws offset: 0x%08x\n", dev_priv->status_gfx_addr);
2552
2553         return 0;
2554 }
2555
2556 static int
2557 i915_gem_init_ringbuffer(struct drm_device *dev)
2558 {
2559         drm_i915_private_t *dev_priv = dev->dev_private;
2560         struct drm_gem_object *obj;
2561         struct drm_i915_gem_object *obj_priv;
2562         int ret;
2563         u32 head;
2564
2565         ret = i915_gem_init_hws(dev);
2566         if (ret != 0)
2567                 return ret;
2568
2569         obj = drm_gem_object_alloc(dev, 128 * 1024);
2570         if (obj == NULL) {
2571                 DRM_ERROR("Failed to allocate ringbuffer\n");
2572                 return -ENOMEM;
2573         }
2574         obj_priv = obj->driver_private;
2575
2576         ret = i915_gem_object_pin(obj, 4096);
2577         if (ret != 0) {
2578                 drm_gem_object_unreference(obj);
2579                 return ret;
2580         }
2581
2582         /* Set up the kernel mapping for the ring. */
2583         dev_priv->ring.Size = obj->size;
2584         dev_priv->ring.tail_mask = obj->size - 1;
2585
2586         dev_priv->ring.map.offset = dev->agp->base + obj_priv->gtt_offset;
2587         dev_priv->ring.map.size = obj->size;
2588         dev_priv->ring.map.type = 0;
2589         dev_priv->ring.map.flags = 0;
2590         dev_priv->ring.map.mtrr = 0;
2591
2592         drm_core_ioremap_wc(&dev_priv->ring.map, dev);
2593         if (dev_priv->ring.map.handle == NULL) {
2594                 DRM_ERROR("Failed to map ringbuffer.\n");
2595                 memset(&dev_priv->ring, 0, sizeof(dev_priv->ring));
2596                 drm_gem_object_unreference(obj);
2597                 return -EINVAL;
2598         }
2599         dev_priv->ring.ring_obj = obj;
2600         dev_priv->ring.virtual_start = dev_priv->ring.map.handle;
2601
2602         /* Stop the ring if it's running. */
2603         I915_WRITE(PRB0_CTL, 0);
2604         I915_WRITE(PRB0_TAIL, 0);
2605         I915_WRITE(PRB0_HEAD, 0);
2606
2607         /* Initialize the ring. */
2608         I915_WRITE(PRB0_START, obj_priv->gtt_offset);
2609         head = I915_READ(PRB0_HEAD) & HEAD_ADDR;
2610
2611         /* G45 ring initialization fails to reset head to zero */
2612         if (head != 0) {
2613                 DRM_ERROR("Ring head not reset to zero "
2614                           "ctl %08x head %08x tail %08x start %08x\n",
2615                           I915_READ(PRB0_CTL),
2616                           I915_READ(PRB0_HEAD),
2617                           I915_READ(PRB0_TAIL),
2618                           I915_READ(PRB0_START));
2619                 I915_WRITE(PRB0_HEAD, 0);
2620
2621                 DRM_ERROR("Ring head forced to zero "
2622                           "ctl %08x head %08x tail %08x start %08x\n",
2623                           I915_READ(PRB0_CTL),
2624                           I915_READ(PRB0_HEAD),
2625                           I915_READ(PRB0_TAIL),
2626                           I915_READ(PRB0_START));
2627         }
2628
2629         I915_WRITE(PRB0_CTL,
2630                    ((obj->size - 4096) & RING_NR_PAGES) |
2631                    RING_NO_REPORT |
2632                    RING_VALID);
2633
2634         head = I915_READ(PRB0_HEAD) & HEAD_ADDR;
2635
2636         /* If the head is still not zero, the ring is dead */
2637         if (head != 0) {
2638                 DRM_ERROR("Ring initialization failed "
2639                           "ctl %08x head %08x tail %08x start %08x\n",
2640                           I915_READ(PRB0_CTL),
2641                           I915_READ(PRB0_HEAD),
2642                           I915_READ(PRB0_TAIL),
2643                           I915_READ(PRB0_START));
2644                 return -EIO;
2645         }
2646
2647         /* Update our cache of the ring state */
2648         i915_kernel_lost_context(dev);
2649
2650         return 0;
2651 }
2652
2653 static void
2654 i915_gem_cleanup_ringbuffer(struct drm_device *dev)
2655 {
2656         drm_i915_private_t *dev_priv = dev->dev_private;
2657
2658         if (dev_priv->ring.ring_obj == NULL)
2659                 return;
2660
2661         drm_core_ioremapfree(&dev_priv->ring.map, dev);
2662
2663         i915_gem_object_unpin(dev_priv->ring.ring_obj);
2664         drm_gem_object_unreference(dev_priv->ring.ring_obj);
2665         dev_priv->ring.ring_obj = NULL;
2666         memset(&dev_priv->ring, 0, sizeof(dev_priv->ring));
2667
2668         if (dev_priv->hws_obj != NULL) {
2669                 struct drm_gem_object *obj = dev_priv->hws_obj;
2670                 struct drm_i915_gem_object *obj_priv = obj->driver_private;
2671
2672                 kunmap(obj_priv->page_list[0]);
2673                 i915_gem_object_unpin(obj);
2674                 drm_gem_object_unreference(obj);
2675                 dev_priv->hws_obj = NULL;
2676                 memset(&dev_priv->hws_map, 0, sizeof(dev_priv->hws_map));
2677                 dev_priv->hw_status_page = NULL;
2678
2679                 /* Write high address into HWS_PGA when disabling. */
2680                 I915_WRITE(HWS_PGA, 0x1ffff000);
2681         }
2682 }
2683
2684 int
2685 i915_gem_entervt_ioctl(struct drm_device *dev, void *data,
2686                        struct drm_file *file_priv)
2687 {
2688         drm_i915_private_t *dev_priv = dev->dev_private;
2689         int ret;
2690
2691         if (dev_priv->mm.wedged) {
2692                 DRM_ERROR("Reenabling wedged hardware, good luck\n");
2693                 dev_priv->mm.wedged = 0;
2694         }
2695
2696         ret = i915_gem_init_ringbuffer(dev);
2697         if (ret != 0)
2698                 return ret;
2699
2700         dev_priv->mm.gtt_mapping = io_mapping_create_wc(dev->agp->base,
2701                                                         dev->agp->agp_info.aper_size
2702                                                         * 1024 * 1024);
2703
2704         mutex_lock(&dev->struct_mutex);
2705         BUG_ON(!list_empty(&dev_priv->mm.active_list));
2706         BUG_ON(!list_empty(&dev_priv->mm.flushing_list));
2707         BUG_ON(!list_empty(&dev_priv->mm.inactive_list));
2708         BUG_ON(!list_empty(&dev_priv->mm.request_list));
2709         dev_priv->mm.suspended = 0;
2710         mutex_unlock(&dev->struct_mutex);
2711
2712         drm_irq_install(dev);
2713
2714         return 0;
2715 }
2716
2717 int
2718 i915_gem_leavevt_ioctl(struct drm_device *dev, void *data,
2719                        struct drm_file *file_priv)
2720 {
2721         drm_i915_private_t *dev_priv = dev->dev_private;
2722         int ret;
2723
2724         ret = i915_gem_idle(dev);
2725         drm_irq_uninstall(dev);
2726
2727         io_mapping_free(dev_priv->mm.gtt_mapping);
2728         return ret;
2729 }
2730
2731 void
2732 i915_gem_lastclose(struct drm_device *dev)
2733 {
2734         int ret;
2735
2736         ret = i915_gem_idle(dev);
2737         if (ret)
2738                 DRM_ERROR("failed to idle hardware: %d\n", ret);
2739 }
2740
2741 void
2742 i915_gem_load(struct drm_device *dev)
2743 {
2744         drm_i915_private_t *dev_priv = dev->dev_private;
2745
2746         INIT_LIST_HEAD(&dev_priv->mm.active_list);
2747         INIT_LIST_HEAD(&dev_priv->mm.flushing_list);
2748         INIT_LIST_HEAD(&dev_priv->mm.inactive_list);
2749         INIT_LIST_HEAD(&dev_priv->mm.request_list);
2750         INIT_DELAYED_WORK(&dev_priv->mm.retire_work,
2751                           i915_gem_retire_work_handler);
2752         dev_priv->mm.next_gem_seqno = 1;
2753
2754         i915_gem_detect_bit_6_swizzle(dev);
2755 }