d6182c8f494633c8bff12627b1fffef2fad2b541
[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         if (job->syncpt_id == NVSYNCPT_INVALID) {
53                 dev_warn(&job->ch->dev->dev, "%s: Invalid syncpt\n",
54                                 __func__);
55                 return;
56         }
57         job->first_get = first_get;
58         job->num_slots = nr_slots;
59         nvhost_job_get(job);
60         list_add_tail(&job->list, &cdma->sync_queue);
61
62         switch (job->priority) {
63         case NVHOST_PRIORITY_HIGH:
64                 cdma->high_prio_count++;
65                 break;
66         case NVHOST_PRIORITY_MEDIUM:
67                 cdma->med_prio_count++;
68                 break;
69         case NVHOST_PRIORITY_LOW:
70                 cdma->low_prio_count++;
71                 break;
72         }
73 }
74
75 /**
76  * Return the status of the cdma's sync queue or push buffer for the given event
77  *  - sq empty: returns 1 for empty, 0 for not empty (as in "1 empty queue" :-)
78  *  - pb space: returns the number of free slots in the channel's push buffer
79  * Must be called with the cdma lock held.
80  */
81 static unsigned int cdma_status_locked(struct nvhost_cdma *cdma,
82                 enum cdma_event event)
83 {
84         switch (event) {
85         case CDMA_EVENT_SYNC_QUEUE_EMPTY:
86                 return list_empty(&cdma->sync_queue) ? 1 : 0;
87         case CDMA_EVENT_PUSH_BUFFER_SPACE: {
88                 struct push_buffer *pb = &cdma->push_buffer;
89                 return cdma_pb_op().space(pb);
90         }
91         default:
92                 return 0;
93         }
94 }
95
96 /**
97  * Sleep (if necessary) until the requested event happens
98  *   - CDMA_EVENT_SYNC_QUEUE_EMPTY : sync queue is completely empty.
99  *     - Returns 1
100  *   - CDMA_EVENT_PUSH_BUFFER_SPACE : there is space in the push buffer
101  *     - Return the amount of space (> 0)
102  * Must be called with the cdma lock held.
103  */
104 unsigned int nvhost_cdma_wait_locked(struct nvhost_cdma *cdma,
105                 enum cdma_event event)
106 {
107         for (;;) {
108                 unsigned int space = cdma_status_locked(cdma, event);
109                 if (space)
110                         return space;
111
112                 trace_nvhost_wait_cdma(cdma_to_channel(cdma)->dev->name,
113                                 event);
114
115                 /* If somebody has managed to already start waiting, yield */
116                 if (cdma->event != CDMA_EVENT_NONE) {
117                         mutex_unlock(&cdma->lock);
118                         schedule();
119                         mutex_lock(&cdma->lock);
120                         continue;
121                 }
122                 cdma->event = event;
123
124                 mutex_unlock(&cdma->lock);
125                 down(&cdma->sem);
126                 mutex_lock(&cdma->lock);
127         }
128         return 0;
129 }
130
131 /**
132  * Start timer for a buffer submition that has completed yet.
133  * Must be called with the cdma lock held.
134  */
135 static void cdma_start_timer_locked(struct nvhost_cdma *cdma,
136                 struct nvhost_job *job)
137 {
138         if (cdma->timeout.clientid) {
139                 /* timer already started */
140                 return;
141         }
142
143         cdma->timeout.ctx = job->hwctx;
144         cdma->timeout.clientid = job->clientid;
145         cdma->timeout.syncpt_id = job->syncpt_id;
146         cdma->timeout.syncpt_val = job->syncpt_end;
147         cdma->timeout.start_ktime = ktime_get();
148         cdma->timeout.timeout_debug_dump = job->timeout_debug_dump;
149
150         schedule_delayed_work(&cdma->timeout.wq,
151                         msecs_to_jiffies(job->timeout));
152 }
153
154 /**
155  * Stop timer when a buffer submition completes.
156  * Must be called with the cdma lock held.
157  */
158 static void stop_cdma_timer_locked(struct nvhost_cdma *cdma)
159 {
160         bool ret = true;
161         while (ret)
162                 ret = cancel_delayed_work_sync(&cdma->timeout.wq);
163
164         cdma->timeout.ctx = NULL;
165         cdma->timeout.clientid = 0;
166 }
167
168 /**
169  * For all sync queue entries that have already finished according to the
170  * current sync point registers:
171  *  - unpin & unref their mems
172  *  - pop their push buffer slots
173  *  - remove them from the sync queue
174  * This is normally called from the host code's worker thread, but can be
175  * called manually if necessary.
176  * Must be called with the cdma lock held.
177  */
178 static void update_cdma_locked(struct nvhost_cdma *cdma)
179 {
180         bool signal = false;
181         struct nvhost_master *dev = cdma_to_dev(cdma);
182         struct nvhost_syncpt *sp = &dev->syncpt;
183         struct nvhost_job *job, *n;
184
185         /* If CDMA is stopped, queue is cleared and we can return */
186         if (!cdma->running)
187                 return;
188
189         /*
190          * Walk the sync queue, reading the sync point registers as necessary,
191          * to consume as many sync queue entries as possible without blocking
192          */
193         list_for_each_entry_safe(job, n, &cdma->sync_queue, list) {
194                 /* Check whether this syncpt has completed, and bail if not */
195                 if (!nvhost_syncpt_is_expired(sp,
196                                 job->syncpt_id, job->syncpt_end)) {
197                         /* Start timer on next pending syncpt */
198                         if (job->timeout)
199                                 cdma_start_timer_locked(cdma, job);
200                         break;
201                 }
202
203                 /* Cancel timeout, when a buffer completes */
204                 if (cdma->timeout.clientid)
205                         stop_cdma_timer_locked(cdma);
206
207                 /* Unpin the memory */
208                 nvhost_job_unpin(job);
209
210                 /* Pop push buffer slots */
211                 if (job->num_slots) {
212                         struct push_buffer *pb = &cdma->push_buffer;
213                         cdma_pb_op().pop_from(pb, job->num_slots);
214                         if (cdma->event == CDMA_EVENT_PUSH_BUFFER_SPACE)
215                                 signal = true;
216                 }
217
218                 list_del(&job->list);
219
220                 switch (job->priority) {
221                 case NVHOST_PRIORITY_HIGH:
222                         cdma->high_prio_count--;
223                         break;
224                 case NVHOST_PRIORITY_MEDIUM:
225                         cdma->med_prio_count--;
226                         break;
227                 case NVHOST_PRIORITY_LOW:
228                         cdma->low_prio_count--;
229                         break;
230                 }
231
232                 nvhost_job_put(job);
233         }
234
235         if (list_empty(&cdma->sync_queue) &&
236                                 cdma->event == CDMA_EVENT_SYNC_QUEUE_EMPTY)
237                         signal = true;
238
239         /* Wake up CdmaWait() if the requested event happened */
240         if (signal) {
241                 cdma->event = CDMA_EVENT_NONE;
242                 up(&cdma->sem);
243         }
244 }
245
246 void nvhost_cdma_update_sync_queue(struct nvhost_cdma *cdma,
247                 struct nvhost_syncpt *syncpt, struct platform_device *dev)
248 {
249         u32 get_restart;
250         u32 syncpt_incrs;
251         struct nvhost_job *job = NULL;
252         u32 syncpt_val;
253         struct nvhost_device_data *pdata = platform_get_drvdata(dev);
254
255         syncpt_val = nvhost_syncpt_update_min(syncpt, cdma->timeout.syncpt_id);
256
257         dev_dbg(&dev->dev,
258                 "%s: starting cleanup (thresh %d)\n",
259                 __func__, syncpt_val);
260
261         /*
262          * Move the sync_queue read pointer to the first entry that hasn't
263          * completed based on the current HW syncpt value. It's likely there
264          * won't be any (i.e. we're still at the head), but covers the case
265          * where a syncpt incr happens just prior/during the teardown.
266          */
267
268         dev_dbg(&dev->dev,
269                 "%s: skip completed buffers still in sync_queue\n",
270                 __func__);
271
272         list_for_each_entry(job, &cdma->sync_queue, list) {
273                 if (!nvhost_syncpt_is_expired(syncpt,
274                         cdma->timeout.syncpt_id, job->syncpt_end))
275                         break;
276
277                 nvhost_job_dump(&dev->dev, 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->dev,
296                 "%s: perform CPU incr on pending same ctx buffers\n",
297                 __func__);
298
299         get_restart = cdma->last_put;
300         if (!list_empty(&cdma->sync_queue))
301                 get_restart = job->first_get;
302
303         /* do CPU increments as long as this context continues */
304         list_for_each_entry_from(job, &cdma->sync_queue, list) {
305                 int i;
306
307                 /* different context, gets us out of this loop */
308                 if (job->clientid != cdma->timeout.clientid)
309                         break;
310
311                 nvhost_job_dump(&dev->dev, job);
312
313                 /* won't need a timeout when replayed */
314                 job->timeout = 0;
315
316                 syncpt_incrs = job->syncpt_end - syncpt_val;
317                 dev_dbg(&dev->dev,
318                         "%s: CPU incr (%d)\n", __func__, syncpt_incrs);
319
320                 /* do CPU increments */
321                 for (i = 0; i < syncpt_incrs; i++)
322                         nvhost_syncpt_cpu_incr(&cdma_to_dev(cdma)->syncpt,
323                                 cdma->timeout.syncpt_id);
324
325                 /* ensure shadow is up to date */
326                 nvhost_syncpt_update_min(&cdma_to_dev(cdma)->syncpt,
327                         cdma->timeout.syncpt_id);
328
329                 /* synchronize wait bases */
330                 if (cdma->timeout.syncpt_id != NVSYNCPT_2D_0 &&
331                         pdata->waitbases[0])
332                         nvhost_syncpt_cpu_set_wait_base(dev,
333                                 pdata->waitbases[0], job->syncpt_end);
334
335                 /* cleanup push buffer */
336                 cdma_op().timeout_pb_cleanup(cdma, job->first_get,
337                         job->num_slots);
338
339                 syncpt_val += syncpt_incrs;
340         }
341
342         list_for_each_entry_from(job, &cdma->sync_queue, list)
343                 if (job->clientid == cdma->timeout.clientid)
344                         job->timeout = min(job->timeout, 500);
345
346         dev_dbg(&dev->dev,
347                 "%s: finished sync_queue modification\n", __func__);
348
349         /* roll back DMAGET and start up channel again */
350         cdma_op().timeout_teardown_end(cdma, get_restart);
351
352         if (cdma->timeout.ctx)
353                 cdma->timeout.ctx->has_timedout = true;
354 }
355
356 /**
357  * Create a cdma
358  */
359 int nvhost_cdma_init(struct nvhost_cdma *cdma)
360 {
361         int err;
362         struct push_buffer *pb = &cdma->push_buffer;
363         mutex_init(&cdma->lock);
364         sema_init(&cdma->sem, 0);
365
366         INIT_LIST_HEAD(&cdma->sync_queue);
367
368         cdma->event = CDMA_EVENT_NONE;
369         cdma->running = false;
370         cdma->torndown = false;
371
372         err = cdma_pb_op().init(pb);
373         if (err)
374                 return err;
375         return 0;
376 }
377
378 /**
379  * Destroy a cdma
380  */
381 void nvhost_cdma_deinit(struct nvhost_cdma *cdma)
382 {
383         struct push_buffer *pb = &cdma->push_buffer;
384
385         WARN_ON(cdma->running);
386         cdma_pb_op().destroy(pb);
387         cdma_op().timeout_destroy(cdma);
388 }
389
390 /**
391  * Begin a cdma submit
392  */
393 int nvhost_cdma_begin(struct nvhost_cdma *cdma, struct nvhost_job *job)
394 {
395         mutex_lock(&cdma->lock);
396
397         if (job->timeout) {
398                 /* init state on first submit with timeout value */
399                 if (!cdma->timeout.initialized) {
400                         int err;
401                         err = cdma_op().timeout_init(cdma,
402                                 job->syncpt_id);
403                         if (err) {
404                                 mutex_unlock(&cdma->lock);
405                                 return err;
406                         }
407                 }
408         }
409         if (!cdma->running) {
410                 cdma_op().start(cdma);
411         }
412         cdma->slots_free = 0;
413         cdma->slots_used = 0;
414         cdma->first_get = cdma_pb_op().putptr(&cdma->push_buffer);
415         return 0;
416 }
417
418 static void trace_write_gather(struct nvhost_cdma *cdma,
419                 struct mem_handle *ref,
420                 u32 offset, u32 words)
421 {
422         void *mem = NULL;
423
424         if (nvhost_debug_trace_cmdbuf)
425                 mem = nvhost_memmgr_mmap(ref);
426
427         if (mem) {
428                 u32 i;
429                 /*
430                  * Write in batches of 128 as there seems to be a limit
431                  * of how much you can output to ftrace at once.
432                  */
433                 for (i = 0; i < words; i += TRACE_MAX_LENGTH) {
434                         trace_nvhost_cdma_push_gather(
435                                 cdma_to_channel(cdma)->dev->name,
436                                 (u32)ref,
437                                 min(words - i, TRACE_MAX_LENGTH),
438                                 offset + i * sizeof(u32),
439                                 mem);
440                 }
441                 nvhost_memmgr_munmap(ref, mem);
442         }
443 }
444
445 /**
446  * Push two words into a push buffer slot
447  * Blocks as necessary if the push buffer is full.
448  */
449 void nvhost_cdma_push(struct nvhost_cdma *cdma, u32 op1, u32 op2)
450 {
451         if (nvhost_debug_trace_cmdbuf)
452                 trace_nvhost_cdma_push(cdma_to_channel(cdma)->dev->name,
453                                 op1, op2);
454
455         nvhost_cdma_push_gather(cdma, NULL, NULL, 0, op1, op2);
456 }
457
458 /**
459  * Push two words into a push buffer slot
460  * Blocks as necessary if the push buffer is full.
461  */
462 void nvhost_cdma_push_gather(struct nvhost_cdma *cdma,
463                 struct mem_mgr *client, struct mem_handle *handle,
464                 u32 offset, u32 op1, u32 op2)
465 {
466         u32 slots_free = cdma->slots_free;
467         struct push_buffer *pb = &cdma->push_buffer;
468
469         if (handle)
470                 trace_write_gather(cdma, handle, offset, op1 & 0x1fff);
471
472         if (slots_free == 0) {
473                 cdma_op().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().push_to(pb, client, handle, op1, op2);
480 }
481
482 /**
483  * End a cdma submit
484  * Kick off DMA, add job to the sync queue, and a number of slots to be freed
485  * from the pushbuffer. The handles for a submit must all be pinned at the same
486  * time, but they can be unpinned in smaller chunks.
487  */
488 void nvhost_cdma_end(struct nvhost_cdma *cdma,
489                 struct nvhost_job *job)
490 {
491         bool was_idle = list_empty(&cdma->sync_queue);
492
493         cdma_op().kick(cdma);
494
495         add_to_sync_queue(cdma,
496                         job,
497                         cdma->slots_used,
498                         cdma->first_get);
499
500         /* start timer on idle -> active transitions */
501         if (job->timeout && was_idle)
502                 cdma_start_timer_locked(cdma, job);
503
504         trace_nvhost_cdma_end(job->ch->dev->name,
505                         job->priority,
506                         job->ch->cdma.high_prio_count,
507                         job->ch->cdma.med_prio_count,
508                         job->ch->cdma.low_prio_count);
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         trace_nvhost_cdma_flush(cdma_to_channel(cdma)->dev->name, timeout);
535
536         /*
537          * Wait for at most timeout ms. Recalculate timeout at each iteration
538          * to better keep within given timeout.
539          */
540         while(!err && time_before(jiffies, end_jiffies)) {
541                 int timeout_jiffies = end_jiffies - jiffies;
542
543                 mutex_lock(&cdma->lock);
544                 space = cdma_status_locked(cdma,
545                                 CDMA_EVENT_SYNC_QUEUE_EMPTY);
546                 if (space) {
547                         mutex_unlock(&cdma->lock);
548                         return 0;
549                 }
550
551                 /*
552                  * Wait for sync queue to become empty. If there is already
553                  * an event pending, we need to poll.
554                  */
555                 if (cdma->event != CDMA_EVENT_NONE) {
556                         mutex_unlock(&cdma->lock);
557                         schedule();
558                 } else {
559                         cdma->event = CDMA_EVENT_SYNC_QUEUE_EMPTY;
560
561                         mutex_unlock(&cdma->lock);
562                         err = down_timeout(&cdma->sem,
563                                         jiffies_to_msecs(timeout_jiffies));
564                 }
565         }
566         return err;
567 }