void *g2d_ion_init(struct g2d_dev *g2d, bool is_use_cci)
{
long flags = 0;
#if defined(CONFIG_FIMG2D_CCI_SNOOP)
if (is_use_cci)
flags = (VB2ION_CTX_COHERENT | VB2ION_CTX_VMCONTIG
| VB2ION_CTX_IOMMU | VB2ION_CTX_UNCACHED);
else
flags = (VB2ION_CTX_VMCONTIG | VB2ION_CTX_IOMMU
| VB2ION_CTX_UNCACHED);
#else
flags = (VB2ION_CTX_VMCONTIG | VB2ION_CTX_IOMMU | VB2ION_CTX_UNCACHED);
#endif
return vb2_ion_create_context(g2d->dev, SZ_4K, flags);
}
static void *jpeg_ion_init(struct jpeg_dev *dev)
{
return vb2_ion_create_context(&dev->plat_dev->dev, SZ_8K,
VB2ION_CTX_VMCONTIG | VB2ION_CTX_IOMMU);
}
static void *fimc_is_ion_init(struct platform_device *pdev)
{
return vb2_ion_create_context(&pdev->dev, SZ_4K,
VB2ION_CTX_IOMMU | VB2ION_CTX_VMCONTIG);
}
void *gsc_ion_init(struct gsc_dev *gsc)
{
return vb2_ion_create_context(&gsc->pdev->dev, SZ_4K,
VB2ION_CTX_VMCONTIG | VB2ION_CTX_IOMMU | VB2ION_CTX_UNCACHED);
}
static void *fimc_is_ion_init(struct fimc_is_dev *isp)
{
return vb2_ion_create_context(&isp->pdev->dev, SZ_4K,
VB2ION_CTX_IOMMU | VB2ION_CTX_VMCONTIG);
}
static int __devinit nxp_v4l2_probe(struct platform_device *pdev)
{
struct v4l2_device *v4l2_dev;
struct nxp_v4l2 *nxp_v4l2;
struct nxp_v4l2_platformdata *pdata;
#ifdef CONFIG_VIDEO_NXP_CAPTURE
struct nxp_capture_platformdata *capture_pdata;
struct nxp_capture *capture;
int i;
#endif
#ifdef CONFIG_NXP_M2M_SCALER
struct nxp_scaler *scaler;
#endif
#ifdef CONFIG_LOOPBACK_SENSOR_DRIVER
struct nxp_loopback_sensor *loopback_sensor = NULL;
#endif
int ret;
pr_debug("%s entered\n", __func__);
pdata = pdev->dev.platform_data;
if (!pdata) {
dev_err(&pdev->dev, "can't get platformdata\n");
return -EINVAL;
}
nxp_v4l2 = kzalloc(sizeof(*nxp_v4l2), GFP_KERNEL);
if (!nxp_v4l2) {
pr_err("%s error: fail to kzalloc(size %d)\n", __func__, sizeof(struct nxp_v4l2));
return -ENOMEM;
}
nxp_v4l2->pdev = pdev;
nxp_v4l2->pdata = pdata;
snprintf(nxp_v4l2->media_dev.model, sizeof(nxp_v4l2->media_dev.model), "%s",
dev_name(&pdev->dev));
nxp_v4l2->media_dev.dev = &pdev->dev;
v4l2_dev = &nxp_v4l2->v4l2_dev;
v4l2_dev->mdev = &nxp_v4l2->media_dev;
snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s",
dev_name(&pdev->dev));
/* alloc context : use uncached area */
nxp_v4l2->alloc_ctx =
vb2_ion_create_context(&pdev->dev, SZ_4K, VB2ION_CTX_UNCACHED);
if (!nxp_v4l2->alloc_ctx) {
pr_err("%s: failed to ion alloc context\n", __func__);
ret = -ENOMEM;
goto err_alloc_ctx;
}
ret = v4l2_device_register(&pdev->dev, &nxp_v4l2->v4l2_dev);
if (ret < 0) {
pr_err("%s: failed to register v4l2_device: %d\n", __func__, ret);
goto err_v4l2_reg;
}
ret = media_device_register(&nxp_v4l2->media_dev);
if (ret < 0) {
pr_err("%s: failed to register media_device: %d\n", __func__, ret);
goto err_media_reg;
}
__me = nxp_v4l2;
#ifdef CONFIG_LOOPBACK_SENSOR_DRIVER
loopback_sensor = create_nxp_loopback_sensor(pdata->captures);
if (!loopback_sensor) {
pr_err("%s: failed to create_nxp_loopback_sensor()\n", __func__);
ret = -EINVAL;
goto err_loopback_sensor_create;
}
ret = register_nxp_loopback_sensor(loopback_sensor);
if (ret < 0) {
pr_err("%s: failed to register_nxp_loopback_sensor()\n", __func__);
goto err_loopback_sensor_create;
}
nxp_v4l2->loopback_sensor = loopback_sensor;
#endif
#ifdef CONFIG_VIDEO_NXP_CAPTURE
/* capture */
for (capture_pdata = pdata->captures, i = 0;
capture_pdata->sensor;
capture_pdata++, i++) {
/* TODO : psw0523 test for module index problem !!! */
/* capture = create_nxp_capture(i, capture_pdata); */
capture = create_nxp_capture(i, capture_pdata->module, capture_pdata);
if (!capture) {
pr_err("%s: failed to %dth create_nxp_capture()\n", __func__, i);
ret = -EINVAL;
goto err_capture_create;
}
ret = register_nxp_capture(capture);
if (ret < 0) {
pr_err("%s: failed to %dth register_nxp_capture()\n", __func__, i);
goto err_capture_create;
}
nxp_v4l2->capture[i] = capture;
}
#endif
#ifdef CONFIG_NXP_M2M_SCALER
/* m2m */
scaler = create_nxp_scaler();
if (!scaler) {
pr_err("%s: failed to create_nxp_scaler()\n", __func__);
ret = -ENOMEM;
#ifdef CONFIG_VIDEO_NXP_CAPTURE
goto err_capture_create;
#else
goto err_media_reg;
#endif
}
ret = register_nxp_scaler(scaler);
if (ret < 0) {
pr_err("%s: failed to nxp_scaler_register()\n", __func__);
goto err_register_scaler;
}
nxp_v4l2->scaler = scaler;
#endif
#ifdef CONFIG_VIDEO_NXP_OUT
/* out */
nxp_v4l2->out = create_nxp_out(pdata->out);
if (!nxp_v4l2->out) {
pr_err("%s: failed to create_nxp_out()\n", __func__);
goto err_create_out;
}
ret = register_nxp_out(nxp_v4l2->out);
if (ret < 0) {
pr_err("%s: failed to register_nxp_out()\n", __func__);
goto err_register_out;
}
#endif
ret = v4l2_device_register_subdev_nodes(&nxp_v4l2->v4l2_dev);
if (ret < 0) {
pr_err("%s: failed to v4l2_device_register_subdev_nodes()\n", __func__);
goto err_register_out_subdev;
}
platform_set_drvdata(pdev, nxp_v4l2);
// printk("%s success!!!\n", __func__);
return 0;
err_register_out_subdev:
#ifdef CONFIG_VIDEO_NXP_OUT
unregister_nxp_out(nxp_v4l2->out);
err_register_out:
release_nxp_out(nxp_v4l2->out);
err_create_out:
#endif
#ifdef CONFIG_NXP_M2M_SCALER
unregister_nxp_scaler(scaler);
err_register_scaler:
release_nxp_scaler(scaler);
#endif
#ifdef CONFIG_VIDEO_NXP_CAPTURE
err_capture_create:
for (i = 0; i < NXP_MAX_CAPTURE_NUM; ++i) {
capture = nxp_v4l2->capture[i];
if (capture) {
unregister_nxp_capture(capture);
release_nxp_capture(capture);
}
}
media_device_unregister(&nxp_v4l2->media_dev);
#endif
#ifdef CONFIG_LOOPBACK_SENSOR_DRIVER
err_loopback_sensor_create:
if( loopback_sensor )
{
unregister_nxp_loopback_sensor(loopback_sensor);
release_nxp_loopback_sensor(loopback_sensor);
}
#endif
err_media_reg:
v4l2_device_unregister(&nxp_v4l2->v4l2_dev);
err_v4l2_reg:
vb2_ion_destroy_context(nxp_v4l2->alloc_ctx);
err_alloc_ctx:
kfree(nxp_v4l2);
__me = NULL;
return ret;
}
