Commit | Line | Data |
---|---|---|
1c1e45d1 HV |
1 | /* |
2 | * cx18 buffer queues | |
3 | * | |
4 | * Derived from ivtv-queue.c | |
5 | * | |
6 | * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl> | |
1ed9dcc8 | 7 | * Copyright (C) 2008 Andy Walls <awalls@radix.net> |
1c1e45d1 HV |
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" | |
1c1e45d1 | 26 | #include "cx18-queue.h" |
21a278b8 | 27 | #include "cx18-streams.h" |
1c1e45d1 HV |
28 | #include "cx18-scb.h" |
29 | ||
1c1e45d1 HV |
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); | |
b04bce47 | 41 | atomic_set(&q->buffers, 0); |
1c1e45d1 HV |
42 | q->bytesused = 0; |
43 | } | |
44 | ||
66c2a6b0 AW |
45 | struct cx18_queue *_cx18_enqueue(struct cx18_stream *s, struct cx18_buffer *buf, |
46 | struct cx18_queue *q, int to_front) | |
1c1e45d1 | 47 | { |
66c2a6b0 AW |
48 | /* clear the buffer if it is not to be enqueued to the full queue */ |
49 | if (q != &s->q_full) { | |
1c1e45d1 HV |
50 | buf->bytesused = 0; |
51 | buf->readpos = 0; | |
52 | buf->b_flags = 0; | |
bca11a57 | 53 | buf->skipped = 0; |
1c1e45d1 | 54 | } |
66c2a6b0 | 55 | |
0ef02892 AW |
56 | /* q_busy is restricted to a max buffer count imposed by firmware */ |
57 | if (q == &s->q_busy && | |
58 | atomic_read(&q->buffers) >= CX18_MAX_FW_MDLS_PER_STREAM) | |
66c2a6b0 AW |
59 | q = &s->q_free; |
60 | ||
40c5520f AW |
61 | spin_lock(&q->lock); |
62 | ||
b80e1074 AW |
63 | if (to_front) |
64 | list_add(&buf->list, &q->list); /* LIFO */ | |
65 | else | |
66 | list_add_tail(&buf->list, &q->list); /* FIFO */ | |
1c1e45d1 | 67 | q->bytesused += buf->bytesused - buf->readpos; |
66c2a6b0 AW |
68 | atomic_inc(&q->buffers); |
69 | ||
40c5520f | 70 | spin_unlock(&q->lock); |
66c2a6b0 | 71 | return q; |
1c1e45d1 HV |
72 | } |
73 | ||
74 | struct cx18_buffer *cx18_dequeue(struct cx18_stream *s, struct cx18_queue *q) | |
75 | { | |
76 | struct cx18_buffer *buf = NULL; | |
1c1e45d1 | 77 | |
40c5520f | 78 | spin_lock(&q->lock); |
1c1e45d1 | 79 | if (!list_empty(&q->list)) { |
f6b181ac AW |
80 | buf = list_first_entry(&q->list, struct cx18_buffer, list); |
81 | list_del_init(&buf->list); | |
1c1e45d1 | 82 | q->bytesused -= buf->bytesused - buf->readpos; |
bca11a57 | 83 | buf->skipped = 0; |
66c2a6b0 | 84 | atomic_dec(&q->buffers); |
1c1e45d1 | 85 | } |
40c5520f | 86 | spin_unlock(&q->lock); |
1c1e45d1 HV |
87 | return buf; |
88 | } | |
89 | ||
ee2d64f5 | 90 | struct cx18_buffer *cx18_queue_get_buf(struct cx18_stream *s, u32 id, |
1c1e45d1 HV |
91 | u32 bytesused) |
92 | { | |
93 | struct cx18 *cx = s->cx; | |
bca11a57 | 94 | struct cx18_buffer *buf; |
f6b181ac | 95 | struct cx18_buffer *tmp; |
bca11a57 | 96 | struct cx18_buffer *ret = NULL; |
40c5520f AW |
97 | LIST_HEAD(sweep_up); |
98 | ||
99 | /* | |
100 | * We don't have to acquire multiple q locks here, because we are | |
101 | * serialized by the single threaded work handler. | |
102 | * Buffers from the firmware will thus remain in order as | |
103 | * they are moved from q_busy to q_full or to the dvb ring buffer. | |
104 | */ | |
105 | spin_lock(&s->q_busy.lock); | |
f6b181ac | 106 | list_for_each_entry_safe(buf, tmp, &s->q_busy.list, list) { |
40c5520f AW |
107 | /* |
108 | * We should find what the firmware told us is done, | |
109 | * right at the front of the queue. If we don't, we likely have | |
110 | * missed a buffer done message from the firmware. | |
111 | * Once we skip a buffer repeatedly, relative to the size of | |
112 | * q_busy, we have high confidence we've missed it. | |
113 | */ | |
ee2d64f5 | 114 | if (buf->id != id) { |
bca11a57 | 115 | buf->skipped++; |
66c2a6b0 | 116 | if (buf->skipped >= atomic_read(&s->q_busy.buffers)-1) { |
bca11a57 | 117 | /* buffer must have fallen out of rotation */ |
bca11a57 AW |
118 | CX18_WARN("Skipped %s, buffer %d, %d " |
119 | "times - it must have dropped out of " | |
120 | "rotation\n", s->name, buf->id, | |
121 | buf->skipped); | |
40c5520f AW |
122 | /* Sweep it up to put it back into rotation */ |
123 | list_move_tail(&buf->list, &sweep_up); | |
66c2a6b0 | 124 | atomic_dec(&s->q_busy.buffers); |
bca11a57 | 125 | } |
1c1e45d1 | 126 | continue; |
ee2d64f5 | 127 | } |
40c5520f AW |
128 | /* |
129 | * We pull the desired buffer off of the queue here. Something | |
130 | * will have to put it back on a queue later. | |
131 | */ | |
132 | list_del_init(&buf->list); | |
66c2a6b0 | 133 | atomic_dec(&s->q_busy.buffers); |
bca11a57 AW |
134 | ret = buf; |
135 | break; | |
1c1e45d1 | 136 | } |
40c5520f AW |
137 | spin_unlock(&s->q_busy.lock); |
138 | ||
139 | /* | |
140 | * We found the buffer for which we were looking. Get it ready for | |
141 | * the caller to put on q_full or in the dvb ring buffer. | |
142 | */ | |
143 | if (ret != NULL) { | |
144 | ret->bytesused = bytesused; | |
145 | ret->skipped = 0; | |
146 | /* readpos and b_flags were 0'ed when the buf went on q_busy */ | |
147 | cx18_buf_sync_for_cpu(s, ret); | |
148 | if (s->type != CX18_ENC_STREAM_TYPE_TS) | |
149 | set_bit(CX18_F_B_NEED_BUF_SWAP, &ret->b_flags); | |
150 | } | |
151 | ||
152 | /* Put any buffers the firmware is ignoring back into normal rotation */ | |
153 | list_for_each_entry_safe(buf, tmp, &sweep_up, list) { | |
154 | list_del_init(&buf->list); | |
155 | cx18_enqueue(s, buf, &s->q_free); | |
156 | } | |
bca11a57 | 157 | return ret; |
1c1e45d1 HV |
158 | } |
159 | ||
6c9de528 AW |
160 | /* Move all buffers of a queue to q_free, while flushing the buffers */ |
161 | static void cx18_queue_flush(struct cx18_stream *s, struct cx18_queue *q) | |
1c1e45d1 | 162 | { |
6c9de528 | 163 | struct cx18_buffer *buf; |
1c1e45d1 | 164 | |
6c9de528 AW |
165 | if (q == &s->q_free) |
166 | return; | |
1c1e45d1 | 167 | |
40c5520f | 168 | spin_lock(&q->lock); |
6c9de528 | 169 | while (!list_empty(&q->list)) { |
f6b181ac AW |
170 | buf = list_first_entry(&q->list, struct cx18_buffer, list); |
171 | list_move_tail(&buf->list, &s->q_free.list); | |
bca11a57 | 172 | buf->bytesused = buf->readpos = buf->b_flags = buf->skipped = 0; |
b04bce47 | 173 | atomic_inc(&s->q_free.buffers); |
1c1e45d1 | 174 | } |
6c9de528 | 175 | cx18_queue_init(q); |
40c5520f | 176 | spin_unlock(&q->lock); |
1c1e45d1 HV |
177 | } |
178 | ||
179 | void cx18_flush_queues(struct cx18_stream *s) | |
180 | { | |
66c2a6b0 | 181 | cx18_queue_flush(s, &s->q_busy); |
6c9de528 | 182 | cx18_queue_flush(s, &s->q_full); |
1c1e45d1 HV |
183 | } |
184 | ||
185 | int cx18_stream_alloc(struct cx18_stream *s) | |
186 | { | |
187 | struct cx18 *cx = s->cx; | |
188 | int i; | |
189 | ||
190 | if (s->buffers == 0) | |
191 | return 0; | |
192 | ||
193 | CX18_DEBUG_INFO("Allocate %s stream: %d x %d buffers (%dkB total)\n", | |
194 | s->name, s->buffers, s->buf_size, | |
195 | s->buffers * s->buf_size / 1024); | |
196 | ||
c6eb8eaf HV |
197 | if (((char __iomem *)&cx->scb->cpu_mdl[cx->mdl_offset + s->buffers] - |
198 | (char __iomem *)cx->scb) > SCB_RESERVED_SIZE) { | |
199 | unsigned bufsz = (((char __iomem *)cx->scb) + SCB_RESERVED_SIZE - | |
200 | ((char __iomem *)cx->scb->cpu_mdl)); | |
1c1e45d1 HV |
201 | |
202 | CX18_ERR("Too many buffers, cannot fit in SCB area\n"); | |
203 | CX18_ERR("Max buffers = %zd\n", | |
204 | bufsz / sizeof(struct cx18_mdl)); | |
205 | return -ENOMEM; | |
206 | } | |
207 | ||
208 | s->mdl_offset = cx->mdl_offset; | |
209 | ||
210 | /* allocate stream buffers. Initially all buffers are in q_free. */ | |
211 | for (i = 0; i < s->buffers; i++) { | |
3f98387e HV |
212 | struct cx18_buffer *buf = kzalloc(sizeof(struct cx18_buffer), |
213 | GFP_KERNEL|__GFP_NOWARN); | |
1c1e45d1 HV |
214 | |
215 | if (buf == NULL) | |
216 | break; | |
3f98387e | 217 | buf->buf = kmalloc(s->buf_size, GFP_KERNEL|__GFP_NOWARN); |
1c1e45d1 HV |
218 | if (buf->buf == NULL) { |
219 | kfree(buf); | |
220 | break; | |
221 | } | |
222 | buf->id = cx->buffer_id++; | |
223 | INIT_LIST_HEAD(&buf->list); | |
3d05913d | 224 | buf->dma_handle = pci_map_single(s->cx->pci_dev, |
1c1e45d1 HV |
225 | buf->buf, s->buf_size, s->dma); |
226 | cx18_buf_sync_for_cpu(s, buf); | |
227 | cx18_enqueue(s, buf, &s->q_free); | |
228 | } | |
229 | if (i == s->buffers) { | |
230 | cx->mdl_offset += s->buffers; | |
231 | return 0; | |
232 | } | |
233 | CX18_ERR("Couldn't allocate buffers for %s stream\n", s->name); | |
234 | cx18_stream_free(s); | |
235 | return -ENOMEM; | |
236 | } | |
237 | ||
238 | void cx18_stream_free(struct cx18_stream *s) | |
239 | { | |
240 | struct cx18_buffer *buf; | |
241 | ||
242 | /* move all buffers to q_free */ | |
243 | cx18_flush_queues(s); | |
244 | ||
245 | /* empty q_free */ | |
246 | while ((buf = cx18_dequeue(s, &s->q_free))) { | |
3d05913d | 247 | pci_unmap_single(s->cx->pci_dev, buf->dma_handle, |
1c1e45d1 HV |
248 | s->buf_size, s->dma); |
249 | kfree(buf->buf); | |
250 | kfree(buf); | |
251 | } | |
252 | } |