static int jpeg_hx_remove(struct platform_device *pdev)
{
struct jpeg_dev *dev = platform_get_drvdata(pdev);
del_timer_sync(&dev->watchdog_timer);
flush_workqueue(dev->watchdog_workqueue);
destroy_workqueue(dev->watchdog_workqueue);
v4l2_m2m_release(dev->m2m_dev_enc);
video_unregister_device(dev->vfd_enc);
v4l2_m2m_release(dev->m2m_dev_dec);
video_unregister_device(dev->vfd_dec);
v4l2_device_unregister(&dev->v4l2_dev);
dev->vb2->cleanup(dev->alloc_ctx);
free_irq(dev->irq_no, pdev);
mutex_destroy(&dev->lock);
iounmap(dev->reg_base);
clk_put(dev->clk);
clk_put(dev->sclk_clk);
#ifdef CONFIG_BUSFREQ_OPP
/* lock bus frequency */
dev_unlock(dev->bus_dev, &pdev->dev);
#endif
kfree(dev);
return 0;
}
static int jpeg_remove(struct platform_device *pdev)
{
struct jpeg_dev *dev = platform_get_drvdata(pdev);
del_timer_sync(&dev->watchdog_timer);
flush_workqueue(dev->watchdog_workqueue);
destroy_workqueue(dev->watchdog_workqueue);
v4l2_m2m_release(dev->m2m_dev_enc);
video_unregister_device(dev->vfd_enc);
v4l2_m2m_release(dev->m2m_dev_dec);
video_unregister_device(dev->vfd_dec);
v4l2_device_unregister(&dev->v4l2_dev);
dev->vb2->cleanup(dev->alloc_ctx);
free_irq(dev->irq_no, pdev);
mutex_destroy(&dev->lock);
iounmap(dev->reg_base);
clk_put(dev->clk);
#ifdef CONFIG_PM_RUNTIME
pm_runtime_put_sync(&pdev->dev);
pm_runtime_disable(&pdev->dev);
#endif
kfree(dev);
return 0;
}
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;
}
void gsc_unregister_m2m_device(struct gsc_dev *gsc)
{
if (gsc) {
v4l2_m2m_release(gsc->m2m.m2m_dev);
video_unregister_device(&gsc->vdev);
}
}
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;
}
static void bdisp_unregister_device(struct bdisp_dev *bdisp)
{
if (!bdisp)
return;
if (bdisp->m2m.m2m_dev)
v4l2_m2m_release(bdisp->m2m.m2m_dev);
video_unregister_device(bdisp->m2m.vdev);
}
static void hva_unregister_device(struct hva_dev *hva)
{
if (!hva)
return;
if (hva->m2m_dev)
v4l2_m2m_release(hva->m2m_dev);
video_unregister_device(hva->vdev);
}
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;
}
void release_nxp_video(struct nxp_video *me)
{
mutex_destroy(&me->lock);
media_entity_cleanup(&me->vdev.entity);
if (me->m2m_dev)
v4l2_m2m_release(me->m2m_dev);
if (me->vbq) {
vb2_queue_release(me->vbq);
kfree(me->vbq);
}
kfree(me);
}
void fimc_unregister_m2m_device(struct fimc_dev *fimc)
{
if (!fimc)
return;
if (fimc->m2m.m2m_dev)
v4l2_m2m_release(fimc->m2m.m2m_dev);
if (video_is_registered(&fimc->m2m.vfd)) {
video_unregister_device(&fimc->m2m.vfd);
media_entity_cleanup(&fimc->m2m.vfd.entity);
}
}
void fimc_unregister_m2m_device(struct fimc_dev *fimc)
{
if (!fimc)
return;
if (fimc->m2m.m2m_dev)
v4l2_m2m_release(fimc->m2m.m2m_dev);
if (fimc->m2m.vfd) {
media_entity_cleanup(&fimc->m2m.vfd->entity);
/* Can also be called if video device wasn't registered */
video_unregister_device(fimc->m2m.vfd);
}
}
static int g2d_remove(struct platform_device *pdev)
{
struct g2d_dev *dev = platform_get_drvdata(pdev);
v4l2_info(&dev->v4l2_dev, "Removing " G2D_NAME);
v4l2_m2m_release(dev->m2m_dev);
video_unregister_device(dev->vfd);
v4l2_device_unregister(&dev->v4l2_dev);
vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);
clk_unprepare(dev->gate);
clk_put(dev->gate);
clk_unprepare(dev->clk);
clk_put(dev->clk);
return 0;
}
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 rockchip_vpu_remove(struct platform_device *pdev)
{
struct rockchip_vpu_dev *vpu = platform_get_drvdata(pdev);
v4l2_info(&vpu->v4l2_dev, "Removing %s\n", pdev->name);
media_device_unregister(&vpu->mdev);
v4l2_m2m_unregister_media_controller(vpu->m2m_dev);
v4l2_m2m_release(vpu->m2m_dev);
media_device_cleanup(&vpu->mdev);
if (vpu->vfd_enc) {
video_unregister_device(vpu->vfd_enc);
video_device_release(vpu->vfd_enc);
}
v4l2_device_unregister(&vpu->v4l2_dev);
clk_bulk_unprepare(vpu->variant->num_clocks, vpu->clocks);
pm_runtime_disable(vpu->dev);
return 0;
}
/*
* jpegdma_device_remove - Jpegdma device remove method.
* @pdev: Pointer jpegdma platform device.
*/
static int jpegdma_device_remove(struct platform_device *pdev)
{
struct msm_jpegdma_device *dma;
dma = platform_get_drvdata(pdev);
if (NULL == dma) {
dev_err(&pdev->dev, "Can not get jpeg dma drvdata\n");
return 0;
}
video_unregister_device(&dma->video);
v4l2_device_unregister(&dma->v4l2_dev);
v4l2_m2m_release(dma->m2m_dev);
msm_jpegdma_hw_release_irq(dma);
msm_jpegdma_hw_put_clocks(dma);
msm_jpegdma_hw_put_regulators(dma);
msm_jpegdma_hw_release_mem_resources(dma);
kfree(dma);
return 0;
}
/*
* 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;
}
void gsc_unregister_m2m_device(struct gsc_dev *gsc)
{
if (gsc)
v4l2_m2m_release(gsc->m2m.m2m_dev);
}
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 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 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;
}
