Commit f2fe8906 authored by Helen Koike's avatar Helen Koike Committed by Mauro Carvalho Chehab

[media] vimc: Virtual Media Controller core, capture and sensor

First version of the Virtual Media Controller.
Add a simple version of the core of the driver, the capture and
sensor nodes in the topology, generating a grey image in a hardcoded
format.
Signed-off-by: default avatarHelen Koike <helen.koike@collabora.com>
Signed-off-by: default avatarHans Verkuil <hans.verkuil@cisco.com>
[hans.verkuil@cisco.com: fix small typo in Kconfig]
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@s-opensource.com>
parent 3c2472a3
...@@ -13407,6 +13407,14 @@ W: https://linuxtv.org ...@@ -13407,6 +13407,14 @@ W: https://linuxtv.org
S: Maintained S: Maintained
F: drivers/media/platform/vivid/* F: drivers/media/platform/vivid/*
VIMC VIRTUAL MEDIA CONTROLLER DRIVER
M: Helen Koike <helen.koike@collabora.com>
L: linux-media@vger.kernel.org
T: git git://linuxtv.org/media_tree.git
W: https://linuxtv.org
S: Maintained
F: drivers/media/platform/vimc/*
VLYNQ BUS VLYNQ BUS
M: Florian Fainelli <f.fainelli@gmail.com> M: Florian Fainelli <f.fainelli@gmail.com>
L: openwrt-devel@lists.openwrt.org (subscribers-only) L: openwrt-devel@lists.openwrt.org (subscribers-only)
......
...@@ -495,6 +495,8 @@ menuconfig V4L_TEST_DRIVERS ...@@ -495,6 +495,8 @@ menuconfig V4L_TEST_DRIVERS
if V4L_TEST_DRIVERS if V4L_TEST_DRIVERS
source "drivers/media/platform/vimc/Kconfig"
source "drivers/media/platform/vivid/Kconfig" source "drivers/media/platform/vivid/Kconfig"
config VIDEO_VIM2M config VIDEO_VIM2M
......
...@@ -13,6 +13,7 @@ obj-$(CONFIG_VIDEO_PXA27x) += pxa_camera.o ...@@ -13,6 +13,7 @@ obj-$(CONFIG_VIDEO_PXA27x) += pxa_camera.o
obj-$(CONFIG_VIDEO_VIU) += fsl-viu.o obj-$(CONFIG_VIDEO_VIU) += fsl-viu.o
obj-$(CONFIG_VIDEO_VIMC) += vimc/
obj-$(CONFIG_VIDEO_VIVID) += vivid/ obj-$(CONFIG_VIDEO_VIVID) += vivid/
obj-$(CONFIG_VIDEO_VIM2M) += vim2m.o obj-$(CONFIG_VIDEO_VIM2M) += vim2m.o
......
config VIDEO_VIMC
tristate "Virtual Media Controller Driver (VIMC)"
depends on VIDEO_DEV && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
select VIDEOBUF2_VMALLOC
default n
---help---
Skeleton driver for Virtual Media Controller
This driver can be compared to the vivid driver for emulating
a media node that exposes a complex media topology. The topology
is hard coded for now but is meant to be highly configurable in
the future.
When in doubt, say N.
vimc-objs := vimc-core.o vimc-capture.o vimc-sensor.o
obj-$(CONFIG_VIDEO_VIMC) += vimc.o
This diff is collapsed.
/*
* vimc-capture.h 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.
*
*/
#ifndef _VIMC_CAPTURE_H_
#define _VIMC_CAPTURE_H_
#include "vimc-core.h"
struct vimc_ent_device *vimc_cap_create(struct v4l2_device *v4l2_dev,
const char *const name,
u16 num_pads,
const unsigned long *pads_flag);
#endif
This diff is collapsed.
/*
* vimc-core.h 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.
*
*/
#ifndef _VIMC_CORE_H_
#define _VIMC_CORE_H_
#include <linux/slab.h>
#include <media/v4l2-device.h>
/**
* struct vimc_pix_map - maps media bus code with v4l2 pixel format
*
* @code: media bus format code defined by MEDIA_BUS_FMT_* macros
* @bbp: number of bytes each pixel occupies
* @pixelformat: pixel format devined by V4L2_PIX_FMT_* macros
*
* Struct which matches the MEDIA_BUS_FMT_* codes with the corresponding
* V4L2_PIX_FMT_* fourcc pixelformat and its bytes per pixel (bpp)
*/
struct vimc_pix_map {
unsigned int code;
unsigned int bpp;
u32 pixelformat;
};
/**
* struct vimc_ent_device - core struct that represents a node in the topology
*
* @ent: the pointer to struct media_entity for the node
* @pads: the list of pads of the node
* @destroy: callback to destroy the node
* @process_frame: callback send a frame to that node
*
* Each node of the topology must create a vimc_ent_device struct. Depending on
* the node it will be of an instance of v4l2_subdev or video_device struct
* where both contains a struct media_entity.
* Those structures should embedded the vimc_ent_device struct through
* v4l2_set_subdevdata() and video_set_drvdata() respectivaly, allowing the
* vimc_ent_device struct to be retrieved from the corresponding struct
* media_entity
*/
struct vimc_ent_device {
struct media_entity *ent;
struct media_pad *pads;
void (*destroy)(struct vimc_ent_device *);
void (*process_frame)(struct vimc_ent_device *ved,
struct media_pad *sink, const void *frame);
};
/**
* vimc_propagate_frame - propagate a frame through the topology
*
* @src: the source pad where the frame is being originated
* @frame: the frame to be propagated
*
* This function will call the process_frame callback from the vimc_ent_device
* struct of the nodes directly connected to the @src pad
*/
int vimc_propagate_frame(struct media_pad *src, const void *frame);
/**
* vimc_pads_init - initialize pads
*
* @num_pads: number of pads to initialize
* @pads_flags: flags to use in each pad
*
* Helper functions to allocate/initialize pads
*/
struct media_pad *vimc_pads_init(u16 num_pads,
const unsigned long *pads_flag);
/**
* vimc_pads_cleanup - free pads
*
* @pads: pointer to the pads
*
* Helper function to free the pads initialized with vimc_pads_init
*/
static inline void vimc_pads_cleanup(struct media_pad *pads)
{
kfree(pads);
}
/**
* vimc_pix_map_by_code - get vimc_pix_map struct by media bus code
*
* @code: media bus format code defined by MEDIA_BUS_FMT_* macros
*/
const struct vimc_pix_map *vimc_pix_map_by_code(u32 code);
/**
* vimc_pix_map_by_pixelformat - get vimc_pix_map struct by v4l2 pixel format
*
* @pixelformat: pixel format devined by V4L2_PIX_FMT_* macros
*/
const struct vimc_pix_map *vimc_pix_map_by_pixelformat(u32 pixelformat);
#endif
/*
* vimc-sensor.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/freezer.h>
#include <linux/kthread.h>
#include <linux/v4l2-mediabus.h>
#include <linux/vmalloc.h>
#include <media/v4l2-subdev.h>
#include "vimc-sensor.h"
struct vimc_sen_device {
struct vimc_ent_device ved;
struct v4l2_subdev sd;
struct task_struct *kthread_sen;
u8 *frame;
/* The active format */
struct v4l2_mbus_framefmt mbus_format;
int frame_size;
};
static int vimc_sen_enum_mbus_code(struct v4l2_subdev *sd,
struct v4l2_subdev_pad_config *cfg,
struct v4l2_subdev_mbus_code_enum *code)
{
struct vimc_sen_device *vsen =
container_of(sd, struct vimc_sen_device, sd);
/* TODO: Add support for other codes */
if (code->index)
return -EINVAL;
code->code = vsen->mbus_format.code;
return 0;
}
static int vimc_sen_enum_frame_size(struct v4l2_subdev *sd,
struct v4l2_subdev_pad_config *cfg,
struct v4l2_subdev_frame_size_enum *fse)
{
struct vimc_sen_device *vsen =
container_of(sd, struct vimc_sen_device, sd);
/* TODO: Add support to other formats */
if (fse->index)
return -EINVAL;
/* TODO: Add support for other codes */
if (fse->code != vsen->mbus_format.code)
return -EINVAL;
fse->min_width = vsen->mbus_format.width;
fse->max_width = vsen->mbus_format.width;
fse->min_height = vsen->mbus_format.height;
fse->max_height = vsen->mbus_format.height;
return 0;
}
static int vimc_sen_get_fmt(struct v4l2_subdev *sd,
struct v4l2_subdev_pad_config *cfg,
struct v4l2_subdev_format *format)
{
struct vimc_sen_device *vsen =
container_of(sd, struct vimc_sen_device, sd);
format->format = vsen->mbus_format;
return 0;
}
static const struct v4l2_subdev_pad_ops vimc_sen_pad_ops = {
.enum_mbus_code = vimc_sen_enum_mbus_code,
.enum_frame_size = vimc_sen_enum_frame_size,
.get_fmt = vimc_sen_get_fmt,
/* TODO: Add support to other formats */
.set_fmt = vimc_sen_get_fmt,
};
/* media operations */
static const struct media_entity_operations vimc_sen_mops = {
.link_validate = v4l2_subdev_link_validate,
};
static int vimc_thread_sen(void *data)
{
struct vimc_sen_device *vsen = data;
unsigned int i;
set_freezable();
set_current_state(TASK_UNINTERRUPTIBLE);
for (;;) {
try_to_freeze();
if (kthread_should_stop())
break;
memset(vsen->frame, 100, vsen->frame_size);
/* Send the frame to all source pads */
for (i = 0; i < vsen->sd.entity.num_pads; i++)
vimc_propagate_frame(&vsen->sd.entity.pads[i],
vsen->frame);
/* 60 frames per second */
schedule_timeout(HZ/60);
}
return 0;
}
static int vimc_sen_s_stream(struct v4l2_subdev *sd, int enable)
{
struct vimc_sen_device *vsen =
container_of(sd, struct vimc_sen_device, sd);
int ret;
if (enable) {
const struct vimc_pix_map *vpix;
if (vsen->kthread_sen)
return -EINVAL;
/* Calculate the frame size */
vpix = vimc_pix_map_by_code(vsen->mbus_format.code);
vsen->frame_size = vsen->mbus_format.width * vpix->bpp *
vsen->mbus_format.height;
/*
* Allocate the frame buffer. Use vmalloc to be able to
* allocate a large amount of memory
*/
vsen->frame = vmalloc(vsen->frame_size);
if (!vsen->frame)
return -ENOMEM;
/* Initialize the image generator thread */
vsen->kthread_sen = kthread_run(vimc_thread_sen, vsen, "%s-sen",
vsen->sd.v4l2_dev->name);
if (IS_ERR(vsen->kthread_sen)) {
dev_err(vsen->sd.v4l2_dev->dev,
"%s: kernel_thread() failed\n", vsen->sd.name);
vfree(vsen->frame);
vsen->frame = NULL;
return PTR_ERR(vsen->kthread_sen);
}
} else {
if (!vsen->kthread_sen)
return -EINVAL;
/* Stop image generator */
ret = kthread_stop(vsen->kthread_sen);
vsen->kthread_sen = NULL;
vfree(vsen->frame);
vsen->frame = NULL;
return ret;
}
return 0;
}
struct v4l2_subdev_video_ops vimc_sen_video_ops = {
.s_stream = vimc_sen_s_stream,
};
static const struct v4l2_subdev_ops vimc_sen_ops = {
.pad = &vimc_sen_pad_ops,
.video = &vimc_sen_video_ops,
};
static void vimc_sen_destroy(struct vimc_ent_device *ved)
{
struct vimc_sen_device *vsen =
container_of(ved, struct vimc_sen_device, ved);
v4l2_device_unregister_subdev(&vsen->sd);
media_entity_cleanup(ved->ent);
kfree(vsen);
}
struct vimc_ent_device *vimc_sen_create(struct v4l2_device *v4l2_dev,
const char *const name,
u16 num_pads,
const unsigned long *pads_flag)
{
struct vimc_sen_device *vsen;
unsigned int i;
int ret;
/* NOTE: a sensor node may be created with more then one pad */
if (!name || !num_pads || !pads_flag)
return ERR_PTR(-EINVAL);
/* check if all pads are sources */
for (i = 0; i < num_pads; i++)
if (!(pads_flag[i] & MEDIA_PAD_FL_SOURCE))
return ERR_PTR(-EINVAL);
/* Allocate the vsen struct */
vsen = kzalloc(sizeof(*vsen), GFP_KERNEL);
if (!vsen)
return ERR_PTR(-ENOMEM);
/* Allocate the pads */
vsen->ved.pads = vimc_pads_init(num_pads, pads_flag);
if (IS_ERR(vsen->ved.pads)) {
ret = PTR_ERR(vsen->ved.pads);
goto err_free_vsen;
}
/* Fill the vimc_ent_device struct */
vsen->ved.destroy = vimc_sen_destroy;
vsen->ved.ent = &vsen->sd.entity;
/* Initialize the subdev */
v4l2_subdev_init(&vsen->sd, &vimc_sen_ops);
vsen->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
vsen->sd.entity.ops = &vimc_sen_mops;
vsen->sd.owner = THIS_MODULE;
strlcpy(vsen->sd.name, name, sizeof(vsen->sd.name));
v4l2_set_subdevdata(&vsen->sd, &vsen->ved);
/* Expose this subdev to user space */
vsen->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
/* Initialize the media entity */
ret = media_entity_pads_init(&vsen->sd.entity,
num_pads, vsen->ved.pads);
if (ret)
goto err_clean_pads;
/* Set the active frame format (this is hardcoded for now) */
vsen->mbus_format.width = 640;
vsen->mbus_format.height = 480;
vsen->mbus_format.code = MEDIA_BUS_FMT_RGB888_1X24;
vsen->mbus_format.field = V4L2_FIELD_NONE;
vsen->mbus_format.colorspace = V4L2_COLORSPACE_SRGB;
vsen->mbus_format.quantization = V4L2_QUANTIZATION_FULL_RANGE;
vsen->mbus_format.xfer_func = V4L2_XFER_FUNC_SRGB;
/* Register the subdev with the v4l2 and the media framework */
ret = v4l2_device_register_subdev(v4l2_dev, &vsen->sd);
if (ret) {
dev_err(vsen->sd.v4l2_dev->dev,
"%s: subdev register failed (err=%d)\n",
vsen->sd.name, ret);
goto err_clean_m_ent;
}
return &vsen->ved;
err_clean_m_ent:
media_entity_cleanup(&vsen->sd.entity);
err_clean_pads:
vimc_pads_cleanup(vsen->ved.pads);
err_free_vsen:
kfree(vsen);
return ERR_PTR(ret);
}
/*
* vimc-sensor.h 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.
*
*/
#ifndef _VIMC_SENSOR_H_
#define _VIMC_SENSOR_H_
#include "vimc-core.h"
struct vimc_ent_device *vimc_sen_create(struct v4l2_device *v4l2_dev,
const char *const name,
u16 num_pads,
const unsigned long *pads_flag);
#endif
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment