| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * A virtual stateless decoder device for stateless uAPI development purposes. | |
| * | |
| * This tool's objective is to help the development and testing of userspace | |
| * applications that use the V4L2 stateless API to decode media. | |
| * | |
| * A userspace implementation can use visl to run a decoding loop even when no | |
| * hardware is available or when the kernel uAPI for the codec has not been | |
| * upstreamed yet. This can reveal bugs at an early stage. | |
| * | |
| * This driver can also trace the contents of the V4L2 controls submitted to it. | |
| * It can also dump the contents of the vb2 buffers through a debugfs | |
| * interface. This is in many ways similar to the tracing infrastructure | |
| * available for other popular encode/decode APIs out there and can help develop | |
| * a userspace application by using another (working) one as a reference. | |
| * | |
| * Note that no actual decoding of video frames is performed by visl. The V4L2 | |
| * test pattern generator is used to write various debug information to the | |
| * capture buffers instead. | |
| * | |
| * Copyright (C) 2022 Collabora, Ltd. | |
| * | |
| * Based on the vim2m driver, that is: | |
| * | |
| * Copyright (c) 2009-2010 Samsung Electronics Co., Ltd. | |
| * Pawel Osciak, <pawel@osciak.com> | |
| * Marek Szyprowski, <m.szyprowski@samsung.com> | |
| * | |
| * Based on the vicodec driver, that is: | |
| * | |
| * Copyright 2018 Cisco Systems, Inc. and/or its affiliates. All rights reserved. | |
| * | |
| * Based on the Cedrus VPU driver, that is: | |
| * | |
| * Copyright (C) 2016 Florent Revest <florent.revest@free-electrons.com> | |
| * Copyright (C) 2018 Paul Kocialkowski <paul.kocialkowski@bootlin.com> | |
| * Copyright (C) 2018 Bootlin | |
| */ | |
| #include <linux/debugfs.h> | |
| #include <linux/module.h> | |
| #include <linux/platform_device.h> | |
| #include <media/v4l2-ctrls.h> | |
| #include <media/v4l2-device.h> | |
| #include <media/v4l2-ioctl.h> | |
| #include <media/v4l2-mem2mem.h> | |
| #include "visl.h" | |
| #include "visl-dec.h" | |
| #include "visl-debugfs.h" | |
| #include "visl-video.h" | |
| unsigned int visl_debug; | |
| module_param(visl_debug, uint, 0644); | |
| MODULE_PARM_DESC(visl_debug, " activates debug info"); | |
| unsigned int visl_transtime_ms; | |
| module_param(visl_transtime_ms, uint, 0644); | |
| MODULE_PARM_DESC(visl_transtime_ms, " simulated process time in milliseconds."); | |
| /* | |
| * dprintk can be slow through serial. This lets one limit the tracing to a | |
| * particular number of frames | |
| */ | |
| int visl_dprintk_frame_start = -1; | |
| module_param(visl_dprintk_frame_start, int, 0444); | |
| MODULE_PARM_DESC(visl_dprintk_frame_start, | |
| " a frame number to start tracing with dprintk"); | |
| unsigned int visl_dprintk_nframes; | |
| module_param(visl_dprintk_nframes, uint, 0444); | |
| MODULE_PARM_DESC(visl_dprintk_nframes, | |
| " the number of frames to trace with dprintk"); | |
| bool keep_bitstream_buffers; | |
| module_param(keep_bitstream_buffers, bool, 0444); | |
| MODULE_PARM_DESC(keep_bitstream_buffers, | |
| " keep bitstream buffers in debugfs after streaming is stopped"); | |
| int bitstream_trace_frame_start = -1; | |
| module_param(bitstream_trace_frame_start, int, 0444); | |
| MODULE_PARM_DESC(bitstream_trace_frame_start, | |
| " a frame number to start dumping the bitstream through debugfs"); | |
| unsigned int bitstream_trace_nframes; | |
| module_param(bitstream_trace_nframes, uint, 0444); | |
| MODULE_PARM_DESC(bitstream_trace_nframes, | |
| " the number of frames to dump the bitstream through debugfs"); | |
| bool tpg_verbose; | |
| module_param(tpg_verbose, bool, 0644); | |
| MODULE_PARM_DESC(tpg_verbose, | |
| " add more verbose information on the generated output frames"); | |
| static const struct visl_ctrl_desc visl_fwht_ctrl_descs[] = { | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_FWHT_PARAMS, | |
| }, | |
| }; | |
| const struct visl_ctrls visl_fwht_ctrls = { | |
| .ctrls = visl_fwht_ctrl_descs, | |
| .num_ctrls = ARRAY_SIZE(visl_fwht_ctrl_descs) | |
| }; | |
| static const struct visl_ctrl_desc visl_mpeg2_ctrl_descs[] = { | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_MPEG2_SEQUENCE, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_MPEG2_PICTURE, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_MPEG2_QUANTISATION, | |
| }, | |
| }; | |
| const struct visl_ctrls visl_mpeg2_ctrls = { | |
| .ctrls = visl_mpeg2_ctrl_descs, | |
| .num_ctrls = ARRAY_SIZE(visl_mpeg2_ctrl_descs), | |
| }; | |
| static const struct visl_ctrl_desc visl_vp8_ctrl_descs[] = { | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_VP8_FRAME, | |
| }, | |
| }; | |
| const struct visl_ctrls visl_vp8_ctrls = { | |
| .ctrls = visl_vp8_ctrl_descs, | |
| .num_ctrls = ARRAY_SIZE(visl_vp8_ctrl_descs), | |
| }; | |
| static const struct visl_ctrl_desc visl_vp9_ctrl_descs[] = { | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_VP9_FRAME, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_VP9_COMPRESSED_HDR, | |
| }, | |
| }; | |
| const struct visl_ctrls visl_vp9_ctrls = { | |
| .ctrls = visl_vp9_ctrl_descs, | |
| .num_ctrls = ARRAY_SIZE(visl_vp9_ctrl_descs), | |
| }; | |
| static const struct visl_ctrl_desc visl_h264_ctrl_descs[] = { | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_H264_DECODE_PARAMS, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_H264_SPS, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_H264_PPS, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_H264_SCALING_MATRIX, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_H264_DECODE_MODE, | |
| .cfg.min = V4L2_STATELESS_H264_DECODE_MODE_SLICE_BASED, | |
| .cfg.max = V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED, | |
| .cfg.def = V4L2_STATELESS_H264_DECODE_MODE_SLICE_BASED, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_H264_START_CODE, | |
| .cfg.min = V4L2_STATELESS_H264_START_CODE_NONE, | |
| .cfg.max = V4L2_STATELESS_H264_START_CODE_ANNEX_B, | |
| .cfg.def = V4L2_STATELESS_H264_START_CODE_NONE, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_H264_SLICE_PARAMS, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_H264_PRED_WEIGHTS, | |
| }, | |
| }; | |
| const struct visl_ctrls visl_h264_ctrls = { | |
| .ctrls = visl_h264_ctrl_descs, | |
| .num_ctrls = ARRAY_SIZE(visl_h264_ctrl_descs), | |
| }; | |
| static const struct visl_ctrl_desc visl_hevc_ctrl_descs[] = { | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_HEVC_SPS, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_HEVC_PPS, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_HEVC_SLICE_PARAMS, | |
| /* The absolute maximum for level > 6 */ | |
| .cfg.dims = { 600 }, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_HEVC_SCALING_MATRIX, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_HEVC_DECODE_PARAMS, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_HEVC_DECODE_MODE, | |
| .cfg.min = V4L2_STATELESS_HEVC_DECODE_MODE_SLICE_BASED, | |
| .cfg.max = V4L2_STATELESS_HEVC_DECODE_MODE_FRAME_BASED, | |
| .cfg.def = V4L2_STATELESS_HEVC_DECODE_MODE_SLICE_BASED, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_HEVC_START_CODE, | |
| .cfg.min = V4L2_STATELESS_HEVC_START_CODE_NONE, | |
| .cfg.max = V4L2_STATELESS_HEVC_START_CODE_ANNEX_B, | |
| .cfg.def = V4L2_STATELESS_HEVC_START_CODE_NONE, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_HEVC_ENTRY_POINT_OFFSETS, | |
| .cfg.dims = { 256 }, | |
| .cfg.max = 0xffffffff, | |
| .cfg.step = 1, | |
| }, | |
| }; | |
| const struct visl_ctrls visl_hevc_ctrls = { | |
| .ctrls = visl_hevc_ctrl_descs, | |
| .num_ctrls = ARRAY_SIZE(visl_hevc_ctrl_descs), | |
| }; | |
| static const struct visl_ctrl_desc visl_av1_ctrl_descs[] = { | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_AV1_FRAME, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY, | |
| .cfg.dims = { V4L2_AV1_MAX_TILE_COUNT }, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_AV1_SEQUENCE, | |
| }, | |
| { | |
| .cfg.id = V4L2_CID_STATELESS_AV1_FILM_GRAIN, | |
| }, | |
| }; | |
| const struct visl_ctrls visl_av1_ctrls = { | |
| .ctrls = visl_av1_ctrl_descs, | |
| .num_ctrls = ARRAY_SIZE(visl_av1_ctrl_descs), | |
| }; | |
| struct v4l2_ctrl *visl_find_control(struct visl_ctx *ctx, u32 id) | |
| { | |
| struct v4l2_ctrl_handler *hdl = &ctx->hdl; | |
| return v4l2_ctrl_find(hdl, id); | |
| } | |
| void *visl_find_control_data(struct visl_ctx *ctx, u32 id) | |
| { | |
| struct v4l2_ctrl *ctrl; | |
| ctrl = visl_find_control(ctx, id); | |
| if (ctrl) | |
| return ctrl->p_cur.p; | |
| return NULL; | |
| } | |
| u32 visl_control_num_elems(struct visl_ctx *ctx, u32 id) | |
| { | |
| struct v4l2_ctrl *ctrl; | |
| ctrl = visl_find_control(ctx, id); | |
| if (ctrl) | |
| return ctrl->elems; | |
| return 0; | |
| } | |
| static void visl_device_release(struct video_device *vdev) | |
| { | |
| struct visl_dev *dev = container_of(vdev, struct visl_dev, vfd); | |
| v4l2_device_unregister(&dev->v4l2_dev); | |
| v4l2_m2m_release(dev->m2m_dev); | |
| media_device_cleanup(&dev->mdev); | |
| visl_debugfs_deinit(dev); | |
| kfree(dev); | |
| } | |
| #define VISL_CONTROLS_COUNT ARRAY_SIZE(visl_controls) | |
| static int visl_init_ctrls(struct visl_ctx *ctx) | |
| { | |
| struct visl_dev *dev = ctx->dev; | |
| struct v4l2_ctrl_handler *hdl = &ctx->hdl; | |
| unsigned int ctrl_cnt = 0; | |
| unsigned int i; | |
| unsigned int j; | |
| const struct visl_ctrls *ctrls; | |
| for (i = 0; i < num_coded_fmts; i++) | |
| ctrl_cnt += visl_coded_fmts[i].ctrls->num_ctrls; | |
| v4l2_ctrl_handler_init(hdl, ctrl_cnt); | |
| for (i = 0; i < num_coded_fmts; i++) { | |
| ctrls = visl_coded_fmts[i].ctrls; | |
| for (j = 0; j < ctrls->num_ctrls; j++) | |
| v4l2_ctrl_new_custom(hdl, &ctrls->ctrls[j].cfg, NULL); | |
| } | |
| if (hdl->error) { | |
| v4l2_err(&dev->v4l2_dev, | |
| "Failed to initialize control handler\n"); | |
| v4l2_ctrl_handler_free(hdl); | |
| return hdl->error; | |
| } | |
| ctx->fh.ctrl_handler = hdl; | |
| v4l2_ctrl_handler_setup(hdl); | |
| return 0; | |
| } | |
| static int visl_open(struct file *file) | |
| { | |
| struct visl_dev *dev = video_drvdata(file); | |
| struct visl_ctx *ctx = NULL; | |
| int rc = 0; | |
| if (mutex_lock_interruptible(&dev->dev_mutex)) | |
| return -ERESTARTSYS; | |
| ctx = kzalloc_obj(*ctx); | |
| if (!ctx) { | |
| rc = -ENOMEM; | |
| goto unlock; | |
| } | |
| ctx->tpg_str_buf = kzalloc(TPG_STR_BUF_SZ, GFP_KERNEL); | |
| if (!ctx->tpg_str_buf) { | |
| rc = -ENOMEM; | |
| goto free_ctx; | |
| } | |
| v4l2_fh_init(&ctx->fh, video_devdata(file)); | |
| ctx->dev = dev; | |
| rc = visl_init_ctrls(ctx); | |
| if (rc) | |
| goto free_ctx; | |
| ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev, ctx, &visl_queue_init); | |
| mutex_init(&ctx->vb_mutex); | |
| if (IS_ERR(ctx->fh.m2m_ctx)) { | |
| rc = PTR_ERR(ctx->fh.m2m_ctx); | |
| goto free_hdl; | |
| } | |
| rc = visl_set_default_format(ctx); | |
| if (rc) | |
| goto free_m2m_ctx; | |
| v4l2_fh_add(&ctx->fh, file); | |
| dprintk(dev, "Created instance: %p, m2m_ctx: %p\n", | |
| ctx, ctx->fh.m2m_ctx); | |
| mutex_unlock(&dev->dev_mutex); | |
| return rc; | |
| free_m2m_ctx: | |
| v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); | |
| free_hdl: | |
| v4l2_ctrl_handler_free(&ctx->hdl); | |
| v4l2_fh_exit(&ctx->fh); | |
| free_ctx: | |
| kfree(ctx->tpg_str_buf); | |
| kfree(ctx); | |
| unlock: | |
| mutex_unlock(&dev->dev_mutex); | |
| return rc; | |
| } | |
| static int visl_release(struct file *file) | |
| { | |
| struct visl_dev *dev = video_drvdata(file); | |
| struct visl_ctx *ctx = visl_file_to_ctx(file); | |
| dprintk(dev, "Releasing instance %p\n", ctx); | |
| tpg_free(&ctx->tpg); | |
| v4l2_fh_del(&ctx->fh, file); | |
| v4l2_fh_exit(&ctx->fh); | |
| v4l2_ctrl_handler_free(&ctx->hdl); | |
| mutex_lock(&dev->dev_mutex); | |
| v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); | |
| mutex_unlock(&dev->dev_mutex); | |
| kfree(ctx->tpg_str_buf); | |
| kfree(ctx); | |
| return 0; | |
| } | |
| static const struct v4l2_file_operations visl_fops = { | |
| .owner = THIS_MODULE, | |
| .open = visl_open, | |
| .release = visl_release, | |
| .poll = v4l2_m2m_fop_poll, | |
| .unlocked_ioctl = video_ioctl2, | |
| .mmap = v4l2_m2m_fop_mmap, | |
| }; | |
| static const struct video_device visl_videodev = { | |
| .name = VISL_NAME, | |
| .vfl_dir = VFL_DIR_M2M, | |
| .fops = &visl_fops, | |
| .ioctl_ops = &visl_ioctl_ops, | |
| .minor = -1, | |
| .release = visl_device_release, | |
| .device_caps = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING, | |
| }; | |
| static const struct v4l2_m2m_ops visl_m2m_ops = { | |
| .device_run = visl_device_run, | |
| }; | |
| static const struct media_device_ops visl_m2m_media_ops = { | |
| .req_validate = visl_request_validate, | |
| .req_queue = v4l2_m2m_request_queue, | |
| }; | |
| static int visl_probe(struct platform_device *pdev) | |
| { | |
| struct visl_dev *dev; | |
| struct video_device *vfd; | |
| int ret; | |
| int rc; | |
| dev = kzalloc_obj(*dev); | |
| if (!dev) | |
| return -ENOMEM; | |
| ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev); | |
| if (ret) | |
| goto error_visl_dev; | |
| mutex_init(&dev->dev_mutex); | |
| dev->vfd = visl_videodev; | |
| vfd = &dev->vfd; | |
| vfd->lock = &dev->dev_mutex; | |
| vfd->v4l2_dev = &dev->v4l2_dev; | |
| video_set_drvdata(vfd, dev); | |
| platform_set_drvdata(pdev, dev); | |
| dev->m2m_dev = v4l2_m2m_init(&visl_m2m_ops); | |
| if (IS_ERR(dev->m2m_dev)) { | |
| v4l2_err(&dev->v4l2_dev, "Failed to init mem2mem device\n"); | |
| ret = PTR_ERR(dev->m2m_dev); | |
| dev->m2m_dev = NULL; | |
| goto error_dev; | |
| } | |
| dev->mdev.dev = &pdev->dev; | |
| strscpy(dev->mdev.model, "visl", sizeof(dev->mdev.model)); | |
| strscpy(dev->mdev.bus_info, "platform:visl", | |
| sizeof(dev->mdev.bus_info)); | |
| media_device_init(&dev->mdev); | |
| dev->mdev.ops = &visl_m2m_media_ops; | |
| dev->v4l2_dev.mdev = &dev->mdev; | |
| ret = video_register_device(vfd, VFL_TYPE_VIDEO, -1); | |
| if (ret) { | |
| v4l2_err(&dev->v4l2_dev, "Failed to register video device\n"); | |
| goto error_m2m; | |
| } | |
| v4l2_info(&dev->v4l2_dev, | |
| "Device registered as /dev/video%d\n", vfd->num); | |
| ret = v4l2_m2m_register_media_controller(dev->m2m_dev, vfd, | |
| MEDIA_ENT_F_PROC_VIDEO_DECODER); | |
| if (ret) { | |
| v4l2_err(&dev->v4l2_dev, "Failed to init mem2mem media controller\n"); | |
| goto error_v4l2; | |
| } | |
| ret = media_device_register(&dev->mdev); | |
| if (ret) { | |
| v4l2_err(&dev->v4l2_dev, "Failed to register mem2mem media device\n"); | |
| goto error_m2m_mc; | |
| } | |
| rc = visl_debugfs_init(dev); | |
| if (rc) | |
| dprintk(dev, "visl_debugfs_init failed: %d\n" | |
| "Continuing without debugfs support\n", rc); | |
| return 0; | |
| error_m2m_mc: | |
| v4l2_m2m_unregister_media_controller(dev->m2m_dev); | |
| error_v4l2: | |
| video_unregister_device(&dev->vfd); | |
| /* visl_device_release called by video_unregister_device to release various objects */ | |
| return ret; | |
| error_m2m: | |
| v4l2_m2m_release(dev->m2m_dev); | |
| error_dev: | |
| v4l2_device_unregister(&dev->v4l2_dev); | |
| error_visl_dev: | |
| kfree(dev); | |
| return ret; | |
| } | |
| static void visl_remove(struct platform_device *pdev) | |
| { | |
| struct visl_dev *dev = platform_get_drvdata(pdev); | |
| v4l2_info(&dev->v4l2_dev, "Removing " VISL_NAME); | |
| #ifdef CONFIG_MEDIA_CONTROLLER | |
| if (media_devnode_is_registered(dev->mdev.devnode)) { | |
| media_device_unregister(&dev->mdev); | |
| v4l2_m2m_unregister_media_controller(dev->m2m_dev); | |
| } | |
| #endif | |
| video_unregister_device(&dev->vfd); | |
| } | |
| static struct platform_driver visl_pdrv = { | |
| .probe = visl_probe, | |
| .remove = visl_remove, | |
| .driver = { | |
| .name = VISL_NAME, | |
| }, | |
| }; | |
| static void visl_dev_release(struct device *dev) {} | |
| static struct platform_device visl_pdev = { | |
| .name = VISL_NAME, | |
| .dev.release = visl_dev_release, | |
| }; | |
| static void __exit visl_exit(void) | |
| { | |
| platform_driver_unregister(&visl_pdrv); | |
| platform_device_unregister(&visl_pdev); | |
| } | |
| static int __init visl_init(void) | |
| { | |
| int ret; | |
| ret = platform_device_register(&visl_pdev); | |
| if (ret) | |
| return ret; | |
| ret = platform_driver_register(&visl_pdrv); | |
| if (ret) | |
| platform_device_unregister(&visl_pdev); | |
| return ret; | |
| } | |
| MODULE_DESCRIPTION("Virtual stateless decoder device"); | |
| MODULE_AUTHOR("Daniel Almeida <daniel.almeida@collabora.com>"); | |
| MODULE_LICENSE("GPL"); | |
| module_init(visl_init); | |
| module_exit(visl_exit); |