]>
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> | |
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, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |
21 | * 02111-1307 USA | |
22 | */ | |
23 | ||
24 | #include "cx18-driver.h" | |
25 | #include "cx18-streams.h" | |
26 | #include "cx18-queue.h" | |
27 | #include "cx18-scb.h" | |
28 | ||
1c1e45d1 HV |
29 | void cx18_buf_swap(struct cx18_buffer *buf) |
30 | { | |
31 | int i; | |
32 | ||
33 | for (i = 0; i < buf->bytesused; i += 4) | |
34 | swab32s((u32 *)(buf->buf + i)); | |
35 | } | |
36 | ||
37 | void cx18_queue_init(struct cx18_queue *q) | |
38 | { | |
39 | INIT_LIST_HEAD(&q->list); | |
b04bce47 | 40 | atomic_set(&q->buffers, 0); |
1c1e45d1 HV |
41 | q->bytesused = 0; |
42 | } | |
43 | ||
44 | void cx18_enqueue(struct cx18_stream *s, struct cx18_buffer *buf, | |
45 | struct cx18_queue *q) | |
46 | { | |
47 | unsigned long flags = 0; | |
48 | ||
49 | /* clear the buffer if it is going to be enqueued to the free queue */ | |
50 | if (q == &s->q_free) { | |
51 | buf->bytesused = 0; | |
52 | buf->readpos = 0; | |
53 | buf->b_flags = 0; | |
54 | } | |
55 | spin_lock_irqsave(&s->qlock, flags); | |
56 | list_add_tail(&buf->list, &q->list); | |
b04bce47 | 57 | atomic_inc(&q->buffers); |
1c1e45d1 HV |
58 | q->bytesused += buf->bytesused - buf->readpos; |
59 | spin_unlock_irqrestore(&s->qlock, flags); | |
60 | } | |
61 | ||
62 | struct cx18_buffer *cx18_dequeue(struct cx18_stream *s, struct cx18_queue *q) | |
63 | { | |
64 | struct cx18_buffer *buf = NULL; | |
65 | unsigned long flags = 0; | |
66 | ||
67 | spin_lock_irqsave(&s->qlock, flags); | |
68 | if (!list_empty(&q->list)) { | |
69 | buf = list_entry(q->list.next, struct cx18_buffer, list); | |
70 | list_del_init(q->list.next); | |
b04bce47 | 71 | atomic_dec(&q->buffers); |
1c1e45d1 HV |
72 | q->bytesused -= buf->bytesused - buf->readpos; |
73 | } | |
74 | spin_unlock_irqrestore(&s->qlock, flags); | |
75 | return buf; | |
76 | } | |
77 | ||
0058717a | 78 | struct cx18_buffer *cx18_queue_get_buf_irq(struct cx18_stream *s, u32 id, |
1c1e45d1 HV |
79 | u32 bytesused) |
80 | { | |
81 | struct cx18 *cx = s->cx; | |
82 | struct list_head *p; | |
83 | ||
0058717a | 84 | spin_lock(&s->qlock); |
1c1e45d1 HV |
85 | list_for_each(p, &s->q_free.list) { |
86 | struct cx18_buffer *buf = | |
87 | list_entry(p, struct cx18_buffer, list); | |
88 | ||
89 | if (buf->id != id) | |
90 | continue; | |
1d6782bd | 91 | |
1c1e45d1 | 92 | buf->bytesused = bytesused; |
1d6782bd AW |
93 | atomic_dec(&s->q_free.buffers); |
94 | atomic_inc(&s->q_full.buffers); | |
95 | s->q_full.bytesused += buf->bytesused; | |
96 | list_move_tail(&buf->list, &s->q_full.list); | |
97 | ||
0058717a | 98 | spin_unlock(&s->qlock); |
1c1e45d1 HV |
99 | return buf; |
100 | } | |
0058717a | 101 | spin_unlock(&s->qlock); |
1c1e45d1 HV |
102 | CX18_ERR("Cannot find buffer %d for stream %s\n", id, s->name); |
103 | return NULL; | |
104 | } | |
105 | ||
6c9de528 AW |
106 | /* Move all buffers of a queue to q_free, while flushing the buffers */ |
107 | static void cx18_queue_flush(struct cx18_stream *s, struct cx18_queue *q) | |
1c1e45d1 HV |
108 | { |
109 | unsigned long flags; | |
6c9de528 | 110 | struct cx18_buffer *buf; |
1c1e45d1 | 111 | |
6c9de528 AW |
112 | if (q == &s->q_free) |
113 | return; | |
1c1e45d1 | 114 | |
6c9de528 AW |
115 | spin_lock_irqsave(&s->qlock, flags); |
116 | while (!list_empty(&q->list)) { | |
117 | buf = list_entry(q->list.next, struct cx18_buffer, list); | |
118 | list_move_tail(q->list.next, &s->q_free.list); | |
119 | buf->bytesused = buf->readpos = buf->b_flags = 0; | |
b04bce47 | 120 | atomic_inc(&s->q_free.buffers); |
1c1e45d1 | 121 | } |
6c9de528 | 122 | cx18_queue_init(q); |
1c1e45d1 | 123 | spin_unlock_irqrestore(&s->qlock, flags); |
1c1e45d1 HV |
124 | } |
125 | ||
126 | void cx18_flush_queues(struct cx18_stream *s) | |
127 | { | |
6c9de528 AW |
128 | cx18_queue_flush(s, &s->q_io); |
129 | cx18_queue_flush(s, &s->q_full); | |
1c1e45d1 HV |
130 | } |
131 | ||
132 | int cx18_stream_alloc(struct cx18_stream *s) | |
133 | { | |
134 | struct cx18 *cx = s->cx; | |
135 | int i; | |
136 | ||
137 | if (s->buffers == 0) | |
138 | return 0; | |
139 | ||
140 | CX18_DEBUG_INFO("Allocate %s stream: %d x %d buffers (%dkB total)\n", | |
141 | s->name, s->buffers, s->buf_size, | |
142 | s->buffers * s->buf_size / 1024); | |
143 | ||
c6eb8eaf HV |
144 | if (((char __iomem *)&cx->scb->cpu_mdl[cx->mdl_offset + s->buffers] - |
145 | (char __iomem *)cx->scb) > SCB_RESERVED_SIZE) { | |
146 | unsigned bufsz = (((char __iomem *)cx->scb) + SCB_RESERVED_SIZE - | |
147 | ((char __iomem *)cx->scb->cpu_mdl)); | |
1c1e45d1 HV |
148 | |
149 | CX18_ERR("Too many buffers, cannot fit in SCB area\n"); | |
150 | CX18_ERR("Max buffers = %zd\n", | |
151 | bufsz / sizeof(struct cx18_mdl)); | |
152 | return -ENOMEM; | |
153 | } | |
154 | ||
155 | s->mdl_offset = cx->mdl_offset; | |
156 | ||
157 | /* allocate stream buffers. Initially all buffers are in q_free. */ | |
158 | for (i = 0; i < s->buffers; i++) { | |
3f98387e HV |
159 | struct cx18_buffer *buf = kzalloc(sizeof(struct cx18_buffer), |
160 | GFP_KERNEL|__GFP_NOWARN); | |
1c1e45d1 HV |
161 | |
162 | if (buf == NULL) | |
163 | break; | |
3f98387e | 164 | buf->buf = kmalloc(s->buf_size, GFP_KERNEL|__GFP_NOWARN); |
1c1e45d1 HV |
165 | if (buf->buf == NULL) { |
166 | kfree(buf); | |
167 | break; | |
168 | } | |
169 | buf->id = cx->buffer_id++; | |
170 | INIT_LIST_HEAD(&buf->list); | |
171 | buf->dma_handle = pci_map_single(s->cx->dev, | |
172 | buf->buf, s->buf_size, s->dma); | |
173 | cx18_buf_sync_for_cpu(s, buf); | |
174 | cx18_enqueue(s, buf, &s->q_free); | |
175 | } | |
176 | if (i == s->buffers) { | |
177 | cx->mdl_offset += s->buffers; | |
178 | return 0; | |
179 | } | |
180 | CX18_ERR("Couldn't allocate buffers for %s stream\n", s->name); | |
181 | cx18_stream_free(s); | |
182 | return -ENOMEM; | |
183 | } | |
184 | ||
185 | void cx18_stream_free(struct cx18_stream *s) | |
186 | { | |
187 | struct cx18_buffer *buf; | |
188 | ||
189 | /* move all buffers to q_free */ | |
190 | cx18_flush_queues(s); | |
191 | ||
192 | /* empty q_free */ | |
193 | while ((buf = cx18_dequeue(s, &s->q_free))) { | |
194 | pci_unmap_single(s->cx->dev, buf->dma_handle, | |
195 | s->buf_size, s->dma); | |
196 | kfree(buf->buf); | |
197 | kfree(buf); | |
198 | } | |
199 | } |