video: tegra: host: Move device data to nvhost_device
[linux-2.6.git] / drivers / video / tegra / host / nvhost_cdma.c
1 /*
2  * drivers/video/tegra/host/nvhost_cdma.c
3  *
4  * Tegra Graphics Host Command DMA
5  *
6  * Copyright (c) 2010-2011, NVIDIA Corporation.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  *
18  * You should have received a copy of the GNU General Public License along
19  * with this program; if not, write to the Free Software Foundation, Inc.,
20  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21  */
22
23 #include "nvhost_cdma.h"
24 #include "dev.h"
25 #include <asm/cacheflush.h>
26
27 #include <linux/slab.h>
28 #include <linux/kfifo.h>
29 #include <trace/events/nvhost.h>
30 #include <linux/interrupt.h>
31
32 /*
33  * TODO:
34  *   stats
35  *     - for figuring out what to optimize further
36  *   resizable push buffer & sync queue
37  *     - some channels hardly need any, some channels (3d) could use more
38  */
39
40 /**
41  * kfifo_save - save current out pointer
42  * @fifo: address of the fifo to be used
43  */
44 #define kfifo_save(fifo) \
45 __kfifo_uint_must_check_helper( \
46 ({ \
47         typeof((fifo) + 1) __tmp = (fifo); \
48         struct __kfifo *__kfifo = &__tmp->kfifo; \
49         __kfifo->out; \
50 }) \
51 )
52
53 /**
54  * kfifo_restore - restore previously saved pointer
55  * @fifo: address of the fifo to be used
56  * @out: output pointer
57  */
58 #define kfifo_restore(fifo, restore) \
59 (void)({ \
60         typeof((fifo) + 1) __tmp = (fifo); \
61         struct __kfifo *__kfifo = &__tmp->kfifo; \
62         __kfifo->out = (restore); \
63 })
64
65 /**
66  * Add an entry to the sync queue.
67  */
68 static void add_to_sync_queue(struct nvhost_cdma *cdma,
69                               struct nvhost_job *job,
70                               u32 nr_slots,
71                               u32 first_get)
72 {
73         BUG_ON(job->syncpt_id == NVSYNCPT_INVALID);
74
75         job->first_get = first_get;
76         job->num_slots = nr_slots;
77         nvhost_job_get(job);
78         kfifo_in(&cdma->sync_queue, (void *)&job, 1);
79 }
80
81 /**
82  * Return the status of the cdma's sync queue or push buffer for the given event
83  *  - sq empty: returns 1 for empty, 0 for not empty (as in "1 empty queue" :-)
84  *  - sq space: returns the number of handles that can be stored in the queue
85  *  - pb space: returns the number of free slots in the channel's push buffer
86  * Must be called with the cdma lock held.
87  */
88 static unsigned int cdma_status_locked(struct nvhost_cdma *cdma,
89                 enum cdma_event event)
90 {
91         switch (event) {
92         case CDMA_EVENT_SYNC_QUEUE_EMPTY:
93                 return kfifo_len(&cdma->sync_queue) == 0 ? 1 : 0;
94         case CDMA_EVENT_SYNC_QUEUE_SPACE:
95                 return kfifo_avail(&cdma->sync_queue);
96         case CDMA_EVENT_PUSH_BUFFER_SPACE: {
97                 struct push_buffer *pb = &cdma->push_buffer;
98                 BUG_ON(!cdma_pb_op(cdma).space);
99                 return cdma_pb_op(cdma).space(pb);
100         }
101         default:
102                 return 0;
103         }
104 }
105
106 /**
107  * Sleep (if necessary) until the requested event happens
108  *   - CDMA_EVENT_SYNC_QUEUE_EMPTY : sync queue is completely empty.
109  *     - Returns 1
110  *   - CDMA_EVENT_SYNC_QUEUE_SPACE : there is space in the sync queue.
111  *   - CDMA_EVENT_PUSH_BUFFER_SPACE : there is space in the push buffer
112  *     - Return the amount of space (> 0)
113  * Must be called with the cdma lock held.
114  */
115 unsigned int nvhost_cdma_wait_locked(struct nvhost_cdma *cdma,
116                 enum cdma_event event)
117 {
118         for (;;) {
119                 unsigned int space = cdma_status_locked(cdma, event);
120                 if (space)
121                         return space;
122
123                 trace_nvhost_wait_cdma(cdma_to_channel(cdma)->dev->name,
124                                 event);
125
126                 BUG_ON(cdma->event != CDMA_EVENT_NONE);
127                 cdma->event = event;
128
129                 mutex_unlock(&cdma->lock);
130                 down(&cdma->sem);
131                 mutex_lock(&cdma->lock);
132         }
133         return 0;
134 }
135
136 /**
137  * Start timer for a buffer submition that has completed yet.
138  * Must be called with the cdma lock held.
139  */
140 static void cdma_start_timer_locked(struct nvhost_cdma *cdma,
141                 struct nvhost_job *job)
142 {
143         BUG_ON(!job);
144         if (cdma->timeout.clientid) {
145                 /* timer already started */
146                 return;
147         }
148
149         cdma->timeout.ctx = job->hwctx;
150         cdma->timeout.clientid = job->clientid;
151         cdma->timeout.syncpt_id = job->syncpt_id;
152         cdma->timeout.syncpt_val = job->syncpt_end;
153         cdma->timeout.start_ktime = ktime_get();
154
155         schedule_delayed_work(&cdma->timeout.wq,
156                         msecs_to_jiffies(job->timeout));
157 }
158
159 /**
160  * Stop timer when a buffer submition completes.
161  * Must be called with the cdma lock held.
162  */
163 static void stop_cdma_timer_locked(struct nvhost_cdma *cdma)
164 {
165         cancel_delayed_work(&cdma->timeout.wq);
166         cdma->timeout.ctx = NULL;
167         cdma->timeout.clientid = 0;
168 }
169
170 /**
171  * For all sync queue entries that have already finished according to the
172  * current sync point registers:
173  *  - unpin & unref their mems
174  *  - pop their push buffer slots
175  *  - remove them from the sync queue
176  * This is normally called from the host code's worker thread, but can be
177  * called manually if necessary.
178  * Must be called with the cdma lock held.
179  */
180 static void update_cdma_locked(struct nvhost_cdma *cdma)
181 {
182         bool signal = false;
183         struct nvhost_master *dev = cdma_to_dev(cdma);
184
185         BUG_ON(!cdma->running);
186
187         /*
188          * Walk the sync queue, reading the sync point registers as necessary,
189          * to consume as many sync queue entries as possible without blocking
190          */
191         for (;;) {
192                 struct nvhost_syncpt *sp = &dev->syncpt;
193                 struct nvhost_job *job;
194                 int result;
195
196                 result = kfifo_peek(&cdma->sync_queue, &job);
197                 if (!result) {
198                         if (cdma->event == CDMA_EVENT_SYNC_QUEUE_EMPTY)
199                                 signal = true;
200                         break;
201                 }
202
203                 BUG_ON(job->syncpt_id == NVSYNCPT_INVALID);
204
205                 /* Check whether this syncpt has completed, and bail if not */
206                 if (!nvhost_syncpt_min_cmp(sp,
207                                 job->syncpt_id, job->syncpt_end)) {
208                         /* Start timer on next pending syncpt */
209                         if (job->timeout)
210                                 cdma_start_timer_locked(cdma, job);
211                         break;
212                 }
213
214                 /* Cancel timeout, when a buffer completes */
215                 if (cdma->timeout.clientid)
216                         stop_cdma_timer_locked(cdma);
217
218                 /* Unpin the memory */
219                 nvhost_job_unpin(job);
220
221                 /* Pop push buffer slots */
222                 if (job->num_slots) {
223                         struct push_buffer *pb = &cdma->push_buffer;
224                         BUG_ON(!cdma_pb_op(cdma).pop_from);
225                         cdma_pb_op(cdma).pop_from(pb, job->num_slots);
226                         if (cdma->event == CDMA_EVENT_PUSH_BUFFER_SPACE)
227                                 signal = true;
228                 }
229
230                 nvhost_job_put(job);
231                 kfifo_skip(&cdma->sync_queue);
232                 if (cdma->event == CDMA_EVENT_SYNC_QUEUE_SPACE)
233                         signal = true;
234         }
235
236         /* Wake up CdmaWait() if the requested event happened */
237         if (signal) {
238                 cdma->event = CDMA_EVENT_NONE;
239                 up(&cdma->sem);
240         }
241 }
242
243 void nvhost_cdma_update_sync_queue(struct nvhost_cdma *cdma,
244                 struct nvhost_syncpt *syncpt, struct device *dev)
245 {
246         u32 get_restart;
247         u32 syncpt_incrs;
248         bool exec_ctxsave;
249         unsigned int queue_restore;
250         struct nvhost_job *job = NULL;
251         int result;
252         u32 syncpt_val;
253
254         syncpt_val = nvhost_syncpt_update_min(syncpt, cdma->timeout.syncpt_id);
255         queue_restore = kfifo_save(&cdma->sync_queue);
256
257         dev_dbg(dev,
258                 "%s: starting cleanup (thresh %d, queue length %d)\n",
259                 __func__,
260                 syncpt_val, kfifo_len(&cdma->sync_queue));
261
262         /*
263          * Move the sync_queue read pointer to the first entry that hasn't
264          * completed based on the current HW syncpt value. It's likely there
265          * won't be any (i.e. we're still at the head), but covers the case
266          * where a syncpt incr happens just prior/during the teardown.
267          */
268
269         dev_dbg(dev,
270                 "%s: skip completed buffers still in sync_queue\n",
271                 __func__);
272
273         result = kfifo_peek(&cdma->sync_queue, &job);
274         while (result && syncpt_val >= job->syncpt_end) {
275                 nvhost_job_dump(dev, job);
276                 kfifo_skip(&cdma->sync_queue);
277                 result = kfifo_peek(&cdma->sync_queue, &job);
278         }
279
280         /*
281          * Walk the sync_queue, first incrementing with the CPU syncpts that
282          * are partially executed (the first buffer) or fully skipped while
283          * still in the current context (slots are also NOP-ed).
284          *
285          * At the point contexts are interleaved, syncpt increments must be
286          * done inline with the pushbuffer from a GATHER buffer to maintain
287          * the order (slots are modified to be a GATHER of syncpt incrs).
288          *
289          * Note: save in get_restart the location where the timed out buffer
290          * started in the PB, so we can start the refetch from there (with the
291          * modified NOP-ed PB slots). This lets things appear to have completed
292          * properly for this buffer and resources are freed.
293          */
294
295         dev_dbg(dev,
296                 "%s: perform CPU incr on pending same ctx buffers\n",
297                 __func__);
298
299         get_restart = cdma->last_put;
300         if (kfifo_len(&cdma->sync_queue) > 0)
301                 get_restart = job->first_get;
302
303         /* do CPU increments as long as this context continues */
304         while (result && job->clientid == cdma->timeout.clientid) {
305                 /* different context, gets us out of this loop */
306                 if (job->clientid != cdma->timeout.clientid)
307                         break;
308
309                 /* won't need a timeout when replayed */
310                 job->timeout = 0;
311
312                 syncpt_incrs = job->syncpt_end - syncpt_val;
313                 dev_dbg(dev,
314                         "%s: CPU incr (%d)\n", __func__, syncpt_incrs);
315
316                 nvhost_job_dump(dev, job);
317
318                 /* safe to use CPU to incr syncpts */
319                 cdma_op(cdma).timeout_cpu_incr(cdma,
320                                 job->first_get,
321                                 syncpt_incrs,
322                                 job->syncpt_end,
323                                 job->num_slots);
324
325                 kfifo_skip(&cdma->sync_queue);
326                 result = kfifo_peek(&cdma->sync_queue, &job);
327         }
328
329         dev_dbg(dev,
330                 "%s: GPU incr blocked interleaved ctx buffers\n",
331                 __func__);
332
333         exec_ctxsave = false;
334
335         /* setup GPU increments */
336         while (result) {
337                 /* same context, increment in the pushbuffer */
338                 if (job->clientid == cdma->timeout.clientid) {
339                         /* won't need a timeout when replayed */
340                         job->timeout = 0;
341
342                         /* update buffer's syncpts in the pushbuffer */
343                         cdma_op(cdma).timeout_pb_incr(cdma,
344                                         job->first_get,
345                                         job->syncpt_incrs,
346                                         job->num_slots,
347                                         exec_ctxsave);
348
349                         exec_ctxsave = false;
350                 } else {
351                         dev_dbg(dev,
352                                 "%s: switch to a different userctx\n",
353                                 __func__);
354                         /*
355                          * If previous context was the timed out context
356                          * then clear its CTXSAVE in this slot.
357                          */
358                         exec_ctxsave = true;
359                 }
360
361                 nvhost_job_dump(dev, job);
362
363                 kfifo_skip(&cdma->sync_queue);
364                 result = kfifo_peek(&cdma->sync_queue, &job);
365         }
366
367         dev_dbg(dev,
368                 "%s: finished sync_queue modification\n", __func__);
369
370         kfifo_restore(&cdma->sync_queue, queue_restore);
371
372         /* roll back DMAGET and start up channel again */
373         cdma_op(cdma).timeout_teardown_end(cdma, get_restart);
374
375         if (cdma->timeout.ctx)
376                 cdma->timeout.ctx->has_timedout = true;
377 }
378
379 /**
380  * Create a cdma
381  */
382 int nvhost_cdma_init(struct nvhost_cdma *cdma)
383 {
384         int err;
385         struct push_buffer *pb = &cdma->push_buffer;
386         BUG_ON(!cdma_pb_op(cdma).init);
387         mutex_init(&cdma->lock);
388         sema_init(&cdma->sem, 0);
389
390         err = kfifo_alloc(&cdma->sync_queue,
391                         cdma_to_dev(cdma)->sync_queue_size
392                                 * sizeof(struct nvhost_job *),
393                         GFP_KERNEL);
394         if (err)
395                 return err;
396
397         cdma->event = CDMA_EVENT_NONE;
398         cdma->running = false;
399         cdma->torndown = false;
400
401         err = cdma_pb_op(cdma).init(pb);
402         if (err)
403                 return err;
404         return 0;
405 }
406
407 /**
408  * Destroy a cdma
409  */
410 void nvhost_cdma_deinit(struct nvhost_cdma *cdma)
411 {
412         struct push_buffer *pb = &cdma->push_buffer;
413
414         BUG_ON(!cdma_pb_op(cdma).destroy);
415         BUG_ON(cdma->running);
416         kfifo_free(&cdma->sync_queue);
417         cdma_pb_op(cdma).destroy(pb);
418         cdma_op(cdma).timeout_destroy(cdma);
419 }
420
421 /**
422  * Begin a cdma submit
423  */
424 int nvhost_cdma_begin(struct nvhost_cdma *cdma, struct nvhost_job *job)
425 {
426         mutex_lock(&cdma->lock);
427
428         if (job->timeout) {
429                 /* init state on first submit with timeout value */
430                 if (!cdma->timeout.initialized) {
431                         int err;
432                         BUG_ON(!cdma_op(cdma).timeout_init);
433                         err = cdma_op(cdma).timeout_init(cdma,
434                                 job->syncpt_id);
435                         if (err) {
436                                 mutex_unlock(&cdma->lock);
437                                 return err;
438                         }
439                 }
440         }
441         if (!cdma->running) {
442                 BUG_ON(!cdma_op(cdma).start);
443                 cdma_op(cdma).start(cdma);
444         }
445         cdma->slots_free = 0;
446         cdma->slots_used = 0;
447         cdma->first_get = cdma_pb_op(cdma).putptr(&cdma->push_buffer);
448         return 0;
449 }
450
451 /**
452  * Push two words into a push buffer slot
453  * Blocks as necessary if the push buffer is full.
454  */
455 void nvhost_cdma_push(struct nvhost_cdma *cdma, u32 op1, u32 op2)
456 {
457         nvhost_cdma_push_gather(cdma, NULL, NULL, op1, op2);
458 }
459
460 /**
461  * Push two words into a push buffer slot
462  * Blocks as necessary if the push buffer is full.
463  */
464 void nvhost_cdma_push_gather(struct nvhost_cdma *cdma,
465                 struct nvmap_client *client,
466                 struct nvmap_handle *handle, u32 op1, u32 op2)
467 {
468         u32 slots_free = cdma->slots_free;
469         struct push_buffer *pb = &cdma->push_buffer;
470         BUG_ON(!cdma_pb_op(cdma).push_to);
471         BUG_ON(!cdma_op(cdma).kick);
472         if (slots_free == 0) {
473                 cdma_op(cdma).kick(cdma);
474                 slots_free = nvhost_cdma_wait_locked(cdma,
475                                 CDMA_EVENT_PUSH_BUFFER_SPACE);
476         }
477         cdma->slots_free = slots_free - 1;
478         cdma->slots_used++;
479         cdma_pb_op(cdma).push_to(pb, client, handle, op1, op2);
480 }
481
482 /**
483  * End a cdma submit
484  * Kick off DMA, add a contiguous block of memory handles to the sync queue,
485  * and a number of slots to be freed from the pushbuffer.
486  * Blocks as necessary if the sync queue is full.
487  * The handles for a submit must all be pinned at the same time, but they
488  * can be unpinned in smaller chunks.
489  */
490 void nvhost_cdma_end(struct nvhost_cdma *cdma,
491                 struct nvhost_job *job)
492 {
493         bool was_idle = kfifo_len(&cdma->sync_queue) == 0;
494
495         BUG_ON(!cdma_op(cdma).kick);
496         cdma_op(cdma).kick(cdma);
497
498         BUG_ON(job->syncpt_id == NVSYNCPT_INVALID);
499
500         nvhost_cdma_wait_locked(cdma, CDMA_EVENT_SYNC_QUEUE_SPACE);
501         add_to_sync_queue(cdma,
502                         job,
503                         cdma->slots_used,
504                         cdma->first_get);
505
506         /* start timer on idle -> active transitions */
507         if (job->timeout && was_idle)
508                 cdma_start_timer_locked(cdma, job);
509
510         mutex_unlock(&cdma->lock);
511 }
512
513 /**
514  * Update cdma state according to current sync point values
515  */
516 void nvhost_cdma_update(struct nvhost_cdma *cdma)
517 {
518         mutex_lock(&cdma->lock);
519         update_cdma_locked(cdma);
520         mutex_unlock(&cdma->lock);
521 }
522
523 /**
524  * Wait for push buffer to be empty.
525  * @cdma pointer to channel cdma
526  * @timeout timeout in ms
527  * Returns -ETIME if timeout was reached, zero if push buffer is empty.
528  */
529 int nvhost_cdma_flush(struct nvhost_cdma *cdma, int timeout)
530 {
531         unsigned int space, err = 0;
532         unsigned long end_jiffies = jiffies + msecs_to_jiffies(timeout);
533
534         /*
535          * Wait for at most timeout ms. Recalculate timeout at each iteration
536          * to better keep within given timeout.
537          */
538         while(!err && time_before(jiffies, end_jiffies)) {
539                 int timeout_jiffies = end_jiffies - jiffies;
540
541                 mutex_lock(&cdma->lock);
542                 space = cdma_status_locked(cdma,
543                                 CDMA_EVENT_SYNC_QUEUE_EMPTY);
544                 if (space) {
545                         mutex_unlock(&cdma->lock);
546                         return 0;
547                 }
548
549                 /*
550                  * Wait for sync queue to become empty. If there is already
551                  * an event pending, we need to poll.
552                  */
553                 if (cdma->event != CDMA_EVENT_NONE) {
554                         mutex_unlock(&cdma->lock);
555                         schedule();
556                 } else {
557                         cdma->event = CDMA_EVENT_SYNC_QUEUE_EMPTY;
558
559                         mutex_unlock(&cdma->lock);
560                         err = down_timeout(&cdma->sem,
561                                         jiffies_to_msecs(timeout_jiffies));
562                 }
563         }
564         return err;
565 }