24c0c0fff0c032b401b39b639c9af212b78607ef
[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 #include <linux/slab.h>
27 #include <trace/events/nvhost.h>
28 /*
29  * TODO:
30  *   stats
31  *     - for figuring out what to optimize further
32  *   resizable push buffer & sync queue
33  *     - some channels hardly need any, some channels (3d) could use more
34  */
35
36 /* Sync Queue
37  *
38  * The sync queue is a circular buffer of u32s interpreted as:
39  *   0: SyncPointID
40  *   1: SyncPointValue
41  *   2: NumSlots (how many pushbuffer slots to free)
42  *   3: NumHandles
43  *   4: nvmap client which pinned the handles
44  *   5..: NumHandles * nvmemhandle to unpin
45  *
46  * There's always one word unused, so (accounting for wrap):
47  *   - Write == Read => queue empty
48  *   - Write + 1 == Read => queue full
49  * The queue must not be left with less than SYNC_QUEUE_MIN_ENTRY words
50  * of space at the end of the array.
51  *
52  * We want to pass contiguous arrays of handles to nvmap_unpin_handles,
53  * so arrays that would wrap at the end of the buffer will be split into
54  * two (or more) entries.
55  */
56
57 /* Number of words needed to store an entry containing one handle */
58 #define SYNC_QUEUE_MIN_ENTRY (4 + (2 * sizeof(void *) / sizeof(u32)))
59
60 /**
61  * Reset to empty queue.
62  */
63 static void reset_sync_queue(struct sync_queue *queue)
64 {
65         queue->read = 0;
66         queue->write = 0;
67 }
68
69 /**
70  *  Find the number of handles that can be stashed in the sync queue without
71  *  waiting.
72  *  0 -> queue is full, must update to wait for some entries to be freed.
73  */
74 static unsigned int sync_queue_space(struct sync_queue *queue)
75 {
76         struct nvhost_cdma *cdma;
77         struct nvhost_master *host;
78
79         unsigned int read = queue->read;
80         unsigned int write = queue->write;
81         u32 size;
82
83         cdma = container_of(queue, struct nvhost_cdma, sync_queue);
84         host = cdma_to_dev(cdma);
85
86         BUG_ON(read  > (host->sync_queue_size - SYNC_QUEUE_MIN_ENTRY));
87         BUG_ON(write > (host->sync_queue_size - SYNC_QUEUE_MIN_ENTRY));
88
89         /*
90          * We can use all of the space up to the end of the buffer, unless the
91          * read position is within that space (the read position may advance
92          * asynchronously, but that can't take space away once we've seen it).
93          */
94         if (read > write) {
95                 size = (read - 1) - write;
96         } else {
97                 size = host->sync_queue_size - write;
98
99                 /*
100                  * If the read position is zero, it gets complicated. We can't
101                  * use the last word in the buffer, because that would leave
102                  * the queue empty.
103                  * But also if we use too much we would not leave enough space
104                  * for a single handle packet, and would have to wrap in
105                  * add_to_sync_queue - also leaving write == read == 0,
106                  * an empty queue.
107                  */
108                 if (read == 0)
109                         size -= SYNC_QUEUE_MIN_ENTRY;
110         }
111
112         /*
113          * There must be room for an entry header and at least one handle,
114          * otherwise we report a full queue.
115          */
116         if (size < SYNC_QUEUE_MIN_ENTRY)
117                 return 0;
118         /* Minimum entry stores one handle */
119         return (size - SYNC_QUEUE_MIN_ENTRY) + 1;
120 }
121
122 /**
123  * Add an entry to the sync queue.
124  */
125 #define entry_size(_cnt)        ((1 + _cnt)*sizeof(void *)/sizeof(u32))
126
127 static void add_to_sync_queue(struct sync_queue *queue,
128                               u32 sync_point_id, u32 sync_point_value,
129                               u32 nr_slots, struct nvmap_client *user_nvmap,
130                               struct nvmap_handle **handles, u32 nr_handles)
131 {
132         struct nvhost_cdma *cdma;
133         struct nvhost_master *host;
134         u32 write = queue->write;
135         u32 *p = queue->buffer + write;
136         u32 size = 4 + (entry_size(nr_handles));
137
138         cdma = container_of(queue, struct nvhost_cdma, sync_queue);
139         host = cdma_to_dev(cdma);
140
141         BUG_ON(sync_point_id == NVSYNCPT_INVALID);
142         BUG_ON(sync_queue_space(queue) < nr_handles);
143
144         write += size;
145         BUG_ON(write > host->sync_queue_size);
146
147         *p++ = sync_point_id;
148         *p++ = sync_point_value;
149         *p++ = nr_slots;
150         *p++ = nr_handles;
151         BUG_ON(!user_nvmap);
152         *(struct nvmap_client **)p = nvmap_client_get(user_nvmap);
153
154         p = (u32 *)((void *)p + sizeof(struct nvmap_client *));
155
156         if (nr_handles)
157                 memcpy(p, handles, nr_handles * sizeof(struct nvmap_handle *));
158
159         /* If there's not enough room for another entry, wrap to the start. */
160         if ((write + SYNC_QUEUE_MIN_ENTRY) > host->sync_queue_size) {
161                 /*
162                  * It's an error for the read position to be zero, as that
163                  * would mean we emptied the queue while adding something.
164                  */
165                 BUG_ON(queue->read == 0);
166                 write = 0;
167         }
168
169         queue->write = write;
170 }
171
172 /**
173  * Get a pointer to the next entry in the queue, or NULL if the queue is empty.
174  * Doesn't consume the entry.
175  */
176 static u32 *sync_queue_head(struct sync_queue *queue)
177 {
178         struct nvhost_cdma *cdma = container_of(queue,
179                                                 struct nvhost_cdma,
180                                                 sync_queue);
181         struct nvhost_master *host = cdma_to_dev(cdma);
182         u32 read = queue->read;
183         u32 write = queue->write;
184
185         BUG_ON(read  > (host->sync_queue_size - SYNC_QUEUE_MIN_ENTRY));
186         BUG_ON(write > (host->sync_queue_size - SYNC_QUEUE_MIN_ENTRY));
187
188         if (read == write)
189                 return NULL;
190         return queue->buffer + read;
191 }
192
193 /**
194  * Advances to the next queue entry, if you want to consume it.
195  */
196 static void
197 dequeue_sync_queue_head(struct sync_queue *queue)
198 {
199         struct nvhost_cdma *cdma = container_of(queue,
200                                                 struct nvhost_cdma,
201                                                 sync_queue);
202         struct nvhost_master *host = cdma_to_dev(cdma);
203         u32 read = queue->read;
204         u32 size;
205
206         BUG_ON(read == queue->write);
207
208         size = 4 + entry_size(queue->buffer[read + 3]);
209
210         read += size;
211         BUG_ON(read > host->sync_queue_size);
212
213         /* If there's not enough room for another entry, wrap to the start. */
214         if ((read + SYNC_QUEUE_MIN_ENTRY) > host->sync_queue_size)
215                 read = 0;
216
217         queue->read = read;
218 }
219
220
221
222 /**
223  * Return the status of the cdma's sync queue or push buffer for the given event
224  *  - sq empty: returns 1 for empty, 0 for not empty (as in "1 empty queue" :-)
225  *  - sq space: returns the number of handles that can be stored in the queue
226  *  - pb space: returns the number of free slots in the channel's push buffer
227  * Must be called with the cdma lock held.
228  */
229 static unsigned int cdma_status(struct nvhost_cdma *cdma, enum cdma_event event)
230 {
231         switch (event) {
232         case CDMA_EVENT_SYNC_QUEUE_EMPTY:
233                 return sync_queue_head(&cdma->sync_queue) ? 0 : 1;
234         case CDMA_EVENT_SYNC_QUEUE_SPACE:
235                 return sync_queue_space(&cdma->sync_queue);
236         case CDMA_EVENT_PUSH_BUFFER_SPACE: {
237                 struct push_buffer *pb = &cdma->push_buffer;
238                 BUG_ON(!cdma_pb_op(cdma).space);
239                 return cdma_pb_op(cdma).space(pb);
240         }
241         default:
242                 return 0;
243         }
244 }
245
246 /**
247  * Sleep (if necessary) until the requested event happens
248  *   - CDMA_EVENT_SYNC_QUEUE_EMPTY : sync queue is completely empty.
249  *     - Returns 1
250  *   - CDMA_EVENT_SYNC_QUEUE_SPACE : there is space in the sync queue.
251  *   - CDMA_EVENT_PUSH_BUFFER_SPACE : there is space in the push buffer
252  *     - Return the amount of space (> 0)
253  * Must be called with the cdma lock held.
254  */
255 unsigned int nvhost_cdma_wait(struct nvhost_cdma *cdma, enum cdma_event event)
256 {
257         for (;;) {
258                 unsigned int space = cdma_status(cdma, event);
259                 if (space)
260                         return space;
261
262                 trace_nvhost_wait_cdma(cdma_to_channel(cdma)->desc->name,
263                                 event);
264
265                 BUG_ON(cdma->event != CDMA_EVENT_NONE);
266                 cdma->event = event;
267
268                 mutex_unlock(&cdma->lock);
269                 down(&cdma->sem);
270                 mutex_lock(&cdma->lock);
271         }
272 }
273
274 /**
275  * For all sync queue entries that have already finished according to the
276  * current sync point registers:
277  *  - unpin & unref their mems
278  *  - pop their push buffer slots
279  *  - remove them from the sync queue
280  * This is normally called from the host code's worker thread, but can be
281  * called manually if necessary.
282  * Must be called with the cdma lock held.
283  */
284 static void update_cdma(struct nvhost_cdma *cdma)
285 {
286         bool signal = false;
287         struct nvhost_master *dev = cdma_to_dev(cdma);
288
289         BUG_ON(!cdma->running);
290
291         /*
292          * Walk the sync queue, reading the sync point registers as necessary,
293          * to consume as many sync queue entries as possible without blocking
294          */
295         for (;;) {
296                 u32 syncpt_id, syncpt_val;
297                 unsigned int nr_slots, nr_handles;
298                 struct nvmap_handle **handles;
299                 struct nvmap_client *nvmap;
300                 u32 *sync;
301
302                 sync = sync_queue_head(&cdma->sync_queue);
303                 if (!sync) {
304                         if (cdma->event == CDMA_EVENT_SYNC_QUEUE_EMPTY)
305                                 signal = true;
306                         break;
307                 }
308
309                 syncpt_id = *sync++;
310                 syncpt_val = *sync++;
311
312                 BUG_ON(syncpt_id == NVSYNCPT_INVALID);
313
314                 /* Check whether this syncpt has completed, and bail if not */
315                 if (!nvhost_syncpt_min_cmp(&dev->syncpt, syncpt_id, syncpt_val))
316                         break;
317
318                 nr_slots = *sync++;
319                 nr_handles = *sync++;
320                 nvmap = *(struct nvmap_client **)sync;
321                 sync = ((void *)sync + sizeof(struct nvmap_client *));
322                 handles = (struct nvmap_handle **)sync;
323
324                 BUG_ON(!nvmap);
325
326                 /* Unpin the memory */
327                 nvmap_unpin_handles(nvmap, handles, nr_handles);
328
329                 nvmap_client_put(nvmap);
330
331                 /* Pop push buffer slots */
332                 if (nr_slots) {
333                         struct push_buffer *pb = &cdma->push_buffer;
334                         BUG_ON(!cdma_pb_op(cdma).pop_from);
335                         cdma_pb_op(cdma).pop_from(pb, nr_slots);
336                         if (cdma->event == CDMA_EVENT_PUSH_BUFFER_SPACE)
337                                 signal = true;
338                 }
339
340                 dequeue_sync_queue_head(&cdma->sync_queue);
341                 if (cdma->event == CDMA_EVENT_SYNC_QUEUE_SPACE)
342                         signal = true;
343         }
344
345         /* Wake up CdmaWait() if the requested event happened */
346         if (signal) {
347                 cdma->event = CDMA_EVENT_NONE;
348                 up(&cdma->sem);
349         }
350 }
351
352 /**
353  * Create a cdma
354  */
355 int nvhost_cdma_init(struct nvhost_cdma *cdma)
356 {
357         int err;
358         struct push_buffer *pb = &cdma->push_buffer;
359         BUG_ON(!cdma_pb_op(cdma).init);
360         mutex_init(&cdma->lock);
361         sema_init(&cdma->sem, 0);
362         cdma->event = CDMA_EVENT_NONE;
363         cdma->running = false;
364
365         /* allocate sync queue memory */
366         cdma->sync_queue.buffer = kzalloc(cdma_to_dev(cdma)->sync_queue_size
367                                           * sizeof(u32), GFP_KERNEL);
368         if (!cdma->sync_queue.buffer)
369                 return -ENOMEM;
370
371         err = cdma_pb_op(cdma).init(pb);
372         if (err)
373                 return err;
374         reset_sync_queue(&cdma->sync_queue);
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         BUG_ON(!cdma_pb_op(cdma).destroy);
385         BUG_ON(cdma->running);
386         kfree(cdma->sync_queue.buffer);
387         cdma->sync_queue.buffer = 0;
388         cdma_pb_op(cdma).destroy(pb);
389 }
390
391
392 /**
393  * Begin a cdma submit
394  */
395 void nvhost_cdma_begin(struct nvhost_cdma *cdma)
396 {
397         BUG_ON(!cdma_op(cdma).start);
398         mutex_lock(&cdma->lock);
399         if (!cdma->running)
400                 cdma_op(cdma).start(cdma);
401         cdma->slots_free = 0;
402         cdma->slots_used = 0;
403 }
404
405 /**
406  * Push two words into a push buffer slot
407  * Blocks as necessary if the push buffer is full.
408  */
409 void nvhost_cdma_push(struct nvhost_cdma *cdma, u32 op1, u32 op2)
410 {
411         u32 slots_free = cdma->slots_free;
412         struct push_buffer *pb = &cdma->push_buffer;
413         BUG_ON(!cdma_pb_op(cdma).push_to);
414         BUG_ON(!cdma_op(cdma).kick);
415         if (slots_free == 0) {
416                 cdma_op(cdma).kick(cdma);
417                 slots_free = nvhost_cdma_wait(cdma, CDMA_EVENT_PUSH_BUFFER_SPACE);
418         }
419         cdma->slots_free = slots_free - 1;
420         cdma->slots_used++;
421         cdma_pb_op(cdma).push_to(pb, op1, op2);
422 }
423
424 /**
425  * End a cdma submit
426  * Kick off DMA, add a contiguous block of memory handles to the sync queue,
427  * and a number of slots to be freed from the pushbuffer.
428  * Blocks as necessary if the sync queue is full.
429  * The handles for a submit must all be pinned at the same time, but they
430  * can be unpinned in smaller chunks.
431  */
432 void nvhost_cdma_end(struct nvhost_cdma *cdma,
433                 struct nvmap_client *user_nvmap,
434                 u32 sync_point_id, u32 sync_point_value,
435                 struct nvmap_handle **handles, unsigned int nr_handles)
436 {
437         BUG_ON(!cdma_op(cdma).kick);
438         cdma_op(cdma).kick(cdma);
439
440         while (nr_handles || cdma->slots_used) {
441                 unsigned int count;
442                 /*
443                  * Wait until there's enough room in the
444                  * sync queue to write something.
445                  */
446                 count = nvhost_cdma_wait(cdma, CDMA_EVENT_SYNC_QUEUE_SPACE);
447
448                 /* Add reloc entries to sync queue (as many as will fit) */
449                 if (count > nr_handles)
450                         count = nr_handles;
451                 add_to_sync_queue(&cdma->sync_queue, sync_point_id,
452                                   sync_point_value, cdma->slots_used,
453                                   user_nvmap, handles, count);
454                 /* NumSlots only goes in the first packet */
455                 cdma->slots_used = 0;
456                 handles += count;
457                 nr_handles -= count;
458         }
459
460         mutex_unlock(&cdma->lock);
461 }
462
463 /**
464  * Update cdma state according to current sync point values
465  */
466 void nvhost_cdma_update(struct nvhost_cdma *cdma)
467 {
468         mutex_lock(&cdma->lock);
469         update_cdma(cdma);
470         mutex_unlock(&cdma->lock);
471 }
472
473 /**
474  * Manually spin until all CDMA has finished. Used if an async update
475  * cannot be scheduled for any reason.
476  */
477 void nvhost_cdma_flush(struct nvhost_cdma *cdma)
478 {
479         mutex_lock(&cdma->lock);
480         while (sync_queue_head(&cdma->sync_queue)) {
481                 update_cdma(cdma);
482                 mutex_unlock(&cdma->lock);
483                 schedule();
484                 mutex_lock(&cdma->lock);
485         }
486         mutex_unlock(&cdma->lock);
487 }
488