1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | buffer queues. |
4 | Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com> |
5 | Copyright (C) 2004 Chris Kennedy <c@groovy.org> |
6 | Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl> |
7 | |
8 | */ |
9 | |
10 | #include "ivtv-driver.h" |
11 | #include "ivtv-queue.h" |
12 | |
13 | int ivtv_buf_copy_from_user(struct ivtv_stream *s, struct ivtv_buffer *buf, const char __user *src, int copybytes) |
14 | { |
15 | if (s->buf_size - buf->bytesused < copybytes) |
16 | copybytes = s->buf_size - buf->bytesused; |
17 | if (copy_from_user(to: buf->buf + buf->bytesused, from: src, n: copybytes)) { |
18 | return -EFAULT; |
19 | } |
20 | buf->bytesused += copybytes; |
21 | return copybytes; |
22 | } |
23 | |
24 | void ivtv_buf_swap(struct ivtv_buffer *buf) |
25 | { |
26 | int i; |
27 | |
28 | for (i = 0; i < buf->bytesused; i += 4) |
29 | swab32s(p: (u32 *)(buf->buf + i)); |
30 | } |
31 | |
32 | void ivtv_queue_init(struct ivtv_queue *q) |
33 | { |
34 | INIT_LIST_HEAD(list: &q->list); |
35 | q->buffers = 0; |
36 | q->length = 0; |
37 | q->bytesused = 0; |
38 | } |
39 | |
40 | void ivtv_enqueue(struct ivtv_stream *s, struct ivtv_buffer *buf, struct ivtv_queue *q) |
41 | { |
42 | unsigned long flags; |
43 | |
44 | /* clear the buffer if it is going to be enqueued to the free queue */ |
45 | if (q == &s->q_free) { |
46 | buf->bytesused = 0; |
47 | buf->readpos = 0; |
48 | buf->b_flags = 0; |
49 | buf->dma_xfer_cnt = 0; |
50 | } |
51 | spin_lock_irqsave(&s->qlock, flags); |
52 | list_add_tail(new: &buf->list, head: &q->list); |
53 | q->buffers++; |
54 | q->length += s->buf_size; |
55 | q->bytesused += buf->bytesused - buf->readpos; |
56 | spin_unlock_irqrestore(lock: &s->qlock, flags); |
57 | } |
58 | |
59 | struct ivtv_buffer *ivtv_dequeue(struct ivtv_stream *s, struct ivtv_queue *q) |
60 | { |
61 | struct ivtv_buffer *buf = NULL; |
62 | unsigned long flags; |
63 | |
64 | spin_lock_irqsave(&s->qlock, flags); |
65 | if (!list_empty(head: &q->list)) { |
66 | buf = list_entry(q->list.next, struct ivtv_buffer, list); |
67 | list_del_init(entry: q->list.next); |
68 | q->buffers--; |
69 | q->length -= s->buf_size; |
70 | q->bytesused -= buf->bytesused - buf->readpos; |
71 | } |
72 | spin_unlock_irqrestore(lock: &s->qlock, flags); |
73 | return buf; |
74 | } |
75 | |
76 | static void ivtv_queue_move_buf(struct ivtv_stream *s, struct ivtv_queue *from, |
77 | struct ivtv_queue *to, int clear) |
78 | { |
79 | struct ivtv_buffer *buf = list_entry(from->list.next, struct ivtv_buffer, list); |
80 | |
81 | list_move_tail(list: from->list.next, head: &to->list); |
82 | from->buffers--; |
83 | from->length -= s->buf_size; |
84 | from->bytesused -= buf->bytesused - buf->readpos; |
85 | /* special handling for q_free */ |
86 | if (clear) |
87 | buf->bytesused = buf->readpos = buf->b_flags = buf->dma_xfer_cnt = 0; |
88 | to->buffers++; |
89 | to->length += s->buf_size; |
90 | to->bytesused += buf->bytesused - buf->readpos; |
91 | } |
92 | |
93 | /* Move 'needed_bytes' worth of buffers from queue 'from' into queue 'to'. |
94 | If 'needed_bytes' == 0, then move all buffers from 'from' into 'to'. |
95 | If 'steal' != NULL, then buffers may also taken from that queue if |
96 | needed, but only if 'from' is the free queue. |
97 | |
98 | The buffer is automatically cleared if it goes to the free queue. It is |
99 | also cleared if buffers need to be taken from the 'steal' queue and |
100 | the 'from' queue is the free queue. |
101 | |
102 | When 'from' is q_free, then needed_bytes is compared to the total |
103 | available buffer length, otherwise needed_bytes is compared to the |
104 | bytesused value. For the 'steal' queue the total available buffer |
105 | length is always used. |
106 | |
107 | -ENOMEM is returned if the buffers could not be obtained, 0 if all |
108 | buffers where obtained from the 'from' list and if non-zero then |
109 | the number of stolen buffers is returned. */ |
110 | int ivtv_queue_move(struct ivtv_stream *s, struct ivtv_queue *from, struct ivtv_queue *steal, |
111 | struct ivtv_queue *to, int needed_bytes) |
112 | { |
113 | unsigned long flags; |
114 | int rc = 0; |
115 | int from_free = from == &s->q_free; |
116 | int to_free = to == &s->q_free; |
117 | int bytes_available, bytes_steal; |
118 | |
119 | spin_lock_irqsave(&s->qlock, flags); |
120 | if (needed_bytes == 0) { |
121 | from_free = 1; |
122 | needed_bytes = from->length; |
123 | } |
124 | |
125 | bytes_available = from_free ? from->length : from->bytesused; |
126 | bytes_steal = (from_free && steal) ? steal->length : 0; |
127 | |
128 | if (bytes_available + bytes_steal < needed_bytes) { |
129 | spin_unlock_irqrestore(lock: &s->qlock, flags); |
130 | return -ENOMEM; |
131 | } |
132 | while (steal && bytes_available < needed_bytes) { |
133 | struct ivtv_buffer *buf = list_entry(steal->list.prev, struct ivtv_buffer, list); |
134 | u16 dma_xfer_cnt = buf->dma_xfer_cnt; |
135 | |
136 | /* move buffers from the tail of the 'steal' queue to the tail of the |
137 | 'from' queue. Always copy all the buffers with the same dma_xfer_cnt |
138 | value, this ensures that you do not end up with partial frame data |
139 | if one frame is stored in multiple buffers. */ |
140 | while (dma_xfer_cnt == buf->dma_xfer_cnt) { |
141 | list_move_tail(list: steal->list.prev, head: &from->list); |
142 | rc++; |
143 | steal->buffers--; |
144 | steal->length -= s->buf_size; |
145 | steal->bytesused -= buf->bytesused - buf->readpos; |
146 | buf->bytesused = buf->readpos = buf->b_flags = buf->dma_xfer_cnt = 0; |
147 | from->buffers++; |
148 | from->length += s->buf_size; |
149 | bytes_available += s->buf_size; |
150 | if (list_empty(head: &steal->list)) |
151 | break; |
152 | buf = list_entry(steal->list.prev, struct ivtv_buffer, list); |
153 | } |
154 | } |
155 | if (from_free) { |
156 | u32 old_length = to->length; |
157 | |
158 | while (to->length - old_length < needed_bytes) { |
159 | ivtv_queue_move_buf(s, from, to, clear: 1); |
160 | } |
161 | } |
162 | else { |
163 | u32 old_bytesused = to->bytesused; |
164 | |
165 | while (to->bytesused - old_bytesused < needed_bytes) { |
166 | ivtv_queue_move_buf(s, from, to, clear: to_free); |
167 | } |
168 | } |
169 | spin_unlock_irqrestore(lock: &s->qlock, flags); |
170 | return rc; |
171 | } |
172 | |
173 | void ivtv_flush_queues(struct ivtv_stream *s) |
174 | { |
175 | ivtv_queue_move(s, from: &s->q_io, NULL, to: &s->q_free, needed_bytes: 0); |
176 | ivtv_queue_move(s, from: &s->q_full, NULL, to: &s->q_free, needed_bytes: 0); |
177 | ivtv_queue_move(s, from: &s->q_dma, NULL, to: &s->q_free, needed_bytes: 0); |
178 | ivtv_queue_move(s, from: &s->q_predma, NULL, to: &s->q_free, needed_bytes: 0); |
179 | } |
180 | |
181 | int ivtv_stream_alloc(struct ivtv_stream *s) |
182 | { |
183 | struct ivtv *itv = s->itv; |
184 | int SGsize = sizeof(struct ivtv_sg_host_element) * s->buffers; |
185 | int i; |
186 | |
187 | if (s->buffers == 0) |
188 | return 0; |
189 | |
190 | IVTV_DEBUG_INFO("Allocate %s%s stream: %d x %d buffers (%dkB total)\n" , |
191 | s->dma != DMA_NONE ? "DMA " : "" , |
192 | s->name, s->buffers, s->buf_size, s->buffers * s->buf_size / 1024); |
193 | |
194 | s->sg_pending = kzalloc(size: SGsize, GFP_KERNEL|__GFP_NOWARN); |
195 | if (s->sg_pending == NULL) { |
196 | IVTV_ERR("Could not allocate sg_pending for %s stream\n" , s->name); |
197 | return -ENOMEM; |
198 | } |
199 | s->sg_pending_size = 0; |
200 | |
201 | s->sg_processing = kzalloc(size: SGsize, GFP_KERNEL|__GFP_NOWARN); |
202 | if (s->sg_processing == NULL) { |
203 | IVTV_ERR("Could not allocate sg_processing for %s stream\n" , s->name); |
204 | kfree(objp: s->sg_pending); |
205 | s->sg_pending = NULL; |
206 | return -ENOMEM; |
207 | } |
208 | s->sg_processing_size = 0; |
209 | |
210 | s->sg_dma = kzalloc(size: sizeof(struct ivtv_sg_element), |
211 | GFP_KERNEL|__GFP_NOWARN); |
212 | if (s->sg_dma == NULL) { |
213 | IVTV_ERR("Could not allocate sg_dma for %s stream\n" , s->name); |
214 | kfree(objp: s->sg_pending); |
215 | s->sg_pending = NULL; |
216 | kfree(objp: s->sg_processing); |
217 | s->sg_processing = NULL; |
218 | return -ENOMEM; |
219 | } |
220 | if (ivtv_might_use_dma(s)) { |
221 | s->sg_handle = dma_map_single(&itv->pdev->dev, s->sg_dma, |
222 | sizeof(struct ivtv_sg_element), |
223 | DMA_TO_DEVICE); |
224 | ivtv_stream_sync_for_cpu(s); |
225 | } |
226 | |
227 | /* allocate stream buffers. Initially all buffers are in q_free. */ |
228 | for (i = 0; i < s->buffers; i++) { |
229 | struct ivtv_buffer *buf = kzalloc(size: sizeof(struct ivtv_buffer), |
230 | GFP_KERNEL|__GFP_NOWARN); |
231 | |
232 | if (buf == NULL) |
233 | break; |
234 | buf->buf = kmalloc(size: s->buf_size + 256, GFP_KERNEL|__GFP_NOWARN); |
235 | if (buf->buf == NULL) { |
236 | kfree(objp: buf); |
237 | break; |
238 | } |
239 | INIT_LIST_HEAD(list: &buf->list); |
240 | if (ivtv_might_use_dma(s)) { |
241 | buf->dma_handle = dma_map_single(&s->itv->pdev->dev, |
242 | buf->buf, s->buf_size + 256, s->dma); |
243 | ivtv_buf_sync_for_cpu(s, buf); |
244 | } |
245 | ivtv_enqueue(s, buf, q: &s->q_free); |
246 | } |
247 | if (i == s->buffers) |
248 | return 0; |
249 | IVTV_ERR("Couldn't allocate buffers for %s stream\n" , s->name); |
250 | ivtv_stream_free(s); |
251 | return -ENOMEM; |
252 | } |
253 | |
254 | void ivtv_stream_free(struct ivtv_stream *s) |
255 | { |
256 | struct ivtv_buffer *buf; |
257 | |
258 | /* move all buffers to q_free */ |
259 | ivtv_flush_queues(s); |
260 | |
261 | /* empty q_free */ |
262 | while ((buf = ivtv_dequeue(s, q: &s->q_free))) { |
263 | if (ivtv_might_use_dma(s)) |
264 | dma_unmap_single(&s->itv->pdev->dev, buf->dma_handle, |
265 | s->buf_size + 256, s->dma); |
266 | kfree(objp: buf->buf); |
267 | kfree(objp: buf); |
268 | } |
269 | |
270 | /* Free SG Array/Lists */ |
271 | if (s->sg_dma != NULL) { |
272 | if (s->sg_handle != IVTV_DMA_UNMAPPED) { |
273 | dma_unmap_single(&s->itv->pdev->dev, s->sg_handle, |
274 | sizeof(struct ivtv_sg_element), |
275 | DMA_TO_DEVICE); |
276 | s->sg_handle = IVTV_DMA_UNMAPPED; |
277 | } |
278 | kfree(objp: s->sg_pending); |
279 | kfree(objp: s->sg_processing); |
280 | kfree(objp: s->sg_dma); |
281 | s->sg_pending = NULL; |
282 | s->sg_processing = NULL; |
283 | s->sg_dma = NULL; |
284 | s->sg_pending_size = 0; |
285 | s->sg_processing_size = 0; |
286 | } |
287 | } |
288 | |