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; }