This source file includes following definitions.
- _queue_setup
- _buffer_prepare
- _buffer_queue
- _start_streaming
- _stop_streaming
- _dmxdev_lock
- _dmxdev_unlock
- _fill_dmx_buffer
- _fill_vb2_buffer
- dvb_vb2_init
- dvb_vb2_release
- dvb_vb2_stream_on
- dvb_vb2_stream_off
- dvb_vb2_is_streaming
- dvb_vb2_fill_buffer
- dvb_vb2_reqbufs
- dvb_vb2_querybuf
- dvb_vb2_expbuf
- dvb_vb2_qbuf
- dvb_vb2_dqbuf
- dvb_vb2_mmap
- dvb_vb2_poll
1
2
3
4
5
6
7
8
9
10
11
12
13
14 #include <linux/err.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/mm.h>
18
19 #include <media/dvbdev.h>
20 #include <media/dvb_vb2.h>
21
22 #define DVB_V2_MAX_SIZE (4096 * 188)
23
24 static int vb2_debug;
25 module_param(vb2_debug, int, 0644);
26
27 #define dprintk(level, fmt, arg...) \
28 do { \
29 if (vb2_debug >= level) \
30 pr_info("vb2: %s: " fmt, __func__, ## arg); \
31 } while (0)
32
33 static int _queue_setup(struct vb2_queue *vq,
34 unsigned int *nbuffers, unsigned int *nplanes,
35 unsigned int sizes[], struct device *alloc_devs[])
36 {
37 struct dvb_vb2_ctx *ctx = vb2_get_drv_priv(vq);
38
39 ctx->buf_cnt = *nbuffers;
40 *nplanes = 1;
41 sizes[0] = ctx->buf_siz;
42
43
44
45
46
47
48 dprintk(3, "[%s] count=%d, size=%d\n", ctx->name,
49 *nbuffers, sizes[0]);
50
51 return 0;
52 }
53
54 static int _buffer_prepare(struct vb2_buffer *vb)
55 {
56 struct dvb_vb2_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
57 unsigned long size = ctx->buf_siz;
58
59 if (vb2_plane_size(vb, 0) < size) {
60 dprintk(1, "[%s] data will not fit into plane (%lu < %lu)\n",
61 ctx->name, vb2_plane_size(vb, 0), size);
62 return -EINVAL;
63 }
64
65 vb2_set_plane_payload(vb, 0, size);
66 dprintk(3, "[%s]\n", ctx->name);
67
68 return 0;
69 }
70
71 static void _buffer_queue(struct vb2_buffer *vb)
72 {
73 struct dvb_vb2_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
74 struct dvb_buffer *buf = container_of(vb, struct dvb_buffer, vb);
75 unsigned long flags = 0;
76
77 spin_lock_irqsave(&ctx->slock, flags);
78 list_add_tail(&buf->list, &ctx->dvb_q);
79 spin_unlock_irqrestore(&ctx->slock, flags);
80
81 dprintk(3, "[%s]\n", ctx->name);
82 }
83
84 static int _start_streaming(struct vb2_queue *vq, unsigned int count)
85 {
86 struct dvb_vb2_ctx *ctx = vb2_get_drv_priv(vq);
87
88 dprintk(3, "[%s] count=%d\n", ctx->name, count);
89 return 0;
90 }
91
92 static void _stop_streaming(struct vb2_queue *vq)
93 {
94 struct dvb_vb2_ctx *ctx = vb2_get_drv_priv(vq);
95 struct dvb_buffer *buf;
96 unsigned long flags = 0;
97
98 dprintk(3, "[%s]\n", ctx->name);
99
100 spin_lock_irqsave(&ctx->slock, flags);
101 while (!list_empty(&ctx->dvb_q)) {
102 buf = list_entry(ctx->dvb_q.next,
103 struct dvb_buffer, list);
104 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
105 list_del(&buf->list);
106 }
107 spin_unlock_irqrestore(&ctx->slock, flags);
108 }
109
110 static void _dmxdev_lock(struct vb2_queue *vq)
111 {
112 struct dvb_vb2_ctx *ctx = vb2_get_drv_priv(vq);
113
114 mutex_lock(&ctx->mutex);
115 dprintk(3, "[%s]\n", ctx->name);
116 }
117
118 static void _dmxdev_unlock(struct vb2_queue *vq)
119 {
120 struct dvb_vb2_ctx *ctx = vb2_get_drv_priv(vq);
121
122 if (mutex_is_locked(&ctx->mutex))
123 mutex_unlock(&ctx->mutex);
124 dprintk(3, "[%s]\n", ctx->name);
125 }
126
127 static const struct vb2_ops dvb_vb2_qops = {
128 .queue_setup = _queue_setup,
129 .buf_prepare = _buffer_prepare,
130 .buf_queue = _buffer_queue,
131 .start_streaming = _start_streaming,
132 .stop_streaming = _stop_streaming,
133 .wait_prepare = _dmxdev_unlock,
134 .wait_finish = _dmxdev_lock,
135 };
136
137 static void _fill_dmx_buffer(struct vb2_buffer *vb, void *pb)
138 {
139 struct dvb_vb2_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
140 struct dmx_buffer *b = pb;
141
142 b->index = vb->index;
143 b->length = vb->planes[0].length;
144 b->bytesused = vb->planes[0].bytesused;
145 b->offset = vb->planes[0].m.offset;
146 dprintk(3, "[%s]\n", ctx->name);
147 }
148
149 static int _fill_vb2_buffer(struct vb2_buffer *vb, struct vb2_plane *planes)
150 {
151 struct dvb_vb2_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
152
153 planes[0].bytesused = 0;
154 dprintk(3, "[%s]\n", ctx->name);
155
156 return 0;
157 }
158
159 static const struct vb2_buf_ops dvb_vb2_buf_ops = {
160 .fill_user_buffer = _fill_dmx_buffer,
161 .fill_vb2_buffer = _fill_vb2_buffer,
162 };
163
164
165
166
167 int dvb_vb2_init(struct dvb_vb2_ctx *ctx, const char *name, int nonblocking)
168 {
169 struct vb2_queue *q = &ctx->vb_q;
170 int ret;
171
172 memset(ctx, 0, sizeof(struct dvb_vb2_ctx));
173 q->type = DVB_BUF_TYPE_CAPTURE;
174
175 q->is_output = 0;
176
177 q->io_modes = VB2_MMAP;
178 q->drv_priv = ctx;
179 q->buf_struct_size = sizeof(struct dvb_buffer);
180 q->min_buffers_needed = 1;
181 q->ops = &dvb_vb2_qops;
182 q->mem_ops = &vb2_vmalloc_memops;
183 q->buf_ops = &dvb_vb2_buf_ops;
184 q->num_buffers = 0;
185 ret = vb2_core_queue_init(q);
186 if (ret) {
187 ctx->state = DVB_VB2_STATE_NONE;
188 dprintk(1, "[%s] errno=%d\n", ctx->name, ret);
189 return ret;
190 }
191
192 mutex_init(&ctx->mutex);
193 spin_lock_init(&ctx->slock);
194 INIT_LIST_HEAD(&ctx->dvb_q);
195
196 strscpy(ctx->name, name, DVB_VB2_NAME_MAX);
197 ctx->nonblocking = nonblocking;
198 ctx->state = DVB_VB2_STATE_INIT;
199
200 dprintk(3, "[%s]\n", ctx->name);
201
202 return 0;
203 }
204
205 int dvb_vb2_release(struct dvb_vb2_ctx *ctx)
206 {
207 struct vb2_queue *q = (struct vb2_queue *)&ctx->vb_q;
208
209 if (ctx->state & DVB_VB2_STATE_INIT)
210 vb2_core_queue_release(q);
211
212 ctx->state = DVB_VB2_STATE_NONE;
213 dprintk(3, "[%s]\n", ctx->name);
214
215 return 0;
216 }
217
218 int dvb_vb2_stream_on(struct dvb_vb2_ctx *ctx)
219 {
220 struct vb2_queue *q = &ctx->vb_q;
221 int ret;
222
223 ret = vb2_core_streamon(q, q->type);
224 if (ret) {
225 ctx->state = DVB_VB2_STATE_NONE;
226 dprintk(1, "[%s] errno=%d\n", ctx->name, ret);
227 return ret;
228 }
229 ctx->state |= DVB_VB2_STATE_STREAMON;
230 dprintk(3, "[%s]\n", ctx->name);
231
232 return 0;
233 }
234
235 int dvb_vb2_stream_off(struct dvb_vb2_ctx *ctx)
236 {
237 struct vb2_queue *q = (struct vb2_queue *)&ctx->vb_q;
238 int ret;
239
240 ctx->state &= ~DVB_VB2_STATE_STREAMON;
241 ret = vb2_core_streamoff(q, q->type);
242 if (ret) {
243 ctx->state = DVB_VB2_STATE_NONE;
244 dprintk(1, "[%s] errno=%d\n", ctx->name, ret);
245 return ret;
246 }
247 dprintk(3, "[%s]\n", ctx->name);
248
249 return 0;
250 }
251
252 int dvb_vb2_is_streaming(struct dvb_vb2_ctx *ctx)
253 {
254 return (ctx->state & DVB_VB2_STATE_STREAMON);
255 }
256
257 int dvb_vb2_fill_buffer(struct dvb_vb2_ctx *ctx,
258 const unsigned char *src, int len,
259 enum dmx_buffer_flags *buffer_flags)
260 {
261 unsigned long flags = 0;
262 void *vbuf = NULL;
263 int todo = len;
264 unsigned char *psrc = (unsigned char *)src;
265 int ll = 0;
266
267
268
269
270
271 if (!src || !len)
272 return 0;
273 spin_lock_irqsave(&ctx->slock, flags);
274 if (buffer_flags && *buffer_flags) {
275 ctx->flags |= *buffer_flags;
276 *buffer_flags = 0;
277 }
278 while (todo) {
279 if (!ctx->buf) {
280 if (list_empty(&ctx->dvb_q)) {
281 dprintk(3, "[%s] Buffer overflow!!!\n",
282 ctx->name);
283 break;
284 }
285
286 ctx->buf = list_entry(ctx->dvb_q.next,
287 struct dvb_buffer, list);
288 ctx->remain = vb2_plane_size(&ctx->buf->vb, 0);
289 ctx->offset = 0;
290 }
291
292 if (!dvb_vb2_is_streaming(ctx)) {
293 vb2_buffer_done(&ctx->buf->vb, VB2_BUF_STATE_ERROR);
294 list_del(&ctx->buf->list);
295 ctx->buf = NULL;
296 break;
297 }
298
299
300 ll = min(todo, ctx->remain);
301 vbuf = vb2_plane_vaddr(&ctx->buf->vb, 0);
302 memcpy(vbuf + ctx->offset, psrc, ll);
303 todo -= ll;
304 psrc += ll;
305
306 ctx->remain -= ll;
307 ctx->offset += ll;
308
309 if (ctx->remain == 0) {
310 vb2_buffer_done(&ctx->buf->vb, VB2_BUF_STATE_DONE);
311 list_del(&ctx->buf->list);
312 ctx->buf = NULL;
313 }
314 }
315
316 if (ctx->nonblocking && ctx->buf) {
317 vb2_set_plane_payload(&ctx->buf->vb, 0, ll);
318 vb2_buffer_done(&ctx->buf->vb, VB2_BUF_STATE_DONE);
319 list_del(&ctx->buf->list);
320 ctx->buf = NULL;
321 }
322 spin_unlock_irqrestore(&ctx->slock, flags);
323
324 if (todo)
325 dprintk(1, "[%s] %d bytes are dropped.\n", ctx->name, todo);
326 else
327 dprintk(3, "[%s]\n", ctx->name);
328
329 dprintk(3, "[%s] %d bytes are copied\n", ctx->name, len - todo);
330 return (len - todo);
331 }
332
333 int dvb_vb2_reqbufs(struct dvb_vb2_ctx *ctx, struct dmx_requestbuffers *req)
334 {
335 int ret;
336
337
338 if (req->size > DVB_V2_MAX_SIZE)
339 req->size = DVB_V2_MAX_SIZE;
340
341
342
343 ctx->buf_siz = req->size;
344 ctx->buf_cnt = req->count;
345 ret = vb2_core_reqbufs(&ctx->vb_q, VB2_MEMORY_MMAP, &req->count);
346 if (ret) {
347 ctx->state = DVB_VB2_STATE_NONE;
348 dprintk(1, "[%s] count=%d size=%d errno=%d\n", ctx->name,
349 ctx->buf_cnt, ctx->buf_siz, ret);
350 return ret;
351 }
352 ctx->state |= DVB_VB2_STATE_REQBUFS;
353 dprintk(3, "[%s] count=%d size=%d\n", ctx->name,
354 ctx->buf_cnt, ctx->buf_siz);
355
356 return 0;
357 }
358
359 int dvb_vb2_querybuf(struct dvb_vb2_ctx *ctx, struct dmx_buffer *b)
360 {
361 vb2_core_querybuf(&ctx->vb_q, b->index, b);
362 dprintk(3, "[%s] index=%d\n", ctx->name, b->index);
363 return 0;
364 }
365
366 int dvb_vb2_expbuf(struct dvb_vb2_ctx *ctx, struct dmx_exportbuffer *exp)
367 {
368 struct vb2_queue *q = &ctx->vb_q;
369 int ret;
370
371 ret = vb2_core_expbuf(&ctx->vb_q, &exp->fd, q->type, exp->index,
372 0, exp->flags);
373 if (ret) {
374 dprintk(1, "[%s] index=%d errno=%d\n", ctx->name,
375 exp->index, ret);
376 return ret;
377 }
378 dprintk(3, "[%s] index=%d fd=%d\n", ctx->name, exp->index, exp->fd);
379
380 return 0;
381 }
382
383 int dvb_vb2_qbuf(struct dvb_vb2_ctx *ctx, struct dmx_buffer *b)
384 {
385 int ret;
386
387 ret = vb2_core_qbuf(&ctx->vb_q, b->index, b, NULL);
388 if (ret) {
389 dprintk(1, "[%s] index=%d errno=%d\n", ctx->name,
390 b->index, ret);
391 return ret;
392 }
393 dprintk(5, "[%s] index=%d\n", ctx->name, b->index);
394
395 return 0;
396 }
397
398 int dvb_vb2_dqbuf(struct dvb_vb2_ctx *ctx, struct dmx_buffer *b)
399 {
400 unsigned long flags;
401 int ret;
402
403 ret = vb2_core_dqbuf(&ctx->vb_q, &b->index, b, ctx->nonblocking);
404 if (ret) {
405 dprintk(1, "[%s] errno=%d\n", ctx->name, ret);
406 return ret;
407 }
408
409 spin_lock_irqsave(&ctx->slock, flags);
410 b->count = ctx->count++;
411 b->flags = ctx->flags;
412 ctx->flags = 0;
413 spin_unlock_irqrestore(&ctx->slock, flags);
414
415 dprintk(5, "[%s] index=%d, count=%d, flags=%d\n",
416 ctx->name, b->index, ctx->count, b->flags);
417
418
419 return 0;
420 }
421
422 int dvb_vb2_mmap(struct dvb_vb2_ctx *ctx, struct vm_area_struct *vma)
423 {
424 int ret;
425
426 ret = vb2_mmap(&ctx->vb_q, vma);
427 if (ret) {
428 dprintk(1, "[%s] errno=%d\n", ctx->name, ret);
429 return ret;
430 }
431 dprintk(3, "[%s] ret=%d\n", ctx->name, ret);
432
433 return 0;
434 }
435
436 __poll_t dvb_vb2_poll(struct dvb_vb2_ctx *ctx, struct file *file,
437 poll_table *wait)
438 {
439 dprintk(3, "[%s]\n", ctx->name);
440 return vb2_core_poll(&ctx->vb_q, file, wait);
441 }
442