// SPDX-License-Identifier: GPL-2.0-or-later
/*
* vimc-core.c Virtual Media Controller Driver
*
* Copyright (C) 2015-2017 Helen Koike <[email protected]>
*/
#include <linux/dma-mapping.h>
#include <linux/font.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <media/media-device.h>
#include <media/tpg/v4l2-tpg.h>
#include <media/v4l2-device.h>
#include "vimc-common.h"
unsigned int vimc_allocator;
module_param_named(allocator, vimc_allocator, uint, 0444);
MODULE_PARM_DESC(allocator, " memory allocator selection, default is 0.\n"
"\t\t 0 == vmalloc\n"
"\t\t 1 == dma-contig");
#define VIMC_MDEV_MODEL_NAME "VIMC MDEV"
#define VIMC_DATA_LINK(src, srcpad, sink, sinkpad, link_flags) { \
.src_ent = src, \
.src_pad = srcpad, \
.sink_ent = sink, \
.sink_pad = sinkpad, \
.flags = link_flags, \
}
#define VIMC_ANCILLARY_LINK(primary, ancillary) { \
.primary_ent = primary, \
.ancillary_ent = ancillary \
}
/* Structure which describes data links between entities */
struct vimc_data_link {
unsigned int src_ent;
u16 src_pad;
unsigned int sink_ent;
u16 sink_pad;
u32 flags;
};
/* Enum to improve clarity when defining vimc_data_links */
enum vimc_data_link_ents {
SENSOR_A,
SENSOR_B,
DEBAYER_A,
DEBAYER_B,
RAW_CAPTURE_0,
RAW_CAPTURE_1,
RGB_YUV_INPUT,
SCALER,
RGB_YUV_CAPTURE,
LENS_A,
LENS_B,
};
/* Structure which describes ancillary links between entities */
struct vimc_ancillary_link {
unsigned int primary_ent;
unsigned int ancillary_ent;
};
/* Structure which describes the whole topology */
struct vimc_pipeline_config {
const struct vimc_ent_config *ents;
size_t num_ents;
const struct vimc_data_link *data_links;
size_t num_data_links;
const struct vimc_ancillary_link *ancillary_links;
size_t num_ancillary_links;
};
/* --------------------------------------------------------------------------
* Topology Configuration
*/
static const struct vimc_ent_config ent_config[] = {
[SENSOR_A] = {
.name = "Sensor A",
.type = &vimc_sensor_type
},
[SENSOR_B] = {
.name = "Sensor B",
.type = &vimc_sensor_type
},
[DEBAYER_A] = {
.name = "Debayer A",
.type = &vimc_debayer_type
},
[DEBAYER_B] = {
.name = "Debayer B",
.type = &vimc_debayer_type
},
[RAW_CAPTURE_0] = {
.name = "Raw Capture 0",
.type = &vimc_capture_type
},
[RAW_CAPTURE_1] = {
.name = "Raw Capture 1",
.type = &vimc_capture_type
},
[RGB_YUV_INPUT] = {
/* TODO: change this to vimc-input when it is implemented */
.name = "RGB/YUV Input",
.type = &vimc_sensor_type
},
[SCALER] = {
.name = "Scaler",
.type = &vimc_scaler_type
},
[RGB_YUV_CAPTURE] = {
.name = "RGB/YUV Capture",
.type = &vimc_capture_type
},
[LENS_A] = {
.name = "Lens A",
.type = &vimc_lens_type
},
[LENS_B] = {
.name = "Lens B",
.type = &vimc_lens_type
},
};
static const struct vimc_data_link data_links[] = {
/* Link: Sensor A (Pad 0)->(Pad 0) Debayer A */
VIMC_DATA_LINK(SENSOR_A, 0, DEBAYER_A, 0,
MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
/* Link: Sensor A (Pad 0)->(Pad 0) Raw Capture 0 */
VIMC_DATA_LINK(SENSOR_A, 0, RAW_CAPTURE_0, 0,
MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
/* Link: Sensor B (Pad 0)->(Pad 0) Debayer B */
VIMC_DATA_LINK(SENSOR_B, 0, DEBAYER_B, 0,
MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
/* Link: Sensor B (Pad 0)->(Pad 0) Raw Capture 1 */
VIMC_DATA_LINK(SENSOR_B, 0, RAW_CAPTURE_1, 0,
MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
/* Link: Debayer A (Pad 1)->(Pad 0) Scaler */
VIMC_DATA_LINK(DEBAYER_A, 1, SCALER, 0, MEDIA_LNK_FL_ENABLED),
/* Link: Debayer B (Pad 1)->(Pad 0) Scaler */
VIMC_DATA_LINK(DEBAYER_B, 1, SCALER, 0, 0),
/* Link: RGB/YUV Input (Pad 0)->(Pad 0) Scaler */
VIMC_DATA_LINK(RGB_YUV_INPUT, 0, SCALER, 0, 0),
/* Link: Scaler (Pad 1)->(Pad 0) RGB/YUV Capture */
VIMC_DATA_LINK(SCALER, 1, RGB_YUV_CAPTURE, 0,
MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
};
static const struct vimc_ancillary_link ancillary_links[] = {
/* Link: Sensor A -> Lens A */
VIMC_ANCILLARY_LINK(0, 9),
/* Link: Sensor B -> Lens B */
VIMC_ANCILLARY_LINK(1, 10),
};
static struct vimc_pipeline_config pipe_cfg = {
.ents = ent_config,
.num_ents = ARRAY_SIZE(ent_config),
.data_links = data_links,
.num_data_links = ARRAY_SIZE(data_links),
.ancillary_links = ancillary_links,
.num_ancillary_links = ARRAY_SIZE(ancillary_links),
};
/* -------------------------------------------------------------------------- */
static void vimc_rm_links(struct vimc_device *vimc)
{
unsigned int i;
for (i = 0; i < vimc->pipe_cfg->num_ents; i++)
media_entity_remove_links(vimc->ent_devs[i]->ent);
}
static int vimc_create_links(struct vimc_device *vimc)
{
unsigned int i;
int ret;
/* Initialize the links between entities */
for (i = 0; i < vimc->pipe_cfg->num_data_links; i++) {
const struct vimc_data_link *link = &vimc->pipe_cfg->data_links[i];
struct vimc_ent_device *ved_src =
vimc->ent_devs[link->src_ent];
struct vimc_ent_device *ved_sink =
vimc->ent_devs[link->sink_ent];
ret = media_create_pad_link(ved_src->ent, link->src_pad,
ved_sink->ent, link->sink_pad,
link->flags);
if (ret)
goto err_rm_links;
}
for (i = 0; i < vimc->pipe_cfg->num_ancillary_links; i++) {
const struct vimc_ancillary_link *link = &vimc->pipe_cfg->ancillary_links[i];
struct vimc_ent_device *ved_primary =
vimc->ent_devs[link->primary_ent];
struct vimc_ent_device *ved_ancillary =
vimc->ent_devs[link->ancillary_ent];
struct media_link *ret_link =
media_create_ancillary_link(ved_primary->ent, ved_ancillary->ent);
if (IS_ERR(ret_link)) {
ret = PTR_ERR(ret_link);
goto err_rm_links;
}
}
return 0;
err_rm_links:
vimc_rm_links(vimc);
return ret;
}
static void vimc_release_subdevs(struct vimc_device *vimc)
{
unsigned int i;
for (i = 0; i < vimc->pipe_cfg->num_ents; i++)
if (vimc->ent_devs[i])
vimc->pipe_cfg->ents[i].type->release(vimc->ent_devs[i]);
}
static void vimc_unregister_subdevs(struct vimc_device *vimc)
{
unsigned int i;
for (i = 0; i < vimc->pipe_cfg->num_ents; i++)
if (vimc->ent_devs[i] && vimc->pipe_cfg->ents[i].type->unregister)
vimc->pipe_cfg->ents[i].type->unregister(vimc->ent_devs[i]);
}
static int vimc_add_subdevs(struct vimc_device *vimc)
{
unsigned int i;
for (i = 0; i < vimc->pipe_cfg->num_ents; i++) {
dev_dbg(vimc->mdev.dev, "new entity for %s\n",
vimc->pipe_cfg->ents[i].name);
vimc->ent_devs[i] = vimc->pipe_cfg->ents[i].type->add(vimc,
vimc->pipe_cfg->ents[i].name);
if (IS_ERR(vimc->ent_devs[i])) {
int err = PTR_ERR(vimc->ent_devs[i]);
dev_err(vimc->mdev.dev, "adding entity %s failed (%d)\n",
vimc->pipe_cfg->ents[i].name, err);
vimc->ent_devs[i] = NULL;
vimc_unregister_subdevs(vimc);
vimc_release_subdevs(vimc);
return err;
}
}
return 0;
}
static void vimc_v4l2_dev_release(struct v4l2_device *v4l2_dev)
{
struct vimc_device *vimc =
container_of(v4l2_dev, struct vimc_device, v4l2_dev);
vimc_release_subdevs(vimc);
media_device_cleanup(&vimc->mdev);
kfree(vimc->ent_devs);
kfree(vimc);
}
static int vimc_register_devices(struct vimc_device *vimc)
{
int ret;
/* Register the v4l2 struct */
ret = v4l2_device_register(vimc->mdev.dev, &vimc->v4l2_dev);
if (ret) {
dev_err(vimc->mdev.dev,
"v4l2 device register failed (err=%d)\n", ret);
return ret;
}
/* allocate ent_devs */
vimc->ent_devs = kcalloc(vimc->pipe_cfg->num_ents,
sizeof(*vimc->ent_devs), GFP_KERNEL);
if (!vimc->ent_devs) {
ret = -ENOMEM;
goto err_v4l2_unregister;
}
/* Invoke entity config hooks to initialize and register subdevs */
ret = vimc_add_subdevs(vimc);
if (ret)
goto err_free_ent_devs;
/* Initialize links */
ret = vimc_create_links(vimc);
if (ret)
goto err_rm_subdevs;
/* Register the media device */
ret = media_device_register(&vimc->mdev);
if (ret) {
dev_err(vimc->mdev.dev,
"media device register failed (err=%d)\n", ret);
goto err_rm_subdevs;
}
/* Expose all subdev's nodes*/
ret = v4l2_device_register_subdev_nodes(&vimc->v4l2_dev);
if (ret) {
dev_err(vimc->mdev.dev,
"vimc subdev nodes registration failed (err=%d)\n",
ret);
goto err_mdev_unregister;
}
return 0;
err_mdev_unregister:
media_device_unregister(&vimc->mdev);
err_rm_subdevs:
vimc_unregister_subdevs(vimc);
vimc_release_subdevs(vimc);
err_free_ent_devs:
kfree(vimc->ent_devs);
err_v4l2_unregister:
v4l2_device_unregister(&vimc->v4l2_dev);
return ret;
}
static int vimc_probe(struct platform_device *pdev)
{
const struct font_desc *font = find_font("VGA8x16");
struct vimc_device *vimc;
int ret;
dev_dbg(&pdev->dev, "probe");
if (!font) {
dev_err(&pdev->dev, "could not find font\n");
return -ENODEV;
}
tpg_set_font(font->data);
if (vimc_allocator == VIMC_ALLOCATOR_DMA_CONTIG)
dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
vimc = kzalloc(sizeof(*vimc), GFP_KERNEL);
if (!vimc)
return -ENOMEM;
vimc->pipe_cfg = &pipe_cfg;
/* Link the media device within the v4l2_device */
vimc->v4l2_dev.mdev = &vimc->mdev;
/* Initialize media device */
strscpy(vimc->mdev.model, VIMC_MDEV_MODEL_NAME,
sizeof(vimc->mdev.model));
snprintf(vimc->mdev.bus_info, sizeof(vimc->mdev.bus_info),
"platform:%s", VIMC_PDEV_NAME);
vimc->mdev.dev = &pdev->dev;
media_device_init(&vimc->mdev);
ret = vimc_register_devices(vimc);
if (ret) {
media_device_cleanup(&vimc->mdev);
kfree(vimc);
return ret;
}
/*
* the release cb is set only after successful registration.
* if the registration fails, we release directly from probe
*/
vimc->v4l2_dev.release = vimc_v4l2_dev_release;
platform_set_drvdata(pdev, vimc);
return 0;
}
static void vimc_remove(struct platform_device *pdev)
{
struct vimc_device *vimc = platform_get_drvdata(pdev);
dev_dbg(&pdev->dev, "remove");
vimc_unregister_subdevs(vimc);
media_device_unregister(&vimc->mdev);
v4l2_device_unregister(&vimc->v4l2_dev);
v4l2_device_put(&vimc->v4l2_dev);
}
static void vimc_dev_release(struct device *dev)
{
}
static struct platform_device vimc_pdev = {
.name = VIMC_PDEV_NAME,
.dev.release = vimc_dev_release,
};
static struct platform_driver vimc_pdrv = {
.probe = vimc_probe,
.remove_new = vimc_remove,
.driver = {
.name = VIMC_PDEV_NAME,
},
};
static int __init vimc_init(void)
{
int ret;
ret = platform_device_register(&vimc_pdev);
if (ret) {
dev_err(&vimc_pdev.dev,
"platform device registration failed (err=%d)\n", ret);
return ret;
}
ret = platform_driver_register(&vimc_pdrv);
if (ret) {
dev_err(&vimc_pdev.dev,
"platform driver registration failed (err=%d)\n", ret);
platform_device_unregister(&vimc_pdev);
return ret;
}
return 0;
}
static void __exit vimc_exit(void)
{
platform_driver_unregister(&vimc_pdrv);
platform_device_unregister(&vimc_pdev);
}
module_init(vimc_init);
module_exit(vimc_exit);
MODULE_DESCRIPTION("Virtual Media Controller Driver (VIMC)");
MODULE_AUTHOR("Helen Fornazier <[email protected]>");
MODULE_LICENSE("GPL");
Codebase Browser
linux