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 .cfg.min = V4L2_STATELESS_H264_DECODE_MODE_SLICE_BASED,
160 .cfg.max = V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED,
161 .cfg.def = V4L2_STATELESS_H264_DECODE_MODE_SLICE_BASED,
162 },
163 {
164 .cfg.id = V4L2_CID_STATELESS_H264_START_CODE,
165 .cfg.min = V4L2_STATELESS_H264_START_CODE_NONE,
166 .cfg.max = V4L2_STATELESS_H264_START_CODE_ANNEX_B,
167 .cfg.def = V4L2_STATELESS_H264_START_CODE_NONE,
168 },
169 {
170 .cfg.id = V4L2_CID_STATELESS_H264_SLICE_PARAMS,
171 },
172 {
173 .cfg.id = V4L2_CID_STATELESS_H264_PRED_WEIGHTS,
174 },
175 };
176
177 const struct visl_ctrls visl_h264_ctrls = {
178 .ctrls = visl_h264_ctrl_descs,
179 .num_ctrls = ARRAY_SIZE(visl_h264_ctrl_descs),
180 };
181
182 static const struct visl_ctrl_desc visl_hevc_ctrl_descs[] = {
183 {
184 .cfg.id = V4L2_CID_STATELESS_HEVC_SPS,
185 },
186 {
187 .cfg.id = V4L2_CID_STATELESS_HEVC_PPS,
188 },
189 {
190 .cfg.id = V4L2_CID_STATELESS_HEVC_SLICE_PARAMS,
191 /* The absolute maximum for level > 6 */
192 .cfg.dims = { 600 },
193 },
194 {
195 .cfg.id = V4L2_CID_STATELESS_HEVC_SCALING_MATRIX,
196 },
197 {
198 .cfg.id = V4L2_CID_STATELESS_HEVC_DECODE_PARAMS,
199 },
200 {
201 .cfg.id = V4L2_CID_STATELESS_HEVC_DECODE_MODE,
202 .cfg.min = V4L2_STATELESS_HEVC_DECODE_MODE_SLICE_BASED,
203 .cfg.max = V4L2_STATELESS_HEVC_DECODE_MODE_FRAME_BASED,
204 .cfg.def = V4L2_STATELESS_HEVC_DECODE_MODE_SLICE_BASED,
205 },
206 {
207 .cfg.id = V4L2_CID_STATELESS_HEVC_START_CODE,
208 .cfg.min = V4L2_STATELESS_HEVC_START_CODE_NONE,
209 .cfg.max = V4L2_STATELESS_HEVC_START_CODE_ANNEX_B,
210 .cfg.def = V4L2_STATELESS_HEVC_START_CODE_NONE,
211 },
212 {
213 .cfg.id = V4L2_CID_STATELESS_HEVC_ENTRY_POINT_OFFSETS,
214 .cfg.dims = { 256 },
215 .cfg.max = 0xffffffff,
216 .cfg.step = 1,
217 },
218
219 };
220
221 const struct visl_ctrls visl_hevc_ctrls = {
222 .ctrls = visl_hevc_ctrl_descs,
223 .num_ctrls = ARRAY_SIZE(visl_hevc_ctrl_descs),
224 };
225
visl_find_control(struct visl_ctx * ctx,u32 id)226 struct v4l2_ctrl *visl_find_control(struct visl_ctx *ctx, u32 id)
227 {
228 struct v4l2_ctrl_handler *hdl = &ctx->hdl;
229
230 return v4l2_ctrl_find(hdl, id);
231 }
232
visl_find_control_data(struct visl_ctx * ctx,u32 id)233 void *visl_find_control_data(struct visl_ctx *ctx, u32 id)
234 {
235 struct v4l2_ctrl *ctrl;
236
237 ctrl = visl_find_control(ctx, id);
238 if (ctrl)
239 return ctrl->p_cur.p;
240
241 return NULL;
242 }
243
visl_control_num_elems(struct visl_ctx * ctx,u32 id)244 u32 visl_control_num_elems(struct visl_ctx *ctx, u32 id)
245 {
246 struct v4l2_ctrl *ctrl;
247
248 ctrl = visl_find_control(ctx, id);
249 if (ctrl)
250 return ctrl->elems;
251
252 return 0;
253 }
254
visl_device_release(struct video_device * vdev)255 static void visl_device_release(struct video_device *vdev)
256 {
257 struct visl_dev *dev = container_of(vdev, struct visl_dev, vfd);
258
259 v4l2_device_unregister(&dev->v4l2_dev);
260 v4l2_m2m_release(dev->m2m_dev);
261 media_device_cleanup(&dev->mdev);
262 visl_debugfs_deinit(dev);
263 kfree(dev);
264 }
265
266 #define VISL_CONTROLS_COUNT ARRAY_SIZE(visl_controls)
267
visl_init_ctrls(struct visl_ctx * ctx)268 static int visl_init_ctrls(struct visl_ctx *ctx)
269 {
270 struct visl_dev *dev = ctx->dev;
271 struct v4l2_ctrl_handler *hdl = &ctx->hdl;
272 unsigned int ctrl_cnt = 0;
273 unsigned int i;
274 unsigned int j;
275 const struct visl_ctrls *ctrls;
276
277 for (i = 0; i < num_coded_fmts; i++)
278 ctrl_cnt += visl_coded_fmts[i].ctrls->num_ctrls;
279
280 v4l2_ctrl_handler_init(hdl, ctrl_cnt);
281
282 for (i = 0; i < num_coded_fmts; i++) {
283 ctrls = visl_coded_fmts[i].ctrls;
284 for (j = 0; j < ctrls->num_ctrls; j++)
285 v4l2_ctrl_new_custom(hdl, &ctrls->ctrls[j].cfg, NULL);
286 }
287
288 if (hdl->error) {
289 v4l2_err(&dev->v4l2_dev,
290 "Failed to initialize control handler\n");
291 v4l2_ctrl_handler_free(hdl);
292 return hdl->error;
293 }
294
295 ctx->fh.ctrl_handler = hdl;
296 v4l2_ctrl_handler_setup(hdl);
297
298 return 0;
299 }
300
visl_open(struct file * file)301 static int visl_open(struct file *file)
302 {
303 struct visl_dev *dev = video_drvdata(file);
304 struct visl_ctx *ctx = NULL;
305 int rc = 0;
306
307 if (mutex_lock_interruptible(&dev->dev_mutex))
308 return -ERESTARTSYS;
309 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
310 if (!ctx) {
311 rc = -ENOMEM;
312 goto unlock;
313 }
314
315 ctx->tpg_str_buf = kzalloc(TPG_STR_BUF_SZ, GFP_KERNEL);
316
317 v4l2_fh_init(&ctx->fh, video_devdata(file));
318 file->private_data = &ctx->fh;
319 ctx->dev = dev;
320
321 rc = visl_init_ctrls(ctx);
322 if (rc)
323 goto free_ctx;
324
325 ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev, ctx, &visl_queue_init);
326
327 mutex_init(&ctx->vb_mutex);
328
329 if (IS_ERR(ctx->fh.m2m_ctx)) {
330 rc = PTR_ERR(ctx->fh.m2m_ctx);
331 goto free_hdl;
332 }
333
334 rc = visl_set_default_format(ctx);
335 if (rc)
336 goto free_m2m_ctx;
337
338 v4l2_fh_add(&ctx->fh);
339
340 dprintk(dev, "Created instance: %p, m2m_ctx: %p\n",
341 ctx, ctx->fh.m2m_ctx);
342
343 mutex_unlock(&dev->dev_mutex);
344 return rc;
345
346 free_m2m_ctx:
347 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
348 free_hdl:
349 v4l2_ctrl_handler_free(&ctx->hdl);
350 v4l2_fh_exit(&ctx->fh);
351 free_ctx:
352 kfree(ctx->tpg_str_buf);
353 kfree(ctx);
354 unlock:
355 mutex_unlock(&dev->dev_mutex);
356 return rc;
357 }
358
visl_release(struct file * file)359 static int visl_release(struct file *file)
360 {
361 struct visl_dev *dev = video_drvdata(file);
362 struct visl_ctx *ctx = visl_file_to_ctx(file);
363
364 dprintk(dev, "Releasing instance %p\n", ctx);
365
366 tpg_free(&ctx->tpg);
367 v4l2_fh_del(&ctx->fh);
368 v4l2_fh_exit(&ctx->fh);
369 v4l2_ctrl_handler_free(&ctx->hdl);
370 mutex_lock(&dev->dev_mutex);
371 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
372 mutex_unlock(&dev->dev_mutex);
373
374 kfree(ctx->tpg_str_buf);
375 kfree(ctx);
376
377 return 0;
378 }
379
380 static const struct v4l2_file_operations visl_fops = {
381 .owner = THIS_MODULE,
382 .open = visl_open,
383 .release = visl_release,
384 .poll = v4l2_m2m_fop_poll,
385 .unlocked_ioctl = video_ioctl2,
386 .mmap = v4l2_m2m_fop_mmap,
387 };
388
389 static const struct video_device visl_videodev = {
390 .name = VISL_NAME,
391 .vfl_dir = VFL_DIR_M2M,
392 .fops = &visl_fops,
393 .ioctl_ops = &visl_ioctl_ops,
394 .minor = -1,
395 .release = visl_device_release,
396 .device_caps = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING,
397 };
398
399 static const struct v4l2_m2m_ops visl_m2m_ops = {
400 .device_run = visl_device_run,
401 };
402
403 static const struct media_device_ops visl_m2m_media_ops = {
404 .req_validate = visl_request_validate,
405 .req_queue = v4l2_m2m_request_queue,
406 };
407
visl_probe(struct platform_device * pdev)408 static int visl_probe(struct platform_device *pdev)
409 {
410 struct visl_dev *dev;
411 struct video_device *vfd;
412 int ret;
413 int rc;
414
415 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
416 if (!dev)
417 return -ENOMEM;
418
419 ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
420 if (ret)
421 goto error_visl_dev;
422
423 mutex_init(&dev->dev_mutex);
424
425 dev->vfd = visl_videodev;
426 vfd = &dev->vfd;
427 vfd->lock = &dev->dev_mutex;
428 vfd->v4l2_dev = &dev->v4l2_dev;
429
430 video_set_drvdata(vfd, dev);
431
432 platform_set_drvdata(pdev, dev);
433
434 dev->m2m_dev = v4l2_m2m_init(&visl_m2m_ops);
435 if (IS_ERR(dev->m2m_dev)) {
436 v4l2_err(&dev->v4l2_dev, "Failed to init mem2mem device\n");
437 ret = PTR_ERR(dev->m2m_dev);
438 dev->m2m_dev = NULL;
439 goto error_dev;
440 }
441
442 dev->mdev.dev = &pdev->dev;
443 strscpy(dev->mdev.model, "visl", sizeof(dev->mdev.model));
444 strscpy(dev->mdev.bus_info, "platform:visl",
445 sizeof(dev->mdev.bus_info));
446 media_device_init(&dev->mdev);
447 dev->mdev.ops = &visl_m2m_media_ops;
448 dev->v4l2_dev.mdev = &dev->mdev;
449
450 ret = video_register_device(vfd, VFL_TYPE_VIDEO, -1);
451 if (ret) {
452 v4l2_err(&dev->v4l2_dev, "Failed to register video device\n");
453 goto error_m2m;
454 }
455
456 v4l2_info(&dev->v4l2_dev,
457 "Device registered as /dev/video%d\n", vfd->num);
458
459 ret = v4l2_m2m_register_media_controller(dev->m2m_dev, vfd,
460 MEDIA_ENT_F_PROC_VIDEO_DECODER);
461 if (ret) {
462 v4l2_err(&dev->v4l2_dev, "Failed to init mem2mem media controller\n");
463 goto error_v4l2;
464 }
465
466 ret = media_device_register(&dev->mdev);
467 if (ret) {
468 v4l2_err(&dev->v4l2_dev, "Failed to register mem2mem media device\n");
469 goto error_m2m_mc;
470 }
471
472 rc = visl_debugfs_init(dev);
473 if (rc)
474 dprintk(dev, "visl_debugfs_init failed: %d\n"
475 "Continuing without debugfs support\n", rc);
476
477 return 0;
478
479 error_m2m_mc:
480 v4l2_m2m_unregister_media_controller(dev->m2m_dev);
481 error_v4l2:
482 video_unregister_device(&dev->vfd);
483 /* visl_device_release called by video_unregister_device to release various objects */
484 return ret;
485 error_m2m:
486 v4l2_m2m_release(dev->m2m_dev);
487 error_dev:
488 v4l2_device_unregister(&dev->v4l2_dev);
489 error_visl_dev:
490 kfree(dev);
491
492 return ret;
493 }
494
visl_remove(struct platform_device * pdev)495 static void visl_remove(struct platform_device *pdev)
496 {
497 struct visl_dev *dev = platform_get_drvdata(pdev);
498
499 v4l2_info(&dev->v4l2_dev, "Removing " VISL_NAME);
500
501 #ifdef CONFIG_MEDIA_CONTROLLER
502 if (media_devnode_is_registered(dev->mdev.devnode)) {
503 media_device_unregister(&dev->mdev);
504 v4l2_m2m_unregister_media_controller(dev->m2m_dev);
505 }
506 #endif
507 video_unregister_device(&dev->vfd);
508 }
509
510 static struct platform_driver visl_pdrv = {
511 .probe = visl_probe,
512 .remove_new = visl_remove,
513 .driver = {
514 .name = VISL_NAME,
515 },
516 };
517
visl_dev_release(struct device * dev)518 static void visl_dev_release(struct device *dev) {}
519
520 static struct platform_device visl_pdev = {
521 .name = VISL_NAME,
522 .dev.release = visl_dev_release,
523 };
524
visl_exit(void)525 static void __exit visl_exit(void)
526 {
527 platform_driver_unregister(&visl_pdrv);
528 platform_device_unregister(&visl_pdev);
529 }
530
visl_init(void)531 static int __init visl_init(void)
532 {
533 int ret;
534
535 ret = platform_device_register(&visl_pdev);
536 if (ret)
537 return ret;
538
539 ret = platform_driver_register(&visl_pdrv);
540 if (ret)
541 platform_device_unregister(&visl_pdev);
542
543 return ret;
544 }
545
546 MODULE_DESCRIPTION("Virtual stateless decoder device");
547 MODULE_AUTHOR("Daniel Almeida <daniel.almeida@collabora.com>");
548 MODULE_LICENSE("GPL");
549
550 module_init(visl_init);
551 module_exit(visl_exit);
552