drm/nv50: simplify bo moves now that they're all through the vm
[linux-2.6.git] / drivers / gpu / drm / nouveau / nouveau_dma.c
1 /*
2  * Copyright (C) 2007 Ben Skeggs.
3  * All Rights Reserved.
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining
6  * a copy of this software and associated documentation files (the
7  * "Software"), to deal in the Software without restriction, including
8  * without limitation the rights to use, copy, modify, merge, publish,
9  * distribute, sublicense, and/or sell copies of the Software, and to
10  * permit persons to whom the Software is furnished to do so, subject to
11  * the following conditions:
12  *
13  * The above copyright notice and this permission notice (including the
14  * next paragraph) shall be included in all copies or substantial
15  * portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24  *
25  */
26
27 #include "drmP.h"
28 #include "drm.h"
29 #include "nouveau_drv.h"
30 #include "nouveau_dma.h"
31 #include "nouveau_ramht.h"
32
33 void
34 nouveau_dma_pre_init(struct nouveau_channel *chan)
35 {
36         struct drm_nouveau_private *dev_priv = chan->dev->dev_private;
37         struct nouveau_bo *pushbuf = chan->pushbuf_bo;
38
39         if (dev_priv->card_type >= NV_50) {
40                 const int ib_size = pushbuf->bo.mem.size / 2;
41
42                 chan->dma.ib_base = (pushbuf->bo.mem.size - ib_size) >> 2;
43                 chan->dma.ib_max = (ib_size / 8) - 1;
44                 chan->dma.ib_put = 0;
45                 chan->dma.ib_free = chan->dma.ib_max - chan->dma.ib_put;
46
47                 chan->dma.max = (pushbuf->bo.mem.size - ib_size) >> 2;
48         } else {
49                 chan->dma.max  = (pushbuf->bo.mem.size >> 2) - 2;
50         }
51
52         chan->dma.put  = 0;
53         chan->dma.cur  = chan->dma.put;
54         chan->dma.free = chan->dma.max - chan->dma.cur;
55 }
56
57 int
58 nouveau_dma_init(struct nouveau_channel *chan)
59 {
60         struct drm_device *dev = chan->dev;
61         struct drm_nouveau_private *dev_priv = dev->dev_private;
62         int ret, i;
63
64         if (dev_priv->card_type >= NV_C0) {
65                 ret = nouveau_gpuobj_gr_new(chan, 0x9039, 0x9039);
66                 if (ret)
67                         return ret;
68
69                 ret = RING_SPACE(chan, 2);
70                 if (ret)
71                         return ret;
72
73                 BEGIN_NVC0(chan, 2, NvSubM2MF, 0x0000, 1);
74                 OUT_RING  (chan, 0x00009039);
75                 FIRE_RING (chan);
76                 return 0;
77         }
78
79         /* Create NV_MEMORY_TO_MEMORY_FORMAT for buffer moves */
80         ret = nouveau_gpuobj_gr_new(chan, NvM2MF, dev_priv->card_type < NV_50 ?
81                                     0x0039 : 0x5039);
82         if (ret)
83                 return ret;
84
85         /* NV_MEMORY_TO_MEMORY_FORMAT requires a notifier object */
86         ret = nouveau_notifier_alloc(chan, NvNotify0, 32, &chan->m2mf_ntfy);
87         if (ret)
88                 return ret;
89
90         /* Insert NOPS for NOUVEAU_DMA_SKIPS */
91         ret = RING_SPACE(chan, NOUVEAU_DMA_SKIPS);
92         if (ret)
93                 return ret;
94
95         for (i = 0; i < NOUVEAU_DMA_SKIPS; i++)
96                 OUT_RING(chan, 0);
97
98         /* Initialise NV_MEMORY_TO_MEMORY_FORMAT */
99         ret = RING_SPACE(chan, 6);
100         if (ret)
101                 return ret;
102         BEGIN_RING(chan, NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_NAME, 1);
103         OUT_RING  (chan, NvM2MF);
104         BEGIN_RING(chan, NvSubM2MF, NV_MEMORY_TO_MEMORY_FORMAT_DMA_NOTIFY, 3);
105         OUT_RING  (chan, NvNotify0);
106         OUT_RING  (chan, chan->vram_handle);
107         OUT_RING  (chan, chan->gart_handle);
108
109         /* Sit back and pray the channel works.. */
110         FIRE_RING(chan);
111
112         return 0;
113 }
114
115 void
116 OUT_RINGp(struct nouveau_channel *chan, const void *data, unsigned nr_dwords)
117 {
118         bool is_iomem;
119         u32 *mem = ttm_kmap_obj_virtual(&chan->pushbuf_bo->kmap, &is_iomem);
120         mem = &mem[chan->dma.cur];
121         if (is_iomem)
122                 memcpy_toio((void __force __iomem *)mem, data, nr_dwords * 4);
123         else
124                 memcpy(mem, data, nr_dwords * 4);
125         chan->dma.cur += nr_dwords;
126 }
127
128 /* Fetch and adjust GPU GET pointer
129  *
130  * Returns:
131  *  value >= 0, the adjusted GET pointer
132  *  -EINVAL if GET pointer currently outside main push buffer
133  *  -EBUSY if timeout exceeded
134  */
135 static inline int
136 READ_GET(struct nouveau_channel *chan, uint32_t *prev_get, uint32_t *timeout)
137 {
138         uint32_t val;
139
140         val = nvchan_rd32(chan, chan->user_get);
141
142         /* reset counter as long as GET is still advancing, this is
143          * to avoid misdetecting a GPU lockup if the GPU happens to
144          * just be processing an operation that takes a long time
145          */
146         if (val != *prev_get) {
147                 *prev_get = val;
148                 *timeout = 0;
149         }
150
151         if ((++*timeout & 0xff) == 0) {
152                 DRM_UDELAY(1);
153                 if (*timeout > 100000)
154                         return -EBUSY;
155         }
156
157         if (val < chan->pushbuf_base ||
158             val > chan->pushbuf_base + (chan->dma.max << 2))
159                 return -EINVAL;
160
161         return (val - chan->pushbuf_base) >> 2;
162 }
163
164 void
165 nv50_dma_push(struct nouveau_channel *chan, struct nouveau_bo *bo,
166               int delta, int length)
167 {
168         struct nouveau_bo *pb = chan->pushbuf_bo;
169         uint64_t offset = bo->bo.offset + delta;
170         int ip = (chan->dma.ib_put * 2) + chan->dma.ib_base;
171
172         BUG_ON(chan->dma.ib_free < 1);
173         nouveau_bo_wr32(pb, ip++, lower_32_bits(offset));
174         nouveau_bo_wr32(pb, ip++, upper_32_bits(offset) | length << 8);
175
176         chan->dma.ib_put = (chan->dma.ib_put + 1) & chan->dma.ib_max;
177
178         DRM_MEMORYBARRIER();
179         /* Flush writes. */
180         nouveau_bo_rd32(pb, 0);
181
182         nvchan_wr32(chan, 0x8c, chan->dma.ib_put);
183         chan->dma.ib_free--;
184 }
185
186 static int
187 nv50_dma_push_wait(struct nouveau_channel *chan, int count)
188 {
189         uint32_t cnt = 0, prev_get = 0;
190
191         while (chan->dma.ib_free < count) {
192                 uint32_t get = nvchan_rd32(chan, 0x88);
193                 if (get != prev_get) {
194                         prev_get = get;
195                         cnt = 0;
196                 }
197
198                 if ((++cnt & 0xff) == 0) {
199                         DRM_UDELAY(1);
200                         if (cnt > 100000)
201                                 return -EBUSY;
202                 }
203
204                 chan->dma.ib_free = get - chan->dma.ib_put;
205                 if (chan->dma.ib_free <= 0)
206                         chan->dma.ib_free += chan->dma.ib_max;
207         }
208
209         return 0;
210 }
211
212 static int
213 nv50_dma_wait(struct nouveau_channel *chan, int slots, int count)
214 {
215         uint32_t cnt = 0, prev_get = 0;
216         int ret;
217
218         ret = nv50_dma_push_wait(chan, slots + 1);
219         if (unlikely(ret))
220                 return ret;
221
222         while (chan->dma.free < count) {
223                 int get = READ_GET(chan, &prev_get, &cnt);
224                 if (unlikely(get < 0)) {
225                         if (get == -EINVAL)
226                                 continue;
227
228                         return get;
229                 }
230
231                 if (get <= chan->dma.cur) {
232                         chan->dma.free = chan->dma.max - chan->dma.cur;
233                         if (chan->dma.free >= count)
234                                 break;
235
236                         FIRE_RING(chan);
237                         do {
238                                 get = READ_GET(chan, &prev_get, &cnt);
239                                 if (unlikely(get < 0)) {
240                                         if (get == -EINVAL)
241                                                 continue;
242                                         return get;
243                                 }
244                         } while (get == 0);
245                         chan->dma.cur = 0;
246                         chan->dma.put = 0;
247                 }
248
249                 chan->dma.free = get - chan->dma.cur - 1;
250         }
251
252         return 0;
253 }
254
255 int
256 nouveau_dma_wait(struct nouveau_channel *chan, int slots, int size)
257 {
258         uint32_t prev_get = 0, cnt = 0;
259         int get;
260
261         if (chan->dma.ib_max)
262                 return nv50_dma_wait(chan, slots, size);
263
264         while (chan->dma.free < size) {
265                 get = READ_GET(chan, &prev_get, &cnt);
266                 if (unlikely(get == -EBUSY))
267                         return -EBUSY;
268
269                 /* loop until we have a usable GET pointer.  the value
270                  * we read from the GPU may be outside the main ring if
271                  * PFIFO is processing a buffer called from the main ring,
272                  * discard these values until something sensible is seen.
273                  *
274                  * the other case we discard GET is while the GPU is fetching
275                  * from the SKIPS area, so the code below doesn't have to deal
276                  * with some fun corner cases.
277                  */
278                 if (unlikely(get == -EINVAL) || get < NOUVEAU_DMA_SKIPS)
279                         continue;
280
281                 if (get <= chan->dma.cur) {
282                         /* engine is fetching behind us, or is completely
283                          * idle (GET == PUT) so we have free space up until
284                          * the end of the push buffer
285                          *
286                          * we can only hit that path once per call due to
287                          * looping back to the beginning of the push buffer,
288                          * we'll hit the fetching-ahead-of-us path from that
289                          * point on.
290                          *
291                          * the *one* exception to that rule is if we read
292                          * GET==PUT, in which case the below conditional will
293                          * always succeed and break us out of the wait loop.
294                          */
295                         chan->dma.free = chan->dma.max - chan->dma.cur;
296                         if (chan->dma.free >= size)
297                                 break;
298
299                         /* not enough space left at the end of the push buffer,
300                          * instruct the GPU to jump back to the start right
301                          * after processing the currently pending commands.
302                          */
303                         OUT_RING(chan, chan->pushbuf_base | 0x20000000);
304
305                         /* wait for GET to depart from the skips area.
306                          * prevents writing GET==PUT and causing a race
307                          * condition that causes us to think the GPU is
308                          * idle when it's not.
309                          */
310                         do {
311                                 get = READ_GET(chan, &prev_get, &cnt);
312                                 if (unlikely(get == -EBUSY))
313                                         return -EBUSY;
314                                 if (unlikely(get == -EINVAL))
315                                         continue;
316                         } while (get <= NOUVEAU_DMA_SKIPS);
317                         WRITE_PUT(NOUVEAU_DMA_SKIPS);
318
319                         /* we're now submitting commands at the start of
320                          * the push buffer.
321                          */
322                         chan->dma.cur  =
323                         chan->dma.put  = NOUVEAU_DMA_SKIPS;
324                 }
325
326                 /* engine fetching ahead of us, we have space up until the
327                  * current GET pointer.  the "- 1" is to ensure there's
328                  * space left to emit a jump back to the beginning of the
329                  * push buffer if we require it.  we can never get GET == PUT
330                  * here, so this is safe.
331                  */
332                 chan->dma.free = get - chan->dma.cur - 1;
333         }
334
335         return 0;
336 }
337