Merge branch 'for-np' of git://git.wormnet.eu/alex/ts78xx into orion/master
[linux-2.6] / drivers / media / video / cx18 / cx18-queue.c
1 /*
2  *  cx18 buffer queues
3  *
4  *  Derived from ivtv-queue.c
5  *
6  *  Copyright (C) 2007  Hans Verkuil <hverkuil@xs4all.nl>
7  *  Copyright (C) 2008  Andy Walls <awalls@radix.net>
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2 of the License, or
12  *  (at your option) any later version.
13  *
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License
20  *  along with this program; if not, write to the Free Software
21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
22  *  02111-1307  USA
23  */
24
25 #include "cx18-driver.h"
26 #include "cx18-streams.h"
27 #include "cx18-queue.h"
28 #include "cx18-scb.h"
29
30 void cx18_buf_swap(struct cx18_buffer *buf)
31 {
32         int i;
33
34         for (i = 0; i < buf->bytesused; i += 4)
35                 swab32s((u32 *)(buf->buf + i));
36 }
37
38 void cx18_queue_init(struct cx18_queue *q)
39 {
40         INIT_LIST_HEAD(&q->list);
41         atomic_set(&q->buffers, 0);
42         q->bytesused = 0;
43 }
44
45 struct cx18_queue *_cx18_enqueue(struct cx18_stream *s, struct cx18_buffer *buf,
46                                  struct cx18_queue *q, int to_front)
47 {
48         /* clear the buffer if it is not to be enqueued to the full queue */
49         if (q != &s->q_full) {
50                 buf->bytesused = 0;
51                 buf->readpos = 0;
52                 buf->b_flags = 0;
53                 buf->skipped = 0;
54         }
55
56         mutex_lock(&s->qlock);
57
58         /* q_busy is restricted to a max buffer count imposed by firmware */
59         if (q == &s->q_busy &&
60             atomic_read(&q->buffers) >= CX18_MAX_FW_MDLS_PER_STREAM)
61                 q = &s->q_free;
62
63         if (to_front)
64                 list_add(&buf->list, &q->list); /* LIFO */
65         else
66                 list_add_tail(&buf->list, &q->list); /* FIFO */
67         q->bytesused += buf->bytesused - buf->readpos;
68         atomic_inc(&q->buffers);
69
70         mutex_unlock(&s->qlock);
71         return q;
72 }
73
74 struct cx18_buffer *cx18_dequeue(struct cx18_stream *s, struct cx18_queue *q)
75 {
76         struct cx18_buffer *buf = NULL;
77
78         mutex_lock(&s->qlock);
79         if (!list_empty(&q->list)) {
80                 buf = list_first_entry(&q->list, struct cx18_buffer, list);
81                 list_del_init(&buf->list);
82                 q->bytesused -= buf->bytesused - buf->readpos;
83                 buf->skipped = 0;
84                 atomic_dec(&q->buffers);
85         }
86         mutex_unlock(&s->qlock);
87         return buf;
88 }
89
90 struct cx18_buffer *cx18_queue_get_buf(struct cx18_stream *s, u32 id,
91         u32 bytesused)
92 {
93         struct cx18 *cx = s->cx;
94         struct cx18_buffer *buf;
95         struct cx18_buffer *tmp;
96         struct cx18_buffer *ret = NULL;
97
98         mutex_lock(&s->qlock);
99         list_for_each_entry_safe(buf, tmp, &s->q_busy.list, list) {
100                 if (buf->id != id) {
101                         buf->skipped++;
102                         if (buf->skipped >= atomic_read(&s->q_busy.buffers)-1) {
103                                 /* buffer must have fallen out of rotation */
104                                 CX18_WARN("Skipped %s, buffer %d, %d "
105                                           "times - it must have dropped out of "
106                                           "rotation\n", s->name, buf->id,
107                                           buf->skipped);
108                                 /* move it to q_free */
109                                 list_move_tail(&buf->list, &s->q_free.list);
110                                 buf->bytesused = buf->readpos = buf->b_flags =
111                                         buf->skipped = 0;
112                                 atomic_dec(&s->q_busy.buffers);
113                                 atomic_inc(&s->q_free.buffers);
114                         }
115                         continue;
116                 }
117
118                 buf->bytesused = bytesused;
119                 /* Sync the buffer before we release the qlock */
120                 cx18_buf_sync_for_cpu(s, buf);
121                 if (s->type == CX18_ENC_STREAM_TYPE_TS) {
122                         /*
123                          * TS doesn't use q_full.  As we pull the buffer off of
124                          * the queue here, the caller will have to put it back.
125                          */
126                         list_del_init(&buf->list);
127                 } else {
128                         /* Move buffer from q_busy to q_full */
129                         list_move_tail(&buf->list, &s->q_full.list);
130                         set_bit(CX18_F_B_NEED_BUF_SWAP, &buf->b_flags);
131                         s->q_full.bytesused += buf->bytesused;
132                         atomic_inc(&s->q_full.buffers);
133                 }
134                 atomic_dec(&s->q_busy.buffers);
135
136                 ret = buf;
137                 break;
138         }
139         mutex_unlock(&s->qlock);
140         return ret;
141 }
142
143 /* Move all buffers of a queue to q_free, while flushing the buffers */
144 static void cx18_queue_flush(struct cx18_stream *s, struct cx18_queue *q)
145 {
146         struct cx18_buffer *buf;
147
148         if (q == &s->q_free)
149                 return;
150
151         mutex_lock(&s->qlock);
152         while (!list_empty(&q->list)) {
153                 buf = list_first_entry(&q->list, struct cx18_buffer, list);
154                 list_move_tail(&buf->list, &s->q_free.list);
155                 buf->bytesused = buf->readpos = buf->b_flags = buf->skipped = 0;
156                 atomic_inc(&s->q_free.buffers);
157         }
158         cx18_queue_init(q);
159         mutex_unlock(&s->qlock);
160 }
161
162 void cx18_flush_queues(struct cx18_stream *s)
163 {
164         cx18_queue_flush(s, &s->q_busy);
165         cx18_queue_flush(s, &s->q_full);
166 }
167
168 int cx18_stream_alloc(struct cx18_stream *s)
169 {
170         struct cx18 *cx = s->cx;
171         int i;
172
173         if (s->buffers == 0)
174                 return 0;
175
176         CX18_DEBUG_INFO("Allocate %s stream: %d x %d buffers (%dkB total)\n",
177                 s->name, s->buffers, s->buf_size,
178                 s->buffers * s->buf_size / 1024);
179
180         if (((char __iomem *)&cx->scb->cpu_mdl[cx->mdl_offset + s->buffers] -
181                                 (char __iomem *)cx->scb) > SCB_RESERVED_SIZE) {
182                 unsigned bufsz = (((char __iomem *)cx->scb) + SCB_RESERVED_SIZE -
183                                         ((char __iomem *)cx->scb->cpu_mdl));
184
185                 CX18_ERR("Too many buffers, cannot fit in SCB area\n");
186                 CX18_ERR("Max buffers = %zd\n",
187                         bufsz / sizeof(struct cx18_mdl));
188                 return -ENOMEM;
189         }
190
191         s->mdl_offset = cx->mdl_offset;
192
193         /* allocate stream buffers. Initially all buffers are in q_free. */
194         for (i = 0; i < s->buffers; i++) {
195                 struct cx18_buffer *buf = kzalloc(sizeof(struct cx18_buffer),
196                                                 GFP_KERNEL|__GFP_NOWARN);
197
198                 if (buf == NULL)
199                         break;
200                 buf->buf = kmalloc(s->buf_size, GFP_KERNEL|__GFP_NOWARN);
201                 if (buf->buf == NULL) {
202                         kfree(buf);
203                         break;
204                 }
205                 buf->id = cx->buffer_id++;
206                 INIT_LIST_HEAD(&buf->list);
207                 buf->dma_handle = pci_map_single(s->cx->dev,
208                                 buf->buf, s->buf_size, s->dma);
209                 cx18_buf_sync_for_cpu(s, buf);
210                 cx18_enqueue(s, buf, &s->q_free);
211         }
212         if (i == s->buffers) {
213                 cx->mdl_offset += s->buffers;
214                 return 0;
215         }
216         CX18_ERR("Couldn't allocate buffers for %s stream\n", s->name);
217         cx18_stream_free(s);
218         return -ENOMEM;
219 }
220
221 void cx18_stream_free(struct cx18_stream *s)
222 {
223         struct cx18_buffer *buf;
224
225         /* move all buffers to q_free */
226         cx18_flush_queues(s);
227
228         /* empty q_free */
229         while ((buf = cx18_dequeue(s, &s->q_free))) {
230                 pci_unmap_single(s->cx->dev, buf->dma_handle,
231                                 s->buf_size, s->dma);
232                 kfree(buf->buf);
233                 kfree(buf);
234         }
235 }