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