1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * A virtual stateless decoder device for stateless uAPI development purposes.
4  *
5  * This tool's objective is to help the development and testing of userspace
6  * applications that use the V4L2 stateless API to decode media.
7  *
8  * A userspace implementation can use visl to run a decoding loop even when no
9  * hardware is available or when the kernel uAPI for the codec has not been
10  * upstreamed yet. This can reveal bugs at an early stage.
11  *
12  * This driver can also trace the contents of the V4L2 controls submitted to it.
13  * It can also dump the contents of the vb2 buffers through a debugfs
14  * interface. This is in many ways similar to the tracing infrastructure
15  * available for other popular encode/decode APIs out there and can help develop
16  * a userspace application by using another (working) one as a reference.
17  *
18  * Note that no actual decoding of video frames is performed by visl. The V4L2
19  * test pattern generator is used to write various debug information to the
20  * capture buffers instead.
21  *
22  * Copyright (C) 2022 Collabora, Ltd.
23  *
24  * Based on the vim2m driver, that is:
25  *
26  * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd.
27  * Pawel Osciak, <pawel@osciak.com>
28  * Marek Szyprowski, <m.szyprowski@samsung.com>
29  *
30  * Based on the vicodec driver, that is:
31  *
32  * Copyright 2018 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
33  *
34  * Based on the Cedrus VPU driver, that is:
35  *
36  * Copyright (C) 2016 Florent Revest <florent.revest@free-electrons.com>
37  * Copyright (C) 2018 Paul Kocialkowski <paul.kocialkowski@bootlin.com>
38  * Copyright (C) 2018 Bootlin
39  */
40 
41 #include <linux/debugfs.h>
42 #include <linux/module.h>
43 #include <linux/platform_device.h>
44 #include <media/v4l2-ctrls.h>
45 #include <media/v4l2-device.h>
46 #include <media/v4l2-ioctl.h>
47 #include <media/v4l2-mem2mem.h>
48 
49 #include "visl.h"
50 #include "visl-dec.h"
51 #include "visl-debugfs.h"
52 #include "visl-video.h"
53 
54 unsigned int visl_debug;
55 module_param(visl_debug, uint, 0644);
56 MODULE_PARM_DESC(visl_debug, " activates debug info");
57 
58 unsigned int visl_transtime_ms;
59 module_param(visl_transtime_ms, uint, 0644);
60 MODULE_PARM_DESC(visl_transtime_ms, " simulated process time in milliseconds.");
61 
62 /*
63  * dprintk can be slow through serial. This lets one limit the tracing to a
64  * particular number of frames
65  */
66 int visl_dprintk_frame_start = -1;
67 module_param(visl_dprintk_frame_start, int, 0);
68 MODULE_PARM_DESC(visl_dprintk_frame_start,
69 		 " a frame number to start tracing with dprintk");
70 
71 unsigned int visl_dprintk_nframes;
72 module_param(visl_dprintk_nframes, uint, 0);
73 MODULE_PARM_DESC(visl_dprintk_nframes,
74 		 " the number of frames to trace with dprintk");
75 
76 bool keep_bitstream_buffers;
77 module_param(keep_bitstream_buffers, bool, false);
78 MODULE_PARM_DESC(keep_bitstream_buffers,
79 		 " keep bitstream buffers in debugfs after streaming is stopped");
80 
81 int bitstream_trace_frame_start = -1;
82 module_param(bitstream_trace_frame_start, int, 0);
83 MODULE_PARM_DESC(bitstream_trace_frame_start,
84 		 " a frame number to start dumping the bitstream through debugfs");
85 
86 unsigned int bitstream_trace_nframes;
87 module_param(bitstream_trace_nframes, uint, 0);
88 MODULE_PARM_DESC(bitstream_trace_nframes,
89 		 " the number of frames to dump the bitstream through debugfs");
90 
91 static const struct visl_ctrl_desc visl_fwht_ctrl_descs[] = {
92 	{
93 		.cfg.id = V4L2_CID_STATELESS_FWHT_PARAMS,
94 	},
95 };
96 
97 const struct visl_ctrls visl_fwht_ctrls = {
98 	.ctrls = visl_fwht_ctrl_descs,
99 	.num_ctrls = ARRAY_SIZE(visl_fwht_ctrl_descs)
100 };
101 
102 static const struct visl_ctrl_desc visl_mpeg2_ctrl_descs[] = {
103 	{
104 		.cfg.id = V4L2_CID_STATELESS_MPEG2_SEQUENCE,
105 	},
106 	{
107 		.cfg.id = V4L2_CID_STATELESS_MPEG2_PICTURE,
108 	},
109 	{
110 		.cfg.id = V4L2_CID_STATELESS_MPEG2_QUANTISATION,
111 	},
112 };
113 
114 const struct visl_ctrls visl_mpeg2_ctrls = {
115 	.ctrls = visl_mpeg2_ctrl_descs,
116 	.num_ctrls = ARRAY_SIZE(visl_mpeg2_ctrl_descs),
117 };
118 
119 static const struct visl_ctrl_desc visl_vp8_ctrl_descs[] = {
120 	{
121 		.cfg.id = V4L2_CID_STATELESS_VP8_FRAME,
122 	},
123 };
124 
125 const struct visl_ctrls visl_vp8_ctrls = {
126 	.ctrls = visl_vp8_ctrl_descs,
127 	.num_ctrls = ARRAY_SIZE(visl_vp8_ctrl_descs),
128 };
129 
130 static const struct visl_ctrl_desc visl_vp9_ctrl_descs[] = {
131 	{
132 		.cfg.id = V4L2_CID_STATELESS_VP9_FRAME,
133 	},
134 	{
135 		.cfg.id = V4L2_CID_STATELESS_VP9_COMPRESSED_HDR,
136 	},
137 };
138 
139 const struct visl_ctrls visl_vp9_ctrls = {
140 	.ctrls = visl_vp9_ctrl_descs,
141 	.num_ctrls = ARRAY_SIZE(visl_vp9_ctrl_descs),
142 };
143 
144 static const struct visl_ctrl_desc visl_h264_ctrl_descs[] = {
145 	{
146 		.cfg.id = V4L2_CID_STATELESS_H264_DECODE_PARAMS,
147 	},
148 	{
149 		.cfg.id = V4L2_CID_STATELESS_H264_SPS,
150 	},
151 	{
152 		.cfg.id = V4L2_CID_STATELESS_H264_PPS,
153 	},
154 	{
155 		.cfg.id = V4L2_CID_STATELESS_H264_SCALING_MATRIX,
156 	},
157 	{
158 		.cfg.id = V4L2_CID_STATELESS_H264_DECODE_MODE,
159 	},
160 	{
161 		.cfg.id = V4L2_CID_STATELESS_H264_START_CODE,
162 	},
163 	{
164 		.cfg.id = V4L2_CID_STATELESS_H264_SLICE_PARAMS,
165 	},
166 	{
167 		.cfg.id = V4L2_CID_STATELESS_H264_PRED_WEIGHTS,
168 	},
169 };
170 
171 const struct visl_ctrls visl_h264_ctrls = {
172 	.ctrls = visl_h264_ctrl_descs,
173 	.num_ctrls = ARRAY_SIZE(visl_h264_ctrl_descs),
174 };
175 
176 static const struct visl_ctrl_desc visl_hevc_ctrl_descs[] = {
177 	{
178 		.cfg.id = V4L2_CID_STATELESS_HEVC_SPS,
179 	},
180 	{
181 		.cfg.id = V4L2_CID_STATELESS_HEVC_PPS,
182 	},
183 	{
184 		.cfg.id = V4L2_CID_STATELESS_HEVC_SLICE_PARAMS,
185 		/* The absolute maximum for level > 6 */
186 		.cfg.dims = { 600 },
187 	},
188 	{
189 		.cfg.id = V4L2_CID_STATELESS_HEVC_SCALING_MATRIX,
190 	},
191 	{
192 		.cfg.id = V4L2_CID_STATELESS_HEVC_DECODE_PARAMS,
193 	},
194 	{
195 		.cfg.id = V4L2_CID_STATELESS_HEVC_DECODE_MODE,
196 	},
197 	{
198 		.cfg.id = V4L2_CID_STATELESS_HEVC_START_CODE,
199 	},
200 	{
201 		.cfg.id = V4L2_CID_STATELESS_HEVC_ENTRY_POINT_OFFSETS,
202 		.cfg.dims = { 256 },
203 		.cfg.max = 0xffffffff,
204 		.cfg.step = 1,
205 	},
206 
207 };
208 
209 const struct visl_ctrls visl_hevc_ctrls = {
210 	.ctrls = visl_hevc_ctrl_descs,
211 	.num_ctrls = ARRAY_SIZE(visl_hevc_ctrl_descs),
212 };
213 
214 struct v4l2_ctrl *visl_find_control(struct visl_ctx *ctx, u32 id)
215 {
216 	struct v4l2_ctrl_handler *hdl = &ctx->hdl;
217 
218 	return v4l2_ctrl_find(hdl, id);
219 }
220 
221 void *visl_find_control_data(struct visl_ctx *ctx, u32 id)
222 {
223 	struct v4l2_ctrl *ctrl;
224 
225 	ctrl = visl_find_control(ctx, id);
226 	if (ctrl)
227 		return ctrl->p_cur.p;
228 
229 	return NULL;
230 }
231 
232 u32 visl_control_num_elems(struct visl_ctx *ctx, u32 id)
233 {
234 	struct v4l2_ctrl *ctrl;
235 
236 	ctrl = visl_find_control(ctx, id);
237 	if (ctrl)
238 		return ctrl->elems;
239 
240 	return 0;
241 }
242 
243 static void visl_device_release(struct video_device *vdev)
244 {
245 	struct visl_dev *dev = container_of(vdev, struct visl_dev, vfd);
246 
247 	v4l2_device_unregister(&dev->v4l2_dev);
248 	v4l2_m2m_release(dev->m2m_dev);
249 	media_device_cleanup(&dev->mdev);
250 	visl_debugfs_deinit(dev);
251 	kfree(dev);
252 }
253 
254 #define VISL_CONTROLS_COUNT	ARRAY_SIZE(visl_controls)
255 
256 static int visl_init_ctrls(struct visl_ctx *ctx)
257 {
258 	struct visl_dev *dev = ctx->dev;
259 	struct v4l2_ctrl_handler *hdl = &ctx->hdl;
260 	unsigned int ctrl_cnt = 0;
261 	unsigned int i;
262 	unsigned int j;
263 	const struct visl_ctrls *ctrls;
264 
265 	for (i = 0; i < num_coded_fmts; i++)
266 		ctrl_cnt += visl_coded_fmts[i].ctrls->num_ctrls;
267 
268 	v4l2_ctrl_handler_init(hdl, ctrl_cnt);
269 
270 	for (i = 0; i < num_coded_fmts; i++) {
271 		ctrls = visl_coded_fmts[i].ctrls;
272 		for (j = 0; j < ctrls->num_ctrls; j++)
273 			v4l2_ctrl_new_custom(hdl, &ctrls->ctrls[j].cfg, NULL);
274 	}
275 
276 	if (hdl->error) {
277 		v4l2_err(&dev->v4l2_dev,
278 			 "Failed to initialize control handler\n");
279 		v4l2_ctrl_handler_free(hdl);
280 		return hdl->error;
281 	}
282 
283 	ctx->fh.ctrl_handler = hdl;
284 	v4l2_ctrl_handler_setup(hdl);
285 
286 	return 0;
287 }
288 
289 static int visl_open(struct file *file)
290 {
291 	struct visl_dev *dev = video_drvdata(file);
292 	struct visl_ctx *ctx = NULL;
293 	int rc = 0;
294 
295 	if (mutex_lock_interruptible(&dev->dev_mutex))
296 		return -ERESTARTSYS;
297 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
298 	if (!ctx) {
299 		rc = -ENOMEM;
300 		goto unlock;
301 	}
302 
303 	ctx->tpg_str_buf = kzalloc(TPG_STR_BUF_SZ, GFP_KERNEL);
304 
305 	v4l2_fh_init(&ctx->fh, video_devdata(file));
306 	file->private_data = &ctx->fh;
307 	ctx->dev = dev;
308 
309 	rc = visl_init_ctrls(ctx);
310 	if (rc)
311 		goto free_ctx;
312 
313 	ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev, ctx, &visl_queue_init);
314 
315 	mutex_init(&ctx->vb_mutex);
316 
317 	if (IS_ERR(ctx->fh.m2m_ctx)) {
318 		rc = PTR_ERR(ctx->fh.m2m_ctx);
319 		goto free_hdl;
320 	}
321 
322 	rc = visl_set_default_format(ctx);
323 	if (rc)
324 		goto free_m2m_ctx;
325 
326 	v4l2_fh_add(&ctx->fh);
327 
328 	dprintk(dev, "Created instance: %p, m2m_ctx: %p\n",
329 		ctx, ctx->fh.m2m_ctx);
330 
331 	mutex_unlock(&dev->dev_mutex);
332 	return rc;
333 
334 free_m2m_ctx:
335 	v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
336 free_hdl:
337 	v4l2_ctrl_handler_free(&ctx->hdl);
338 	v4l2_fh_exit(&ctx->fh);
339 free_ctx:
340 	kfree(ctx->tpg_str_buf);
341 	kfree(ctx);
342 unlock:
343 	mutex_unlock(&dev->dev_mutex);
344 	return rc;
345 }
346 
347 static int visl_release(struct file *file)
348 {
349 	struct visl_dev *dev = video_drvdata(file);
350 	struct visl_ctx *ctx = visl_file_to_ctx(file);
351 
352 	dprintk(dev, "Releasing instance %p\n", ctx);
353 
354 	tpg_free(&ctx->tpg);
355 	v4l2_fh_del(&ctx->fh);
356 	v4l2_fh_exit(&ctx->fh);
357 	v4l2_ctrl_handler_free(&ctx->hdl);
358 	mutex_lock(&dev->dev_mutex);
359 	v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
360 	mutex_unlock(&dev->dev_mutex);
361 
362 	kfree(ctx->tpg_str_buf);
363 	kfree(ctx);
364 
365 	return 0;
366 }
367 
368 static const struct v4l2_file_operations visl_fops = {
369 	.owner		= THIS_MODULE,
370 	.open		= visl_open,
371 	.release	= visl_release,
372 	.poll		= v4l2_m2m_fop_poll,
373 	.unlocked_ioctl	= video_ioctl2,
374 	.mmap		= v4l2_m2m_fop_mmap,
375 };
376 
377 static const struct video_device visl_videodev = {
378 	.name		= VISL_NAME,
379 	.vfl_dir	= VFL_DIR_M2M,
380 	.fops		= &visl_fops,
381 	.ioctl_ops	= &visl_ioctl_ops,
382 	.minor		= -1,
383 	.release	= visl_device_release,
384 	.device_caps	= V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING,
385 };
386 
387 static const struct v4l2_m2m_ops visl_m2m_ops = {
388 	.device_run	= visl_device_run,
389 };
390 
391 static const struct media_device_ops visl_m2m_media_ops = {
392 	.req_validate	= visl_request_validate,
393 	.req_queue	= v4l2_m2m_request_queue,
394 };
395 
396 static int visl_probe(struct platform_device *pdev)
397 {
398 	struct visl_dev *dev;
399 	struct video_device *vfd;
400 	int ret;
401 	int rc;
402 
403 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
404 	if (!dev)
405 		return -ENOMEM;
406 
407 	ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
408 	if (ret)
409 		goto error_visl_dev;
410 
411 	mutex_init(&dev->dev_mutex);
412 
413 	dev->vfd = visl_videodev;
414 	vfd = &dev->vfd;
415 	vfd->lock = &dev->dev_mutex;
416 	vfd->v4l2_dev = &dev->v4l2_dev;
417 
418 	video_set_drvdata(vfd, dev);
419 
420 	platform_set_drvdata(pdev, dev);
421 
422 	dev->m2m_dev = v4l2_m2m_init(&visl_m2m_ops);
423 	if (IS_ERR(dev->m2m_dev)) {
424 		v4l2_err(&dev->v4l2_dev, "Failed to init mem2mem device\n");
425 		ret = PTR_ERR(dev->m2m_dev);
426 		dev->m2m_dev = NULL;
427 		goto error_dev;
428 	}
429 
430 	dev->mdev.dev = &pdev->dev;
431 	strscpy(dev->mdev.model, "visl", sizeof(dev->mdev.model));
432 	strscpy(dev->mdev.bus_info, "platform:visl",
433 		sizeof(dev->mdev.bus_info));
434 	media_device_init(&dev->mdev);
435 	dev->mdev.ops = &visl_m2m_media_ops;
436 	dev->v4l2_dev.mdev = &dev->mdev;
437 
438 	ret = video_register_device(vfd, VFL_TYPE_VIDEO, -1);
439 	if (ret) {
440 		v4l2_err(&dev->v4l2_dev, "Failed to register video device\n");
441 		goto error_m2m;
442 	}
443 
444 	v4l2_info(&dev->v4l2_dev,
445 		  "Device registered as /dev/video%d\n", vfd->num);
446 
447 	ret = v4l2_m2m_register_media_controller(dev->m2m_dev, vfd,
448 						 MEDIA_ENT_F_PROC_VIDEO_DECODER);
449 	if (ret) {
450 		v4l2_err(&dev->v4l2_dev, "Failed to init mem2mem media controller\n");
451 		goto error_v4l2;
452 	}
453 
454 	ret = media_device_register(&dev->mdev);
455 	if (ret) {
456 		v4l2_err(&dev->v4l2_dev, "Failed to register mem2mem media device\n");
457 		goto error_m2m_mc;
458 	}
459 
460 	rc = visl_debugfs_init(dev);
461 	if (rc)
462 		dprintk(dev, "visl_debugfs_init failed: %d\n"
463 			"Continuing without debugfs support\n", rc);
464 
465 	return 0;
466 
467 error_m2m_mc:
468 	v4l2_m2m_unregister_media_controller(dev->m2m_dev);
469 error_v4l2:
470 	video_unregister_device(&dev->vfd);
471 	/* visl_device_release called by video_unregister_device to release various objects */
472 	return ret;
473 error_m2m:
474 	v4l2_m2m_release(dev->m2m_dev);
475 error_dev:
476 	v4l2_device_unregister(&dev->v4l2_dev);
477 error_visl_dev:
478 	kfree(dev);
479 
480 	return ret;
481 }
482 
483 static void visl_remove(struct platform_device *pdev)
484 {
485 	struct visl_dev *dev = platform_get_drvdata(pdev);
486 
487 	v4l2_info(&dev->v4l2_dev, "Removing " VISL_NAME);
488 
489 #ifdef CONFIG_MEDIA_CONTROLLER
490 	if (media_devnode_is_registered(dev->mdev.devnode)) {
491 		media_device_unregister(&dev->mdev);
492 		v4l2_m2m_unregister_media_controller(dev->m2m_dev);
493 	}
494 #endif
495 	video_unregister_device(&dev->vfd);
496 }
497 
498 static struct platform_driver visl_pdrv = {
499 	.probe		= visl_probe,
500 	.remove_new	= visl_remove,
501 	.driver		= {
502 		.name	= VISL_NAME,
503 	},
504 };
505 
506 static void visl_dev_release(struct device *dev) {}
507 
508 static struct platform_device visl_pdev = {
509 	.name		= VISL_NAME,
510 	.dev.release	= visl_dev_release,
511 };
512 
513 static void __exit visl_exit(void)
514 {
515 	platform_driver_unregister(&visl_pdrv);
516 	platform_device_unregister(&visl_pdev);
517 }
518 
519 static int __init visl_init(void)
520 {
521 	int ret;
522 
523 	ret = platform_device_register(&visl_pdev);
524 	if (ret)
525 		return ret;
526 
527 	ret = platform_driver_register(&visl_pdrv);
528 	if (ret)
529 		platform_device_unregister(&visl_pdev);
530 
531 	return ret;
532 }
533 
534 MODULE_DESCRIPTION("Virtual stateless decoder device");
535 MODULE_AUTHOR("Daniel Almeida <daniel.almeida@collabora.com>");
536 MODULE_LICENSE("GPL");
537 
538 module_init(visl_init);
539 module_exit(visl_exit);
540