static long fimg2d_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
int ret = 0;
struct fimg2d_context *ctx;
struct fimg2d_platdata *pdata;
union {
struct fimg2d_blit *blit;
struct fimg2d_version ver;
} u;
ctx = file->private_data;
if (!ctx) {
printk(KERN_ERR "[%s] missing ctx\n", __func__);
return -EFAULT;
}
switch (cmd) {
case FIMG2D_BITBLT_BLIT:
fimg2d_debug("FIMG2D_BITBLT_BLIT ctx: %p\n", ctx);
u.blit = (struct fimg2d_blit *)arg;
ret = fimg2d_add_command(info, ctx, u.blit);
if (!ret)
fimg2d_request_bitblt(ctx);
#ifdef PERF_PROFILE
perf_print(ctx, u.blit->seq_no);
perf_clear(ctx);
#endif
break;
case FIMG2D_BITBLT_SYNC:
fimg2d_debug("FIMG2D_BITBLT_SYNC ctx: %p\n", ctx);
/* FIXME: */
break;
case FIMG2D_BITBLT_VERSION:
fimg2d_debug("FIMG2D_BITBLT_VERSION ctx: %p\n", ctx);
pdata = to_fimg2d_plat(info->dev);
u.ver.hw = pdata->hw_ver;
u.ver.sw = 0;
fimg2d_debug("fimg2d version, hw: 0x%x sw: 0x%x\n", u.ver.hw, u.ver.sw);
if (copy_to_user((void *)arg, &u.ver, sizeof(u.ver)))
return -EFAULT;
break;
default:
printk(KERN_ERR "[%s] unknown ioctl\n", __func__);
ret = -EFAULT;
break;
}
return ret;
}
static long fimg2d_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
int ret = 0;
struct fimg2d_context *ctx;
struct mm_struct *mm;
ctx = file->private_data;
switch (cmd) {
case FIMG2D_BITBLT_BLIT:
mm = get_task_mm(current);
if(!mm) {
fimg2d_err("no mm for ctx\n");
return -ENXIO;
}
fimg2d_clk_on(ctrl);
g2d_lock(&ctrl->drvlock);
ctx->mm = mm;
if (atomic_read(&ctrl->drvact) ||
atomic_read(&ctrl->suspended)) {
fimg2d_err("driver is unavailable, do sw fallback\n");
g2d_unlock(&ctrl->drvlock);
fimg2d_clk_off(ctrl);
mmput(mm);
return -EPERM;
}
ret = fimg2d_add_command(ctrl, ctx, (struct fimg2d_blit __user *)arg);
if (ret) {
fimg2d_err("add command not allowed.\n");
g2d_unlock(&ctrl->drvlock);
fimg2d_clk_off(ctrl);
mmput(mm);
return ret;
}
ret = fimg2d_request_bitblt(ctrl, ctx);
if (ret) {
fimg2d_err("request bitblit not allowed.\n");
g2d_unlock(&ctrl->drvlock);
fimg2d_clk_off(ctrl);
mmput(mm);
return -EBUSY;
}
g2d_unlock(&ctrl->drvlock);
fimg2d_clk_off(ctrl);
mmput(mm);
break;
case FIMG2D_BITBLT_VERSION:
{
struct fimg2d_version ver;
struct fimg2d_platdata *pdata;
pdata = to_fimg2d_plat(ctrl->dev);
ver.hw = pdata->hw_ver;
ver.sw = 0;
fimg2d_info("version info. hw(0x%x), sw(0x%x)\n",
ver.hw, ver.sw);
if (copy_to_user((void *)arg, &ver, sizeof(ver)))
return -EFAULT;
break;
}
case FIMG2D_BITBLT_ACTIVATE:
{
enum driver_act act;
if (copy_from_user(&act, (void *)arg, sizeof(act)))
return -EFAULT;
g2d_lock(&ctrl->drvlock);
atomic_set(&ctrl->drvact, act);
if (act == DRV_ACT)
fimg2d_info("fimg2d driver is activated\n");
else
fimg2d_info("fimg2d driver is deactivated\n");
g2d_unlock(&ctrl->drvlock);
break;
}
default:
fimg2d_err("unknown ioctl\n");
ret = -EFAULT;
break;
}
return ret;
}
static long fimg2d_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
int ret = 0;
struct fimg2d_context *ctx;
struct mm_struct *mm;
struct fimg2d_dma *usr_dst;
ctx = file->private_data;
switch (cmd) {
case FIMG2D_BITBLT_BLIT:
mm = get_task_mm(current);
if (!mm) {
fimg2d_err("no mm for ctx\n");
return -ENXIO;
}
g2d_lock(&ctrl->drvlock);
ctx->mm = mm;
if (atomic_read(&ctrl->drvact) ||
atomic_read(&ctrl->suspended)) {
fimg2d_err("driver is unavailable, do sw fallback\n");
g2d_unlock(&ctrl->drvlock);
mmput(mm);
return -EPERM;
}
ret = fimg2d_add_command(ctrl, ctx, (struct fimg2d_blit __user *)arg);
if (ret) {
fimg2d_err("add command not allowed.\n");
g2d_unlock(&ctrl->drvlock);
mmput(mm);
return ret;
}
fimg2d_pm_qos_update(ctrl, FIMG2D_QOS_ON);
usr_dst = kzalloc(sizeof(struct fimg2d_dma), GFP_KERNEL);
if (!usr_dst) {
fimg2d_err("failed to allocate memory for fimg2d_dma\n");
g2d_unlock(&ctrl->drvlock);
mmput(mm);
return -ENOMEM;
}
ret = store_user_dst((struct fimg2d_blit __user *)arg, usr_dst);
if (ret) {
fimg2d_err("store_user_dst() not allowed.\n");
g2d_unlock(&ctrl->drvlock);
kfree(usr_dst);
mmput(mm);
return ret;
}
ret = fimg2d_request_bitblt(ctrl, ctx);
if (ret) {
fimg2d_info("request bitblit not allowed, "
"so passing to s/w fallback.\n");
g2d_unlock(&ctrl->drvlock);
kfree(usr_dst);
mmput(mm);
return -EBUSY;
}
g2d_unlock(&ctrl->drvlock);
fimg2d_debug("addr : %p, size : %zd\n",
(void *)usr_dst->addr, usr_dst->size);
#ifndef CCI_SNOOP
fimg2d_dma_unsync_inner(usr_dst->addr,
usr_dst->size, DMA_FROM_DEVICE);
#endif
kfree(usr_dst);
mmput(mm);
break;
case FIMG2D_BITBLT_VERSION:
{
struct fimg2d_version ver;
struct fimg2d_platdata *pdata;
#ifdef CONFIG_OF
pdata = ctrl->pdata;
#else
pdata = to_fimg2d_plat(ctrl->dev);
#endif
ver.hw = pdata->hw_ver;
ver.sw = 0;
fimg2d_info("version info. hw(0x%x), sw(0x%x)\n",
ver.hw, ver.sw);
if (copy_to_user((void *)arg, &ver, sizeof(ver)))
return -EFAULT;
break;
}
case FIMG2D_BITBLT_ACTIVATE:
{
enum driver_act act;
if (copy_from_user(&act, (void *)arg, sizeof(act)))
return -EFAULT;
g2d_lock(&ctrl->drvlock);
atomic_set(&ctrl->drvact, act);
if (act == DRV_ACT) {
fimg2d_power_control(ctrl, FIMG2D_PW_OFF);
fimg2d_info("fimg2d driver is activated\n");
} else {
fimg2d_power_control(ctrl, FIMG2D_PW_ON);
fimg2d_info("fimg2d driver is deactivated\n");
}
g2d_unlock(&ctrl->drvlock);
break;
}
default:
fimg2d_err("unknown ioctl\n");
ret = -EFAULT;
break;
}
return ret;
}
static long fimg2d_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
int ret = 0;
struct fimg2d_context *ctx;
struct fimg2d_platdata *pdata;
struct fimg2d_blit blit;
struct fimg2d_version ver;
struct fimg2d_image dst;
ctx = file->private_data;
if (!ctx) {
printk(KERN_ERR "[%s] missing ctx\n", __func__);
return -EFAULT;
}
switch (cmd) {
case FIMG2D_BITBLT_BLIT:
if (info->secure)
return -EFAULT;
if (copy_from_user(&blit, (void *)arg, sizeof(blit)))
return -EFAULT;
if (blit.dst)
if (copy_from_user(&dst, (void *)blit.dst, sizeof(dst)))
return -EFAULT;
#ifdef CONFIG_BUSFREQ_OPP
#if defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412)
dev_lock(info->bus_dev, info->dev, 160160);
#endif
#endif
if ((blit.dst) && (dst.addr.type == ADDR_USER))
if (!down_write_trylock(&page_alloc_slow_rwsem))
ret = -EAGAIN;
if (ret != -EAGAIN)
ret = fimg2d_add_command(info, ctx, &blit, dst.addr.type);
if (!ret) {
fimg2d_request_bitblt(ctx);
}
#ifdef PERF_PROFILE
perf_print(ctx, blit.seq_no);
perf_clear(ctx);
#endif
if ((blit.dst) && (dst.addr.type == ADDR_USER) && ret != -EAGAIN)
up_write(&page_alloc_slow_rwsem);
#ifdef CONFIG_BUSFREQ_OPP
#if defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412)
dev_unlock(info->bus_dev, info->dev);
#endif
#endif
break;
case FIMG2D_BITBLT_SYNC:
fimg2d_debug("FIMG2D_BITBLT_SYNC ctx: %p\n", ctx);
/* FIXME: */
break;
case FIMG2D_BITBLT_VERSION:
pdata = to_fimg2d_plat(info->dev);
ver.hw = pdata->hw_ver;
ver.sw = 0;
fimg2d_debug("fimg2d version, hw: 0x%x sw: 0x%x\n",
ver.hw, ver.sw);
if (copy_to_user((void *)arg, &ver, sizeof(ver)))
return -EFAULT;
break;
case FIMG2D_BITBLT_SECURE:
if (copy_from_user(&info->secure,
(unsigned int *)arg,
sizeof(unsigned int))) {
printk(KERN_ERR
"[%s] failed to FIMG2D_BITBLT_SECURE: copy_from_user error\n\n",
__func__);
return -EFAULT;
}
while (1) {
if (fimg2d_queue_is_empty(&info->cmd_q))
break;
mdelay(2);
}
break;
default:
printk(KERN_ERR "[%s] unknown ioctl\n", __func__);
ret = -EFAULT;
break;
}
return ret;
}
