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