xref: /openbmc/linux/drivers/media/dvb-core/dvb_vb2.c (revision 98ddec80) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * dvb-vb2.c - dvb-vb2
4  *
5  * Copyright (C) 2015 Samsung Electronics
6  *
7  * Author: jh1009.sung@samsung.com
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.
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 	 * videobuf2-vmalloc allocator is context-less so no need to set
45 	 * alloc_ctxs array.
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,
150 			    const void *pb, struct vb2_plane *planes)
151 {
152 	struct dvb_vb2_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
153 
154 	planes[0].bytesused = 0;
155 	dprintk(3, "[%s]\n", ctx->name);
156 
157 	return 0;
158 }
159 
160 static const struct vb2_buf_ops dvb_vb2_buf_ops = {
161 	.fill_user_buffer	= _fill_dmx_buffer,
162 	.fill_vb2_buffer	= _fill_vb2_buffer,
163 };
164 
165 /*
166  * Videobuf operations
167  */
168 int dvb_vb2_init(struct dvb_vb2_ctx *ctx, const char *name, int nonblocking)
169 {
170 	struct vb2_queue *q = &ctx->vb_q;
171 	int ret;
172 
173 	memset(ctx, 0, sizeof(struct dvb_vb2_ctx));
174 	q->type = DVB_BUF_TYPE_CAPTURE;
175 	/**capture type*/
176 	q->is_output = 0;
177 	/**only mmap is supported currently*/
178 	q->io_modes = VB2_MMAP;
179 	q->drv_priv = ctx;
180 	q->buf_struct_size = sizeof(struct dvb_buffer);
181 	q->min_buffers_needed = 1;
182 	q->ops = &dvb_vb2_qops;
183 	q->mem_ops = &vb2_vmalloc_memops;
184 	q->buf_ops = &dvb_vb2_buf_ops;
185 	q->num_buffers = 0;
186 	ret = vb2_core_queue_init(q);
187 	if (ret) {
188 		ctx->state = DVB_VB2_STATE_NONE;
189 		dprintk(1, "[%s] errno=%d\n", ctx->name, ret);
190 		return ret;
191 	}
192 
193 	mutex_init(&ctx->mutex);
194 	spin_lock_init(&ctx->slock);
195 	INIT_LIST_HEAD(&ctx->dvb_q);
196 
197 	strlcpy(ctx->name, name, DVB_VB2_NAME_MAX);
198 	ctx->nonblocking = nonblocking;
199 	ctx->state = DVB_VB2_STATE_INIT;
200 
201 	dprintk(3, "[%s]\n", ctx->name);
202 
203 	return 0;
204 }
205 
206 int dvb_vb2_release(struct dvb_vb2_ctx *ctx)
207 {
208 	struct vb2_queue *q = (struct vb2_queue *)&ctx->vb_q;
209 
210 	if (ctx->state & DVB_VB2_STATE_INIT)
211 		vb2_core_queue_release(q);
212 
213 	ctx->state = DVB_VB2_STATE_NONE;
214 	dprintk(3, "[%s]\n", ctx->name);
215 
216 	return 0;
217 }
218 
219 int dvb_vb2_stream_on(struct dvb_vb2_ctx *ctx)
220 {
221 	struct vb2_queue *q = &ctx->vb_q;
222 	int ret;
223 
224 	ret = vb2_core_streamon(q, q->type);
225 	if (ret) {
226 		ctx->state = DVB_VB2_STATE_NONE;
227 		dprintk(1, "[%s] errno=%d\n", ctx->name, ret);
228 		return ret;
229 	}
230 	ctx->state |= DVB_VB2_STATE_STREAMON;
231 	dprintk(3, "[%s]\n", ctx->name);
232 
233 	return 0;
234 }
235 
236 int dvb_vb2_stream_off(struct dvb_vb2_ctx *ctx)
237 {
238 	struct vb2_queue *q = (struct vb2_queue *)&ctx->vb_q;
239 	int ret;
240 
241 	ctx->state &= ~DVB_VB2_STATE_STREAMON;
242 	ret = vb2_core_streamoff(q, q->type);
243 	if (ret) {
244 		ctx->state = DVB_VB2_STATE_NONE;
245 		dprintk(1, "[%s] errno=%d\n", ctx->name, ret);
246 		return ret;
247 	}
248 	dprintk(3, "[%s]\n", ctx->name);
249 
250 	return 0;
251 }
252 
253 int dvb_vb2_is_streaming(struct dvb_vb2_ctx *ctx)
254 {
255 	return (ctx->state & DVB_VB2_STATE_STREAMON);
256 }
257 
258 int dvb_vb2_fill_buffer(struct dvb_vb2_ctx *ctx,
259 			const unsigned char *src, int len,
260 			enum dmx_buffer_flags *buffer_flags)
261 {
262 	unsigned long flags = 0;
263 	void *vbuf = NULL;
264 	int todo = len;
265 	unsigned char *psrc = (unsigned char *)src;
266 	int ll = 0;
267 
268 	/*
269 	 * normal case: This func is called twice from demux driver
270 	 * one with valid src pointer, second time with NULL pointer
271 	 */
272 	if (!src || !len)
273 		return 0;
274 	spin_lock_irqsave(&ctx->slock, flags);
275 	if (buffer_flags && *buffer_flags) {
276 		ctx->flags |= *buffer_flags;
277 		*buffer_flags = 0;
278 	}
279 	while (todo) {
280 		if (!ctx->buf) {
281 			if (list_empty(&ctx->dvb_q)) {
282 				dprintk(3, "[%s] Buffer overflow!!!\n",
283 					ctx->name);
284 				break;
285 			}
286 
287 			ctx->buf = list_entry(ctx->dvb_q.next,
288 					      struct dvb_buffer, list);
289 			ctx->remain = vb2_plane_size(&ctx->buf->vb, 0);
290 			ctx->offset = 0;
291 		}
292 
293 		if (!dvb_vb2_is_streaming(ctx)) {
294 			vb2_buffer_done(&ctx->buf->vb, VB2_BUF_STATE_ERROR);
295 			list_del(&ctx->buf->list);
296 			ctx->buf = NULL;
297 			break;
298 		}
299 
300 		/* Fill buffer */
301 		ll = min(todo, ctx->remain);
302 		vbuf = vb2_plane_vaddr(&ctx->buf->vb, 0);
303 		memcpy(vbuf + ctx->offset, psrc, ll);
304 		todo -= ll;
305 		psrc += ll;
306 
307 		ctx->remain -= ll;
308 		ctx->offset += ll;
309 
310 		if (ctx->remain == 0) {
311 			vb2_buffer_done(&ctx->buf->vb, VB2_BUF_STATE_DONE);
312 			list_del(&ctx->buf->list);
313 			ctx->buf = NULL;
314 		}
315 	}
316 
317 	if (ctx->nonblocking && ctx->buf) {
318 		vb2_set_plane_payload(&ctx->buf->vb, 0, ll);
319 		vb2_buffer_done(&ctx->buf->vb, VB2_BUF_STATE_DONE);
320 		list_del(&ctx->buf->list);
321 		ctx->buf = NULL;
322 	}
323 	spin_unlock_irqrestore(&ctx->slock, flags);
324 
325 	if (todo)
326 		dprintk(1, "[%s] %d bytes are dropped.\n", ctx->name, todo);
327 	else
328 		dprintk(3, "[%s]\n", ctx->name);
329 
330 	dprintk(3, "[%s] %d bytes are copied\n", ctx->name, len - todo);
331 	return (len - todo);
332 }
333 
334 int dvb_vb2_reqbufs(struct dvb_vb2_ctx *ctx, struct dmx_requestbuffers *req)
335 {
336 	int ret;
337 
338 	/* Adjust size to a sane value */
339 	if (req->size > DVB_V2_MAX_SIZE)
340 		req->size = DVB_V2_MAX_SIZE;
341 
342 	/* FIXME: round req->size to a 188 or 204 multiple */
343 
344 	ctx->buf_siz = req->size;
345 	ctx->buf_cnt = req->count;
346 	ret = vb2_core_reqbufs(&ctx->vb_q, VB2_MEMORY_MMAP, &req->count);
347 	if (ret) {
348 		ctx->state = DVB_VB2_STATE_NONE;
349 		dprintk(1, "[%s] count=%d size=%d errno=%d\n", ctx->name,
350 			ctx->buf_cnt, ctx->buf_siz, ret);
351 		return ret;
352 	}
353 	ctx->state |= DVB_VB2_STATE_REQBUFS;
354 	dprintk(3, "[%s] count=%d size=%d\n", ctx->name,
355 		ctx->buf_cnt, ctx->buf_siz);
356 
357 	return 0;
358 }
359 
360 int dvb_vb2_querybuf(struct dvb_vb2_ctx *ctx, struct dmx_buffer *b)
361 {
362 	vb2_core_querybuf(&ctx->vb_q, b->index, b);
363 	dprintk(3, "[%s] index=%d\n", ctx->name, b->index);
364 	return 0;
365 }
366 
367 int dvb_vb2_expbuf(struct dvb_vb2_ctx *ctx, struct dmx_exportbuffer *exp)
368 {
369 	struct vb2_queue *q = &ctx->vb_q;
370 	int ret;
371 
372 	ret = vb2_core_expbuf(&ctx->vb_q, &exp->fd, q->type, exp->index,
373 			      0, exp->flags);
374 	if (ret) {
375 		dprintk(1, "[%s] index=%d errno=%d\n", ctx->name,
376 			exp->index, ret);
377 		return ret;
378 	}
379 	dprintk(3, "[%s] index=%d fd=%d\n", ctx->name, exp->index, exp->fd);
380 
381 	return 0;
382 }
383 
384 int dvb_vb2_qbuf(struct dvb_vb2_ctx *ctx, struct dmx_buffer *b)
385 {
386 	int ret;
387 
388 	ret = vb2_core_qbuf(&ctx->vb_q, b->index, b);
389 	if (ret) {
390 		dprintk(1, "[%s] index=%d errno=%d\n", ctx->name,
391 			b->index, ret);
392 		return ret;
393 	}
394 	dprintk(5, "[%s] index=%d\n", ctx->name, b->index);
395 
396 	return 0;
397 }
398 
399 int dvb_vb2_dqbuf(struct dvb_vb2_ctx *ctx, struct dmx_buffer *b)
400 {
401 	unsigned long flags;
402 	int ret;
403 
404 	ret = vb2_core_dqbuf(&ctx->vb_q, &b->index, b, ctx->nonblocking);
405 	if (ret) {
406 		dprintk(1, "[%s] errno=%d\n", ctx->name, ret);
407 		return ret;
408 	}
409 
410 	spin_lock_irqsave(&ctx->slock, flags);
411 	b->count = ctx->count++;
412 	b->flags = ctx->flags;
413 	ctx->flags = 0;
414 	spin_unlock_irqrestore(&ctx->slock, flags);
415 
416 	dprintk(5, "[%s] index=%d, count=%d, flags=%d\n",
417 		ctx->name, b->index, ctx->count, b->flags);
418 
419 
420 	return 0;
421 }
422 
423 int dvb_vb2_mmap(struct dvb_vb2_ctx *ctx, struct vm_area_struct *vma)
424 {
425 	int ret;
426 
427 	ret = vb2_mmap(&ctx->vb_q, vma);
428 	if (ret) {
429 		dprintk(1, "[%s] errno=%d\n", ctx->name, ret);
430 		return ret;
431 	}
432 	dprintk(3, "[%s] ret=%d\n", ctx->name, ret);
433 
434 	return 0;
435 }
436 
437 __poll_t dvb_vb2_poll(struct dvb_vb2_ctx *ctx, struct file *file,
438 		      poll_table *wait)
439 {
440 	dprintk(3, "[%s]\n", ctx->name);
441 	return vb2_core_poll(&ctx->vb_q, file, wait);
442 }
443 
444