static int bdisp_register_device(struct bdisp_dev *bdisp)
{
int ret;
if (!bdisp)
return -ENODEV;
bdisp->vdev.fops = &bdisp_fops;
bdisp->vdev.ioctl_ops = &bdisp_ioctl_ops;
bdisp->vdev.release = video_device_release_empty;
bdisp->vdev.lock = &bdisp->lock;
bdisp->vdev.vfl_dir = VFL_DIR_M2M;
bdisp->vdev.v4l2_dev = &bdisp->v4l2_dev;
snprintf(bdisp->vdev.name, sizeof(bdisp->vdev.name), "%s.%d",
BDISP_NAME, bdisp->id);
video_set_drvdata(&bdisp->vdev, bdisp);
bdisp->m2m.vdev = &bdisp->vdev;
bdisp->m2m.m2m_dev = v4l2_m2m_init(&bdisp_m2m_ops);
if (IS_ERR(bdisp->m2m.m2m_dev)) {
dev_err(bdisp->dev, "failed to initialize v4l2-m2m device\n");
return PTR_ERR(bdisp->m2m.m2m_dev);
}
ret = video_register_device(&bdisp->vdev, VFL_TYPE_GRABBER, -1);
if (ret) {
dev_err(bdisp->dev,
"%s(): failed to register video device\n", __func__);
v4l2_m2m_release(bdisp->m2m.m2m_dev);
return ret;
}
return 0;
}
int fimc_register_m2m_device(struct fimc_dev *fimc,
struct v4l2_device *v4l2_dev)
{
struct video_device *vfd;
struct platform_device *pdev;
int ret = 0;
if (!fimc)
return -ENODEV;
pdev = fimc->pdev;
fimc->v4l2_dev = v4l2_dev;
vfd = video_device_alloc();
if (!vfd) {
v4l2_err(v4l2_dev, "Failed to allocate video device\n");
return -ENOMEM;
}
vfd->fops = &fimc_m2m_fops;
vfd->ioctl_ops = &fimc_m2m_ioctl_ops;
vfd->v4l2_dev = v4l2_dev;
vfd->minor = -1;
vfd->release = video_device_release;
vfd->lock = &fimc->lock;
snprintf(vfd->name, sizeof(vfd->name), "fimc.%d.m2m", fimc->id);
video_set_drvdata(vfd, fimc);
fimc->m2m.vfd = vfd;
fimc->m2m.m2m_dev = v4l2_m2m_init(&m2m_ops);
if (IS_ERR(fimc->m2m.m2m_dev)) {
v4l2_err(v4l2_dev, "failed to initialize v4l2-m2m device\n");
ret = PTR_ERR(fimc->m2m.m2m_dev);
goto err_init;
}
ret = media_entity_init(&vfd->entity, 0, NULL, 0);
if (ret)
goto err_me;
ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1);
if (ret)
goto err_vd;
v4l2_info(v4l2_dev, "Registered %s as /dev/%s\n",
vfd->name, video_device_node_name(vfd));
return 0;
err_vd:
media_entity_cleanup(&vfd->entity);
err_me:
v4l2_m2m_release(fimc->m2m.m2m_dev);
err_init:
video_device_release(fimc->m2m.vfd);
return ret;
}
int gsc_register_m2m_device(struct gsc_dev *gsc)
{
struct video_device *vfd;
struct platform_device *pdev;
int ret = 0;
if (!gsc)
return -ENODEV;
pdev = gsc->pdev;
vfd = video_device_alloc();
if (!vfd) {
dev_err(&pdev->dev, "Failed to allocate video device\n");
return -ENOMEM;
}
vfd->fops = &gsc_m2m_fops;
vfd->ioctl_ops = &gsc_m2m_ioctl_ops;
vfd->release = video_device_release;
vfd->lock = &gsc->lock;
vfd->vfl_dir = VFL_DIR_M2M;
snprintf(vfd->name, sizeof(vfd->name), "%s:m2m", dev_name(&pdev->dev));
video_set_drvdata(vfd, gsc);
gsc->m2m.vfd = vfd;
gsc->m2m.m2m_dev = v4l2_m2m_init(&gsc_m2m_ops);
if (IS_ERR(gsc->m2m.m2m_dev)) {
dev_err(&pdev->dev, "failed to initialize v4l2-m2m device\n");
ret = PTR_ERR(gsc->m2m.m2m_dev);
goto err_m2m_r1;
}
ret = video_register_device(vfd, VFL_TYPE_GRABBER,
EXYNOS_VIDEONODE_GSC_M2M(gsc->id));
if (ret) {
dev_err(&pdev->dev,
"%s(): failed to register video device\n", __func__);
goto err_m2m_r2;
}
setup_timer(&gsc->op_timer, gsc_op_timer_handler,
(unsigned long)gsc);
gsc_dbg("gsc m2m driver registered as /dev/video%d", vfd->num);
return 0;
err_m2m_r2:
v4l2_m2m_release(gsc->m2m.m2m_dev);
err_m2m_r1:
video_device_release(gsc->m2m.vfd);
return ret;
}
static int hva_register_device(struct hva_dev *hva)
{
int ret;
struct video_device *vdev;
struct device *dev;
if (!hva)
return -ENODEV;
dev = hva_to_dev(hva);
hva->m2m_dev = v4l2_m2m_init(&hva_m2m_ops);
if (IS_ERR(hva->m2m_dev)) {
dev_err(dev, "%s failed to initialize v4l2-m2m device\n",
HVA_PREFIX);
ret = PTR_ERR(hva->m2m_dev);
goto err;
}
vdev = video_device_alloc();
if (!vdev) {
dev_err(dev, "%s failed to allocate video device\n",
HVA_PREFIX);
ret = -ENOMEM;
goto err_m2m_release;
}
vdev->fops = &hva_fops;
vdev->ioctl_ops = &hva_ioctl_ops;
vdev->release = video_device_release;
vdev->lock = &hva->lock;
vdev->vfl_dir = VFL_DIR_M2M;
vdev->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M;
vdev->v4l2_dev = &hva->v4l2_dev;
snprintf(vdev->name, sizeof(vdev->name), "%s%lx", HVA_NAME,
hva->ip_version);
ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
if (ret) {
dev_err(dev, "%s failed to register video device\n",
HVA_PREFIX);
goto err_vdev_release;
}
hva->vdev = vdev;
video_set_drvdata(vdev, hva);
return 0;
err_vdev_release:
video_device_release(vdev);
err_m2m_release:
v4l2_m2m_release(hva->m2m_dev);
err:
return ret;
}
int gsc_register_m2m_device(struct gsc_dev *gsc)
{
struct platform_device *pdev;
int ret;
if (!gsc)
return -ENODEV;
pdev = gsc->pdev;
gsc->vdev.fops = &gsc_m2m_fops;
gsc->vdev.ioctl_ops = &gsc_m2m_ioctl_ops;
gsc->vdev.release = video_device_release_empty;
gsc->vdev.lock = &gsc->lock;
gsc->vdev.vfl_dir = VFL_DIR_M2M;
gsc->vdev.v4l2_dev = &gsc->v4l2_dev;
snprintf(gsc->vdev.name, sizeof(gsc->vdev.name), "%s.%d:m2m",
GSC_MODULE_NAME, gsc->id);
video_set_drvdata(&gsc->vdev, gsc);
gsc->m2m.vfd = &gsc->vdev;
gsc->m2m.m2m_dev = v4l2_m2m_init(&gsc_m2m_ops);
if (IS_ERR(gsc->m2m.m2m_dev)) {
dev_err(&pdev->dev, "failed to initialize v4l2-m2m device\n");
ret = PTR_ERR(gsc->m2m.m2m_dev);
goto err_m2m_r1;
}
ret = video_register_device(&gsc->vdev, VFL_TYPE_GRABBER, -1);
if (ret) {
dev_err(&pdev->dev,
"%s(): failed to register video device\n", __func__);
goto err_m2m_r2;
}
pr_debug("gsc m2m driver registered as /dev/video%d", gsc->vdev.num);
return 0;
err_m2m_r2:
v4l2_m2m_release(gsc->m2m.m2m_dev);
err_m2m_r1:
video_device_release(gsc->m2m.vfd);
return ret;
}
int fimc_register_m2m_device(struct fimc_dev *fimc,
struct v4l2_device *v4l2_dev)
{
struct video_device *vfd = &fimc->m2m.vfd;
int ret;
fimc->v4l2_dev = v4l2_dev;
memset(vfd, 0, sizeof(*vfd));
vfd->fops = &fimc_m2m_fops;
vfd->ioctl_ops = &fimc_m2m_ioctl_ops;
vfd->v4l2_dev = v4l2_dev;
vfd->minor = -1;
vfd->release = video_device_release_empty;
vfd->lock = &fimc->lock;
vfd->vfl_dir = VFL_DIR_M2M;
snprintf(vfd->name, sizeof(vfd->name), "fimc.%d.m2m", fimc->id);
video_set_drvdata(vfd, fimc);
fimc->m2m.m2m_dev = v4l2_m2m_init(&m2m_ops);
if (IS_ERR(fimc->m2m.m2m_dev)) {
v4l2_err(v4l2_dev, "failed to initialize v4l2-m2m device\n");
return PTR_ERR(fimc->m2m.m2m_dev);
}
ret = media_entity_init(&vfd->entity, 0, NULL, 0);
if (ret)
goto err_me;
ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1);
if (ret)
goto err_vd;
v4l2_info(v4l2_dev, "Registered %s as /dev/%s\n",
vfd->name, video_device_node_name(vfd));
return 0;
err_vd:
media_entity_cleanup(&vfd->entity);
err_me:
v4l2_m2m_release(fimc->m2m.m2m_dev);
return ret;
}
static int g2d_probe(struct platform_device *pdev)
{
struct g2d_dev *dev;
struct video_device *vfd;
struct resource *res;
const struct of_device_id *of_id;
int ret = 0;
dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
if (!dev)
return -ENOMEM;
spin_lock_init(&dev->ctrl_lock);
mutex_init(&dev->mutex);
atomic_set(&dev->num_inst, 0);
init_waitqueue_head(&dev->irq_queue);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
dev->regs = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(dev->regs))
return PTR_ERR(dev->regs);
dev->clk = clk_get(&pdev->dev, "sclk_fimg2d");
if (IS_ERR(dev->clk)) {
dev_err(&pdev->dev, "failed to get g2d clock\n");
return -ENXIO;
}
ret = clk_prepare(dev->clk);
if (ret) {
dev_err(&pdev->dev, "failed to prepare g2d clock\n");
goto put_clk;
}
dev->gate = clk_get(&pdev->dev, "fimg2d");
if (IS_ERR(dev->gate)) {
dev_err(&pdev->dev, "failed to get g2d clock gate\n");
ret = -ENXIO;
goto unprep_clk;
}
ret = clk_prepare(dev->gate);
if (ret) {
dev_err(&pdev->dev, "failed to prepare g2d clock gate\n");
goto put_clk_gate;
}
res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!res) {
dev_err(&pdev->dev, "failed to find IRQ\n");
ret = -ENXIO;
goto unprep_clk_gate;
}
dev->irq = res->start;
ret = devm_request_irq(&pdev->dev, dev->irq, g2d_isr,
0, pdev->name, dev);
if (ret) {
dev_err(&pdev->dev, "failed to install IRQ\n");
goto put_clk_gate;
}
dev->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
if (IS_ERR(dev->alloc_ctx)) {
ret = PTR_ERR(dev->alloc_ctx);
goto unprep_clk_gate;
}
ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
if (ret)
goto alloc_ctx_cleanup;
vfd = video_device_alloc();
if (!vfd) {
v4l2_err(&dev->v4l2_dev, "Failed to allocate video device\n");
ret = -ENOMEM;
goto unreg_v4l2_dev;
}
*vfd = g2d_videodev;
vfd->lock = &dev->mutex;
vfd->v4l2_dev = &dev->v4l2_dev;
ret = video_register_device(vfd, VFL_TYPE_GRABBER, 0);
if (ret) {
v4l2_err(&dev->v4l2_dev, "Failed to register video device\n");
goto rel_vdev;
}
video_set_drvdata(vfd, dev);
snprintf(vfd->name, sizeof(vfd->name), "%s", g2d_videodev.name);
dev->vfd = vfd;
v4l2_info(&dev->v4l2_dev, "device registered as /dev/video%d\n",
vfd->num);
platform_set_drvdata(pdev, dev);
dev->m2m_dev = v4l2_m2m_init(&g2d_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);
goto unreg_video_dev;
}
def_frame.stride = (def_frame.width * def_frame.fmt->depth) >> 3;
if (!pdev->dev.of_node) {
dev->variant = g2d_get_drv_data(pdev);
} else {
of_id = of_match_node(exynos_g2d_match, pdev->dev.of_node);
if (!of_id) {
ret = -ENODEV;
goto unreg_video_dev;
}
dev->variant = (struct g2d_variant *)of_id->data;
}
return 0;
unreg_video_dev:
video_unregister_device(dev->vfd);
rel_vdev:
video_device_release(vfd);
unreg_v4l2_dev:
v4l2_device_unregister(&dev->v4l2_dev);
alloc_ctx_cleanup:
vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);
unprep_clk_gate:
clk_unprepare(dev->gate);
put_clk_gate:
clk_put(dev->gate);
unprep_clk:
clk_unprepare(dev->clk);
put_clk:
clk_put(dev->clk);
return ret;
}
static int g2d_probe(struct platform_device *pdev)
{
struct g2d_dev *dev;
struct video_device *vfd;
struct resource *res;
int ret = 0;
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev)
return -ENOMEM;
spin_lock_init(&dev->ctrl_lock);
mutex_init(&dev->mutex);
atomic_set(&dev->num_inst, 0);
init_waitqueue_head(&dev->irq_queue);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "failed to find registers\n");
ret = -ENOENT;
goto free_dev;
}
dev->res_regs = request_mem_region(res->start, resource_size(res),
dev_name(&pdev->dev));
if (!dev->res_regs) {
dev_err(&pdev->dev, "failed to obtain register region\n");
ret = -ENOENT;
goto free_dev;
}
dev->regs = ioremap(res->start, resource_size(res));
if (!dev->regs) {
dev_err(&pdev->dev, "failed to map registers\n");
ret = -ENOENT;
goto rel_res_regs;
}
dev->clk = clk_get(&pdev->dev, "sclk_fimg2d");
if (IS_ERR_OR_NULL(dev->clk)) {
dev_err(&pdev->dev, "failed to get g2d clock\n");
ret = -ENXIO;
goto unmap_regs;
}
ret = clk_prepare(dev->clk);
if (ret) {
dev_err(&pdev->dev, "failed to prepare g2d clock\n");
goto put_clk;
}
dev->gate = clk_get(&pdev->dev, "fimg2d");
if (IS_ERR_OR_NULL(dev->gate)) {
dev_err(&pdev->dev, "failed to get g2d clock gate\n");
ret = -ENXIO;
goto unprep_clk;
}
ret = clk_prepare(dev->gate);
if (ret) {
dev_err(&pdev->dev, "failed to prepare g2d clock gate\n");
goto put_clk_gate;
}
res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!res) {
dev_err(&pdev->dev, "failed to find IRQ\n");
ret = -ENXIO;
goto unprep_clk_gate;
}
dev->irq = res->start;
ret = request_irq(dev->irq, g2d_isr, 0, pdev->name, dev);
if (ret) {
dev_err(&pdev->dev, "failed to install IRQ\n");
goto put_clk_gate;
}
dev->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
if (IS_ERR(dev->alloc_ctx)) {
ret = PTR_ERR(dev->alloc_ctx);
goto rel_irq;
}
ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
if (ret)
goto alloc_ctx_cleanup;
vfd = video_device_alloc();
if (!vfd) {
v4l2_err(&dev->v4l2_dev, "Failed to allocate video device\n");
ret = -ENOMEM;
goto unreg_v4l2_dev;
}
*vfd = g2d_videodev;
vfd->lock = &dev->mutex;
ret = video_register_device(vfd, VFL_TYPE_GRABBER, 0);
if (ret) {
v4l2_err(&dev->v4l2_dev, "Failed to register video device\n");
goto rel_vdev;
}
video_set_drvdata(vfd, dev);
snprintf(vfd->name, sizeof(vfd->name), "%s", g2d_videodev.name);
dev->vfd = vfd;
v4l2_info(&dev->v4l2_dev, "device registered as /dev/video%d\n",
vfd->num);
platform_set_drvdata(pdev, dev);
dev->m2m_dev = v4l2_m2m_init(&g2d_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);
goto unreg_video_dev;
}
def_frame.stride = (def_frame.width * def_frame.fmt->depth) >> 3;
return 0;
unreg_video_dev:
video_unregister_device(dev->vfd);
rel_vdev:
video_device_release(vfd);
unreg_v4l2_dev:
v4l2_device_unregister(&dev->v4l2_dev);
alloc_ctx_cleanup:
vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);
rel_irq:
free_irq(dev->irq, dev);
unprep_clk_gate:
clk_unprepare(dev->gate);
put_clk_gate:
clk_put(dev->gate);
unprep_clk:
clk_unprepare(dev->clk);
put_clk:
clk_put(dev->clk);
unmap_regs:
iounmap(dev->regs);
rel_res_regs:
release_resource(dev->res_regs);
free_dev:
kfree(dev);
return ret;
}
static int rot_register_m2m_device(struct rot_dev *rot)
{
struct v4l2_device *v4l2_dev;
struct platform_device *pdev;
struct video_device *vfd;
int ret = 0;
if (!rot)
return -ENODEV;
pdev = rot->pdev;
v4l2_dev = &rot->m2m.v4l2_dev;
/* Set name to "device name.m2m" if it is empty */
if (!v4l2_dev->name[0])
snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
"%s.m2m", dev_name(&pdev->dev));
ret = v4l2_device_register(&pdev->dev, v4l2_dev);
if (ret) {
rot_err("failed to register v4l2 device\n");
return ret;
}
vfd = video_device_alloc();
if (!vfd) {
rot_err("failed to allocate video device\n");
goto err_v4l2_dev;
}
vfd->fops = &rot_v4l2_fops;
vfd->ioctl_ops = &rot_v4l2_ioctl_ops;
vfd->release = video_device_release;
video_set_drvdata(vfd, rot);
platform_set_drvdata(pdev, rot);
rot->m2m.vfd = vfd;
rot->m2m.m2m_dev = v4l2_m2m_init(&rot_m2m_ops);
if (IS_ERR(rot->m2m.m2m_dev)) {
rot_err("failed to initialize v4l2-m2m device\n");
ret = PTR_ERR(rot->m2m.m2m_dev);
goto err_dev_alloc;
}
ret = video_register_device(vfd, VFL_TYPE_GRABBER,
EXYNOS_VIDEONODE_ROTATOR);
if (ret) {
rot_err("failed to register video device\n");
goto err_m2m_dev;
}
return 0;
err_m2m_dev:
v4l2_m2m_release(rot->m2m.m2m_dev);
err_dev_alloc:
video_device_release(rot->m2m.vfd);
err_v4l2_dev:
v4l2_device_unregister(v4l2_dev);
return ret;
}
static int jpeg_probe(struct platform_device *pdev)
{
struct jpeg_dev *dev;
struct video_device *vfd;
struct resource *res;
int ret;
/* global structure */
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev) {
dev_err(&pdev->dev, "%s: not enough memory\n",
__func__);
ret = -ENOMEM;
goto err_alloc;
}
dev->plat_dev = pdev;
/* setup jpeg control */
ret = jpeg_setup_controller(dev);
if (ret) {
jpeg_err("failed to setup controller\n");
goto err_setup;
}
/* memory region */
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
jpeg_err("failed to get jpeg memory region resource\n");
ret = -ENOENT;
goto err_res;
}
res = request_mem_region(res->start, resource_size(res),
pdev->name);
if (!res) {
jpeg_err("failed to request jpeg io memory region\n");
ret = -ENOMEM;
goto err_region;
}
/* ioremap */
dev->reg_base = ioremap(res->start, resource_size(res));
if (!dev->reg_base) {
jpeg_err("failed to remap jpeg io region\n");
ret = -ENOENT;
goto err_map;
}
spin_lock_init(&dev->slock);
/* irq */
res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!res) {
jpeg_err("failed to request jpeg irq resource\n");
ret = -ENOENT;
goto err_irq;
}
dev->irq_no = res->start;
ret = request_irq(dev->irq_no, (void *)jpeg_irq,
IRQF_DISABLED, pdev->name, dev);
if (ret != 0) {
jpeg_err("failed to jpeg request irq\n");
ret = -ENOENT;
goto err_irq;
}
/* clock */
dev->clk = clk_get(&pdev->dev, "jpeg");
if (IS_ERR(dev->clk)) {
jpeg_err("failed to find jpeg clock source\n");
ret = -ENOENT;
goto err_clk;
}
#ifdef CONFIG_PM_RUNTIME
pm_runtime_enable(&pdev->dev);
#endif
/* clock enable */
clk_enable(dev->clk);
ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
if (ret) {
v4l2_err(&dev->v4l2_dev, "Failed to register v4l2 device\n");
goto err_v4l2;
}
/* encoder */
vfd = video_device_alloc();
if (!vfd) {
v4l2_err(&dev->v4l2_dev, "Failed to allocate video device\n");
ret = -ENOMEM;
goto err_vd_alloc_enc;
}
*vfd = jpeg_enc_videodev;
vfd->ioctl_ops = get_jpeg_enc_v4l2_ioctl_ops();
ret = video_register_device(vfd, VFL_TYPE_GRABBER, 12);
if (ret) {
v4l2_err(&dev->v4l2_dev,
"%s(): failed to register video device\n", __func__);
video_device_release(vfd);
goto err_vd_alloc_enc;
}
v4l2_info(&dev->v4l2_dev,
"JPEG driver is registered to /dev/video%d\n", vfd->num);
dev->vfd_enc = vfd;
dev->m2m_dev_enc = v4l2_m2m_init(&jpeg_m2m_enc_ops);
if (IS_ERR(dev->m2m_dev_enc)) {
v4l2_err(&dev->v4l2_dev,
"failed to initialize v4l2-m2m device\n");
ret = PTR_ERR(dev->m2m_dev_enc);
goto err_m2m_init_enc;
}
video_set_drvdata(vfd, dev);
/* decoder */
vfd = video_device_alloc();
if (!vfd) {
v4l2_err(&dev->v4l2_dev, "Failed to allocate video device\n");
ret = -ENOMEM;
goto err_vd_alloc_dec;
}
*vfd = jpeg_dec_videodev;
vfd->ioctl_ops = get_jpeg_dec_v4l2_ioctl_ops();
ret = video_register_device(vfd, VFL_TYPE_GRABBER, 11);
if (ret) {
v4l2_err(&dev->v4l2_dev,
"%s(): failed to register video device\n", __func__);
video_device_release(vfd);
goto err_vd_alloc_dec;
}
v4l2_info(&dev->v4l2_dev,
"JPEG driver is registered to /dev/video%d\n", vfd->num);
dev->vfd_dec = vfd;
dev->m2m_dev_dec = v4l2_m2m_init(&jpeg_m2m_dec_ops);
if (IS_ERR(dev->m2m_dev_dec)) {
v4l2_err(&dev->v4l2_dev,
"failed to initialize v4l2-m2m device\n");
ret = PTR_ERR(dev->m2m_dev_dec);
goto err_m2m_init_dec;
}
video_set_drvdata(vfd, dev);
platform_set_drvdata(pdev, dev);
#ifdef CONFIG_VIDEOBUF2_CMA_PHYS
dev->vb2 = &jpeg_vb2_cma;
#elif defined(CONFIG_VIDEOBUF2_ION)
dev->vb2 = &jpeg_vb2_ion;
#endif
dev->alloc_ctx = dev->vb2->init(dev);
if (IS_ERR(dev->alloc_ctx)) {
ret = PTR_ERR(dev->alloc_ctx);
goto err_video_reg;
}
#ifdef CONFIG_BUSFREQ_OPP
/* To lock bus frequency in OPP mode */
dev->bus_dev = dev_get("exynos-busfreq");
#endif
dev->watchdog_workqueue = create_singlethread_workqueue(JPEG_NAME);
INIT_WORK(&dev->watchdog_work, jpeg_watchdog_worker);
atomic_set(&dev->watchdog_cnt, 0);
init_timer(&dev->watchdog_timer);
dev->watchdog_timer.data = (unsigned long)dev;
dev->watchdog_timer.function = jpeg_watchdog;
/* clock disable */
clk_disable(dev->clk);
return 0;
err_video_reg:
v4l2_m2m_release(dev->m2m_dev_dec);
err_m2m_init_dec:
video_unregister_device(dev->vfd_dec);
video_device_release(dev->vfd_dec);
err_vd_alloc_dec:
v4l2_m2m_release(dev->m2m_dev_enc);
err_m2m_init_enc:
video_unregister_device(dev->vfd_enc);
video_device_release(dev->vfd_enc);
err_vd_alloc_enc:
v4l2_device_unregister(&dev->v4l2_dev);
err_v4l2:
clk_disable(dev->clk);
clk_put(dev->clk);
err_clk:
free_irq(dev->irq_no, NULL);
err_irq:
iounmap(dev->reg_base);
err_map:
err_region:
kfree(res);
err_res:
mutex_destroy(&dev->lock);
err_setup:
kfree(dev);
err_alloc:
return ret;
}
static int rockchip_vpu_probe(struct platform_device *pdev)
{
const struct of_device_id *match;
struct rockchip_vpu_dev *vpu;
struct resource *res;
int i, ret;
vpu = devm_kzalloc(&pdev->dev, sizeof(*vpu), GFP_KERNEL);
if (!vpu)
return -ENOMEM;
vpu->dev = &pdev->dev;
vpu->pdev = pdev;
mutex_init(&vpu->vpu_mutex);
spin_lock_init(&vpu->irqlock);
match = of_match_node(of_rockchip_vpu_match, pdev->dev.of_node);
vpu->variant = match->data;
INIT_DELAYED_WORK(&vpu->watchdog_work, rockchip_vpu_watchdog);
for (i = 0; i < vpu->variant->num_clocks; i++)
vpu->clocks[i].id = vpu->variant->clk_names[i];
ret = devm_clk_bulk_get(&pdev->dev, vpu->variant->num_clocks,
vpu->clocks);
if (ret)
return ret;
res = platform_get_resource(vpu->pdev, IORESOURCE_MEM, 0);
vpu->base = devm_ioremap_resource(vpu->dev, res);
if (IS_ERR(vpu->base))
return PTR_ERR(vpu->base);
vpu->enc_base = vpu->base + vpu->variant->enc_offset;
ret = dma_set_coherent_mask(vpu->dev, DMA_BIT_MASK(32));
if (ret) {
dev_err(vpu->dev, "Could not set DMA coherent mask.\n");
return ret;
}
if (vpu->variant->vepu_irq) {
int irq;
irq = platform_get_irq_byname(vpu->pdev, "vepu");
if (irq <= 0) {
dev_err(vpu->dev, "Could not get vepu IRQ.\n");
return -ENXIO;
}
ret = devm_request_irq(vpu->dev, irq, vpu->variant->vepu_irq,
0, dev_name(vpu->dev), vpu);
if (ret) {
dev_err(vpu->dev, "Could not request vepu IRQ.\n");
return ret;
}
}
ret = vpu->variant->init(vpu);
if (ret) {
dev_err(&pdev->dev, "Failed to init VPU hardware\n");
return ret;
}
pm_runtime_set_autosuspend_delay(vpu->dev, 100);
pm_runtime_use_autosuspend(vpu->dev);
pm_runtime_enable(vpu->dev);
ret = clk_bulk_prepare(vpu->variant->num_clocks, vpu->clocks);
if (ret) {
dev_err(&pdev->dev, "Failed to prepare clocks\n");
return ret;
}
ret = v4l2_device_register(&pdev->dev, &vpu->v4l2_dev);
if (ret) {
dev_err(&pdev->dev, "Failed to register v4l2 device\n");
goto err_clk_unprepare;
}
platform_set_drvdata(pdev, vpu);
vpu->m2m_dev = v4l2_m2m_init(&vpu_m2m_ops);
if (IS_ERR(vpu->m2m_dev)) {
v4l2_err(&vpu->v4l2_dev, "Failed to init mem2mem device\n");
ret = PTR_ERR(vpu->m2m_dev);
goto err_v4l2_unreg;
}
vpu->mdev.dev = vpu->dev;
strlcpy(vpu->mdev.model, DRIVER_NAME, sizeof(vpu->mdev.model));
media_device_init(&vpu->mdev);
vpu->v4l2_dev.mdev = &vpu->mdev;
ret = rockchip_vpu_video_device_register(vpu);
if (ret) {
dev_err(&pdev->dev, "Failed to register encoder\n");
goto err_m2m_rel;
}
ret = media_device_register(&vpu->mdev);
if (ret) {
v4l2_err(&vpu->v4l2_dev, "Failed to register mem2mem media device\n");
goto err_video_dev_unreg;
}
return 0;
err_video_dev_unreg:
if (vpu->vfd_enc) {
video_unregister_device(vpu->vfd_enc);
video_device_release(vpu->vfd_enc);
}
err_m2m_rel:
v4l2_m2m_release(vpu->m2m_dev);
err_v4l2_unreg:
v4l2_device_unregister(&vpu->v4l2_dev);
err_clk_unprepare:
clk_bulk_unprepare(vpu->variant->num_clocks, vpu->clocks);
pm_runtime_disable(vpu->dev);
return ret;
}
/*
* public functions
*/
struct nxp_video *create_nxp_video(char *name, u32 type,
struct v4l2_device *v4l2_dev, void *vb2_alloc_ctx)
{
int ret;
struct vb2_queue *vbq = NULL;
struct nxp_video *me = kzalloc(sizeof(struct nxp_video), GFP_KERNEL);
int pad_num = 0;
if (!me) {
pr_err("%s: failed to allocate me!!!\n", __func__);
return NULL;
}
snprintf(me->name, sizeof(me->name), "%s", name);
snprintf(me->vdev.name, sizeof(me->vdev.name), "%s", name);
me->type = type;
me->v4l2_dev = v4l2_dev;
me->vb2_alloc_ctx = vb2_alloc_ctx;
/* pad init */
/* TODO */
#if 0
switch (type) {
case NXP_VIDEO_TYPE_CAPTURE:
/**
* capture subdev -> capture ->
* m2m subdev or out subdev
*/
me->pads[0].flags = MEDIA_PAD_FL_SINK;
me->pads[1].flags = MEDIA_PAD_FL_SOURCE;
pad_num = 2;
break;
case NXP_VIDEO_TYPE_OUT:
/**
* out -> out subdev
*/
me->pads[0].flags = MEDIA_PAD_FL_SOURCE;
pad_num = 1;
break;
case NXP_VIDEO_TYPE_M2M:
/**
* capture video -> m2m subdev ->
* m2m video -> out subdev
*/
me->pads[0].flags = MEDIA_PAD_FL_SINK;
me->pads[1].flags = MEDIA_PAD_FL_SOURCE;
pad_num = 2;
break;
default:
pr_err("%s: invalid type(%d)\n", __func__, type);
kfree(me);
return NULL;
}
#else
me->pads[0].flags = MEDIA_PAD_FL_SINK;
me->pads[1].flags = MEDIA_PAD_FL_SOURCE;
pad_num = 2;
#endif
me->vdev.entity.ops = &nxp_media_entity_operations;
ret = media_entity_init(&me->vdev.entity, pad_num, me->pads, 0);
if (ret < 0) {
kfree(me);
return NULL;
}
mutex_init(&me->lock);
me->register_buffer_consumer = _register_buffer_consumer;
me->unregister_buffer_consumer = _unregister_buffer_consumer;
me->vdev.fops = &nxp_video_fops;
me->vdev.ioctl_ops = &nxp_video_ioctl_ops;
me->vdev.v4l2_dev = v4l2_dev;
me->vdev.minor = -1;
me->vdev.vfl_type = VFL_TYPE_GRABBER;
me->vdev.release = video_device_release;
me->vdev.lock = &me->lock;
if (type != NXP_VIDEO_TYPE_M2M) {
vbq = kzalloc(sizeof(*vbq), GFP_KERNEL);
if (!vbq) {
pr_err("%s: failed to allocate vbq\n", __func__);
ret = -ENOMEM;
goto error_vbq_alloc;
}
vbq->type = type == NXP_VIDEO_TYPE_CAPTURE ?
V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE : V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
vbq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
vbq->drv_priv = me;
vbq->ops = &nxp_vb2_ops;
vbq->mem_ops = &vb2_ion_memops;
ret = vb2_queue_init(vbq);
if (ret < 0) {
pr_err("%s: failed to vb2_queue_init()\n", __func__);
goto error_vbq_init;
}
me->vbq = vbq;
} else {
/* m2m */
me->m2m_dev = v4l2_m2m_init(&nxp_m2m_ops);
if (IS_ERR(me->m2m_dev)) {
pr_err("%s: failed to v4l2_m2m_init()\n", __func__);
ret = -ENOMEM;
goto error_vbq_alloc;
}
}
INIT_LIST_HEAD(&me->source_consumer_list);
INIT_LIST_HEAD(&me->sink_consumer_list);
spin_lock_init(&me->lock_consumer);
video_set_drvdata(&me->vdev, me);
pr_debug("%s: success!!!\n", __func__);
return me;
error_vbq_init:
if (vbq)
kfree(vbq);
error_vbq_alloc:
kfree(me);
return NULL;
}
/*
* jpegdma_probe - Dma device probe method.
* @pdev: Pointer Dma platform device.
*/
static int jpegdma_probe(struct platform_device *pdev)
{
struct msm_jpegdma_device *jpegdma;
int ret;
dev_dbg(&pdev->dev, "jpeg v4l2 DMA probed\n");
/* Jpeg dma device struct */
jpegdma = kzalloc(sizeof(struct msm_jpegdma_device), GFP_KERNEL);
if (!jpegdma)
return -ENOMEM;
mutex_init(&jpegdma->lock);
init_completion(&jpegdma->hw_reset_completion);
init_completion(&jpegdma->hw_halt_completion);
jpegdma->dev = &pdev->dev;
/* Get resources */
ret = msm_jpegdma_hw_get_mem_resources(pdev, jpegdma);
if (ret < 0)
goto error_mem_resources;
ret = msm_jpegdma_hw_get_regulators(jpegdma);
if (ret < 0)
goto error_get_regulators;
ret = msm_jpegdma_hw_get_clocks(jpegdma);
if (ret < 0)
goto error_get_clocks;
ret = msm_jpegdma_hw_get_qos(jpegdma);
if (ret < 0)
goto error_qos_get;
ret = msm_jpegdma_hw_get_vbif(jpegdma);
if (ret < 0)
goto error_vbif_get;
ret = msm_jpegdma_hw_get_prefetch(jpegdma);
if (ret < 0)
goto error_prefetch_get;
ret = msm_jpegdma_hw_request_irq(pdev, jpegdma);
if (ret < 0)
goto error_hw_get_request_irq;
ret = msm_jpegdma_hw_get_capabilities(jpegdma);
if (ret < 0)
goto error_hw_get_request_irq;
/* mem2mem device */
jpegdma->m2m_dev = v4l2_m2m_init(&msm_jpegdma_m2m_ops);
if (IS_ERR(jpegdma->m2m_dev)) {
dev_err(&pdev->dev, "Failed to init mem2mem device\n");
ret = PTR_ERR(jpegdma->m2m_dev);
goto error_m2m_init;
}
/* v4l2 device */
ret = v4l2_device_register(&pdev->dev, &jpegdma->v4l2_dev);
if (ret < 0) {
dev_err(&pdev->dev, "Failed to register v4l2 device\n");
goto error_v4l2_register;
}
jpegdma->video.fops = &fd_fops;
jpegdma->video.ioctl_ops = &fd_ioctl_ops;
jpegdma->video.minor = -1;
jpegdma->video.release = video_device_release;
jpegdma->video.v4l2_dev = &jpegdma->v4l2_dev;
jpegdma->video.vfl_dir = VFL_DIR_M2M;
jpegdma->video.vfl_type = VFL_TYPE_GRABBER;
strlcpy(jpegdma->video.name, MSM_JPEGDMA_DRV_NAME,
sizeof(jpegdma->video.name));
ret = video_register_device(&jpegdma->video, VFL_TYPE_GRABBER, -1);
if (ret < 0) {
dev_err(&pdev->dev, "Failed to register video device\n");
goto error_video_register;
}
video_set_drvdata(&jpegdma->video, jpegdma);
platform_set_drvdata(pdev, jpegdma);
dev_dbg(&pdev->dev, "jpeg v4l2 DMA probe success\n");
return 0;
error_video_register:
v4l2_device_unregister(&jpegdma->v4l2_dev);
error_v4l2_register:
v4l2_m2m_release(jpegdma->m2m_dev);
error_m2m_init:
msm_jpegdma_hw_release_irq(jpegdma);
error_hw_get_request_irq:
msm_jpegdma_hw_put_prefetch(jpegdma);
error_prefetch_get:
msm_jpegdma_hw_put_vbif(jpegdma);
error_vbif_get:
msm_jpegdma_hw_put_qos(jpegdma);
error_qos_get:
msm_jpegdma_hw_put_clocks(jpegdma);
error_get_clocks:
msm_jpegdma_hw_put_regulators(jpegdma);
error_get_regulators:
msm_jpegdma_hw_release_mem_resources(jpegdma);
error_mem_resources:
kfree(jpegdma);
return ret;
}
