leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
69fbb3f473
linux/drivers/media/platform/vimc/vimc-common.c
Helen Fornazier b6c61a6c37 media: vimc: propagate pixel format in the stream 
Media bus codes were being mapped to pixelformats, which causes a
limitation on vimc because not all pixelformats can be mapped to media
bus codes.
Also, media bus codes are an internal configuration from the device.
Userspace only assures media bus codes matches between pads and expects
the image in a given pixelformat. So we can allow almost any media bus
format to be configured between pads, except for debayer that expects a
media bus code of type bayer in the sink pad.

[hverkuil-cisco@xs4all.nl: drop use of v4l2_get_fourcc_name: not yet available]
[hverkuil-cisco@xs4all.nl: made vimc_mbus_list static]

Signed-off-by: Helen Koike <helen.koike@collabora.com>
Signed-off-by: Hans Verkuil <hverkuil-cisco@xs4all.nl>
Signed-off-by: Mauro Carvalho Chehab <mchehab+samsung@kernel.org>
2019-04-22 10:58:51 -04:00

394 lines
11 KiB
C
Raw Blame History

/*
* vimc-common.c Virtual Media Controller Driver
*
* Copyright (C) 2015-2017 Helen Koike <helen.fornazier@gmail.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#include <linux/init.h>
#include <linux/module.h>
#include "vimc-common.h"
static const __u32 vimc_mbus_list[] = {
MEDIA_BUS_FMT_FIXED,
MEDIA_BUS_FMT_RGB444_1X12,
MEDIA_BUS_FMT_RGB444_2X8_PADHI_BE,
MEDIA_BUS_FMT_RGB444_2X8_PADHI_LE,
MEDIA_BUS_FMT_RGB555_2X8_PADHI_BE,
MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE,
MEDIA_BUS_FMT_RGB565_1X16,
MEDIA_BUS_FMT_BGR565_2X8_BE,
MEDIA_BUS_FMT_BGR565_2X8_LE,
MEDIA_BUS_FMT_RGB565_2X8_BE,
MEDIA_BUS_FMT_RGB565_2X8_LE,
MEDIA_BUS_FMT_RGB666_1X18,
MEDIA_BUS_FMT_RBG888_1X24,
MEDIA_BUS_FMT_RGB666_1X24_CPADHI,
MEDIA_BUS_FMT_RGB666_1X7X3_SPWG,
MEDIA_BUS_FMT_BGR888_1X24,
MEDIA_BUS_FMT_GBR888_1X24,
MEDIA_BUS_FMT_RGB888_1X24,
MEDIA_BUS_FMT_RGB888_2X12_BE,
MEDIA_BUS_FMT_RGB888_2X12_LE,
MEDIA_BUS_FMT_RGB888_1X7X4_SPWG,
MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA,
MEDIA_BUS_FMT_ARGB8888_1X32,
MEDIA_BUS_FMT_RGB888_1X32_PADHI,
MEDIA_BUS_FMT_RGB101010_1X30,
MEDIA_BUS_FMT_RGB121212_1X36,
MEDIA_BUS_FMT_RGB161616_1X48,
MEDIA_BUS_FMT_Y8_1X8,
MEDIA_BUS_FMT_UV8_1X8,
MEDIA_BUS_FMT_UYVY8_1_5X8,
MEDIA_BUS_FMT_VYUY8_1_5X8,
MEDIA_BUS_FMT_YUYV8_1_5X8,
MEDIA_BUS_FMT_YVYU8_1_5X8,
MEDIA_BUS_FMT_UYVY8_2X8,
MEDIA_BUS_FMT_VYUY8_2X8,
MEDIA_BUS_FMT_YUYV8_2X8,
MEDIA_BUS_FMT_YVYU8_2X8,
MEDIA_BUS_FMT_Y10_1X10,
MEDIA_BUS_FMT_Y10_2X8_PADHI_LE,
MEDIA_BUS_FMT_UYVY10_2X10,
MEDIA_BUS_FMT_VYUY10_2X10,
MEDIA_BUS_FMT_YUYV10_2X10,
MEDIA_BUS_FMT_YVYU10_2X10,
MEDIA_BUS_FMT_Y12_1X12,
MEDIA_BUS_FMT_UYVY12_2X12,
MEDIA_BUS_FMT_VYUY12_2X12,
MEDIA_BUS_FMT_YUYV12_2X12,
MEDIA_BUS_FMT_YVYU12_2X12,
MEDIA_BUS_FMT_UYVY8_1X16,
MEDIA_BUS_FMT_VYUY8_1X16,
MEDIA_BUS_FMT_YUYV8_1X16,
MEDIA_BUS_FMT_YVYU8_1X16,
MEDIA_BUS_FMT_YDYUYDYV8_1X16,
MEDIA_BUS_FMT_UYVY10_1X20,
MEDIA_BUS_FMT_VYUY10_1X20,
MEDIA_BUS_FMT_YUYV10_1X20,
MEDIA_BUS_FMT_YVYU10_1X20,
MEDIA_BUS_FMT_VUY8_1X24,
MEDIA_BUS_FMT_YUV8_1X24,
MEDIA_BUS_FMT_UYYVYY8_0_5X24,
MEDIA_BUS_FMT_UYVY12_1X24,
MEDIA_BUS_FMT_VYUY12_1X24,
MEDIA_BUS_FMT_YUYV12_1X24,
MEDIA_BUS_FMT_YVYU12_1X24,
MEDIA_BUS_FMT_YUV10_1X30,
MEDIA_BUS_FMT_UYYVYY10_0_5X30,
MEDIA_BUS_FMT_AYUV8_1X32,
MEDIA_BUS_FMT_UYYVYY12_0_5X36,
MEDIA_BUS_FMT_YUV12_1X36,
MEDIA_BUS_FMT_YUV16_1X48,
MEDIA_BUS_FMT_UYYVYY16_0_5X48,
MEDIA_BUS_FMT_SBGGR8_1X8,
MEDIA_BUS_FMT_SGBRG8_1X8,
MEDIA_BUS_FMT_SGRBG8_1X8,
MEDIA_BUS_FMT_SRGGB8_1X8,
MEDIA_BUS_FMT_SBGGR10_ALAW8_1X8,
MEDIA_BUS_FMT_SGBRG10_ALAW8_1X8,
MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8,
MEDIA_BUS_FMT_SRGGB10_ALAW8_1X8,
MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8,
MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8,
MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8,
MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8,
MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_BE,
MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE,
MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_BE,
MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_LE,
MEDIA_BUS_FMT_SBGGR10_1X10,
MEDIA_BUS_FMT_SGBRG10_1X10,
MEDIA_BUS_FMT_SGRBG10_1X10,
MEDIA_BUS_FMT_SRGGB10_1X10,
MEDIA_BUS_FMT_SBGGR12_1X12,
MEDIA_BUS_FMT_SGBRG12_1X12,
MEDIA_BUS_FMT_SGRBG12_1X12,
MEDIA_BUS_FMT_SRGGB12_1X12,
MEDIA_BUS_FMT_SBGGR14_1X14,
MEDIA_BUS_FMT_SGBRG14_1X14,
MEDIA_BUS_FMT_SGRBG14_1X14,
MEDIA_BUS_FMT_SRGGB14_1X14,
MEDIA_BUS_FMT_SBGGR16_1X16,
MEDIA_BUS_FMT_SGBRG16_1X16,
MEDIA_BUS_FMT_SGRBG16_1X16,
MEDIA_BUS_FMT_SRGGB16_1X16,
MEDIA_BUS_FMT_JPEG_1X8,
MEDIA_BUS_FMT_S5C_UYVY_JPEG_1X8,
MEDIA_BUS_FMT_AHSV8888_1X32,
};
/* Helper function to check mbus codes */
bool vimc_mbus_code_supported(__u32 code)
{
unsigned int i;
for (i = 0; i < ARRAY_SIZE(vimc_mbus_list); i++)
if (code == vimc_mbus_list[i])
return true;
return false;
}
EXPORT_SYMBOL_GPL(vimc_mbus_code_supported);
/* Helper function to enumerate mbus codes */
int vimc_enum_mbus_code(struct v4l2_subdev *sd,
struct v4l2_subdev_pad_config *cfg,
struct v4l2_subdev_mbus_code_enum *code)
{
if (code->index >= ARRAY_SIZE(vimc_mbus_list))
return -EINVAL;
code->code = vimc_mbus_list[code->index];
return 0;
}
EXPORT_SYMBOL_GPL(vimc_enum_mbus_code);
/* Helper function to allocate and initialize pads */
struct media_pad *vimc_pads_init(u16 num_pads, const unsigned long *pads_flag)
{
struct media_pad *pads;
unsigned int i;
/* Allocate memory for the pads */
pads = kcalloc(num_pads, sizeof(*pads), GFP_KERNEL);
if (!pads)
return ERR_PTR(-ENOMEM);
/* Initialize the pads */
for (i = 0; i < num_pads; i++) {
pads[i].index = i;
pads[i].flags = pads_flag[i];
}
return pads;
}
EXPORT_SYMBOL_GPL(vimc_pads_init);
int vimc_pipeline_s_stream(struct media_entity *ent, int enable)
{
struct v4l2_subdev *sd;
struct media_pad *pad;
unsigned int i;
int ret;
for (i = 0; i < ent->num_pads; i++) {
if (ent->pads[i].flags & MEDIA_PAD_FL_SOURCE)
continue;
/* Start the stream in the subdevice direct connected */
pad = media_entity_remote_pad(&ent->pads[i]);
if (!pad)
continue;
if (!is_media_entity_v4l2_subdev(pad->entity))
return -EINVAL;
sd = media_entity_to_v4l2_subdev(pad->entity);
ret = v4l2_subdev_call(sd, video, s_stream, enable);
if (ret && ret != -ENOIOCTLCMD)
return ret;
}
return 0;
}
EXPORT_SYMBOL_GPL(vimc_pipeline_s_stream);
static int vimc_get_mbus_format(struct media_pad *pad,
struct v4l2_subdev_format *fmt)
{
if (is_media_entity_v4l2_subdev(pad->entity)) {
struct v4l2_subdev *sd =
media_entity_to_v4l2_subdev(pad->entity);
int ret;
fmt->which = V4L2_SUBDEV_FORMAT_ACTIVE;
fmt->pad = pad->index;
ret = v4l2_subdev_call(sd, pad, get_fmt, NULL, fmt);
if (ret)
return ret;
} else if (is_media_entity_v4l2_video_device(pad->entity)) {
struct video_device *vdev = container_of(pad->entity,
struct video_device,
entity);
struct vimc_ent_device *ved = video_get_drvdata(vdev);
struct v4l2_pix_format vdev_fmt;
if (!ved->vdev_get_format)
return -ENOIOCTLCMD;
ved->vdev_get_format(ved, &vdev_fmt);
v4l2_fill_mbus_format(&fmt->format, &vdev_fmt, 0);
} else {
return -EINVAL;
}
return 0;
}
int vimc_link_validate(struct media_link *link)
{
struct v4l2_subdev_format source_fmt, sink_fmt;
int ret;
ret = vimc_get_mbus_format(link->source, &source_fmt);
if (ret)
return ret;
ret = vimc_get_mbus_format(link->sink, &sink_fmt);
if (ret)
return ret;
pr_info("vimc link validate: "
"%s:src:%dx%d (0x%x, %d, %d, %d, %d) "
"%s:snk:%dx%d (0x%x, %d, %d, %d, %d)\n",
/* src */
link->source->entity->name,
source_fmt.format.width, source_fmt.format.height,
source_fmt.format.code, source_fmt.format.colorspace,
source_fmt.format.quantization, source_fmt.format.xfer_func,
source_fmt.format.ycbcr_enc,
/* sink */
link->sink->entity->name,
sink_fmt.format.width, sink_fmt.format.height,
sink_fmt.format.code, sink_fmt.format.colorspace,
sink_fmt.format.quantization, sink_fmt.format.xfer_func,
sink_fmt.format.ycbcr_enc);
/* The width, height and code must match. */
if (source_fmt.format.width != sink_fmt.format.width
|| source_fmt.format.height != sink_fmt.format.height
|| (source_fmt.format.code && sink_fmt.format.code &&
source_fmt.format.code != sink_fmt.format.code)) {
pr_err("vimc: format doesn't match in link %s->%s\n",
link->source->entity->name, link->sink->entity->name);
return -EPIPE;
}
/*
* The field order must match, or the sink field order must be NONE
* to support interlaced hardware connected to bridges that support
* progressive formats only.
*/
if (source_fmt.format.field != sink_fmt.format.field &&
sink_fmt.format.field != V4L2_FIELD_NONE)
return -EPIPE;
/*
* If colorspace is DEFAULT, then assume all the colorimetry is also
* DEFAULT, return 0 to skip comparing the other colorimetry parameters
*/
if (source_fmt.format.colorspace == V4L2_COLORSPACE_DEFAULT
|| sink_fmt.format.colorspace == V4L2_COLORSPACE_DEFAULT)
return 0;
/* Colorspace must match. */
if (source_fmt.format.colorspace != sink_fmt.format.colorspace)
return -EPIPE;
/* Colorimetry must match if they are not set to DEFAULT */
if (source_fmt.format.ycbcr_enc != V4L2_YCBCR_ENC_DEFAULT
&& sink_fmt.format.ycbcr_enc != V4L2_YCBCR_ENC_DEFAULT
&& source_fmt.format.ycbcr_enc != sink_fmt.format.ycbcr_enc)
return -EPIPE;
if (source_fmt.format.quantization != V4L2_QUANTIZATION_DEFAULT
&& sink_fmt.format.quantization != V4L2_QUANTIZATION_DEFAULT
&& source_fmt.format.quantization != sink_fmt.format.quantization)
return -EPIPE;
if (source_fmt.format.xfer_func != V4L2_XFER_FUNC_DEFAULT
&& sink_fmt.format.xfer_func != V4L2_XFER_FUNC_DEFAULT
&& source_fmt.format.xfer_func != sink_fmt.format.xfer_func)
return -EPIPE;
return 0;
}
EXPORT_SYMBOL_GPL(vimc_link_validate);
static const struct media_entity_operations vimc_ent_sd_mops = {
.link_validate = vimc_link_validate,
};
int vimc_ent_sd_register(struct vimc_ent_device *ved,
struct v4l2_subdev *sd,
struct v4l2_device *v4l2_dev,
const char *const name,
u32 function,
u16 num_pads,
const unsigned long *pads_flag,
const struct v4l2_subdev_internal_ops *sd_int_ops,
const struct v4l2_subdev_ops *sd_ops)
{
int ret;
/* Allocate the pads */
ved->pads = vimc_pads_init(num_pads, pads_flag);
if (IS_ERR(ved->pads))
return PTR_ERR(ved->pads);
/* Fill the vimc_ent_device struct */
ved->ent = &sd->entity;
/* Initialize the subdev */
v4l2_subdev_init(sd, sd_ops);
sd->internal_ops = sd_int_ops;
sd->entity.function = function;
sd->entity.ops = &vimc_ent_sd_mops;
sd->owner = THIS_MODULE;
strscpy(sd->name, name, sizeof(sd->name));
v4l2_set_subdevdata(sd, ved);
/* Expose this subdev to user space */
sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
if (sd->ctrl_handler)
sd->flags |= V4L2_SUBDEV_FL_HAS_EVENTS;
/* Initialize the media entity */
ret = media_entity_pads_init(&sd->entity, num_pads, ved->pads);
if (ret)
goto err_clean_pads;
/* Register the subdev with the v4l2 and the media framework */
ret = v4l2_device_register_subdev(v4l2_dev, sd);
if (ret) {
dev_err(v4l2_dev->dev,
"%s: subdev register failed (err=%d)\n",
name, ret);
goto err_clean_m_ent;
}
return 0;
err_clean_m_ent:
media_entity_cleanup(&sd->entity);
err_clean_pads:
vimc_pads_cleanup(ved->pads);
return ret;
}
EXPORT_SYMBOL_GPL(vimc_ent_sd_register);
void vimc_ent_sd_unregister(struct vimc_ent_device *ved, struct v4l2_subdev *sd)
{
media_entity_cleanup(ved->ent);
vimc_pads_cleanup(ved->pads);
v4l2_device_unregister_subdev(sd);
}
EXPORT_SYMBOL_GPL(vimc_ent_sd_unregister);
MODULE_DESCRIPTION("Virtual Media Controller Driver (VIMC) Common");
MODULE_AUTHOR("Helen Koike <helen.fornazier@gmail.com>");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink