drivers/media/m2m1shot-testdev.c - LeafOS-Devices/android_kernel_samsung_gta4xl - Gitiles

 /*
  * drivers/media/m2m1shot-testdev.c
  *
  * Copyright (C) 2014 Samsung Electronics Co., Ltd.
  *
  * Contact: Cho KyongHo <pullip.cho@samsung.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA
  *
  */

 #include <linux/kernel.h>
 #include <linux/device.h>
 #include <linux/uaccess.h>
 #include <linux/platform_device.h>
 #include <linux/jiffies.h>
 #include <linux/videodev2.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/list.h>
 #include <linux/kthread.h>
 #include <linux/freezer.h>

 #include <media/m2m1shot.h>
 #include <media/m2m1shot-helper.h>

 struct m2m1shot_testdev_drvdata {
 	struct m2m1shot_device *m21dev;
 	struct task_struct *thread;
 	wait_queue_head_t waitqueue;
 	struct list_head task_list;
 	spinlock_t lock;
 };

 #define M2M1SHOT_TESTDEV_IOC_TIMEOUT _IOW('T', 0, unsigned long)

 struct m2m1shot_testdev_fmt {
 	__u32 fmt;
 	const char *fmt_name;
 	__u8 mbpp[3]; /* bytes * 2 per pixel: should be divided by 2 */
 	__u8 planes;
 	__u8 buf_mbpp[3]; /* bytes * 2 per pixel: should be divided by 2 */
 	__u8 buf_planes;
 };

 #define TO_MBPP(bpp) ((bpp) << 2)
 #define TO_MBPPDIV(bpp_diven, bpp_diver) (((bpp_diven) << 2) / (bpp_diver))
 #define TO_BPP(mbpp) ((mbpp) >> 2)

 static struct m2m1shot_testdev_fmt m2m1shot_testdev_fmtlist[] = {
 	{
 		.fmt = V4L2_PIX_FMT_RGB565,
 		.fmt_name = "RGB565",
 		.mbpp = { TO_MBPP(2), 0, 0},
 		.planes = 1,
 		.buf_mbpp = { TO_MBPP(2), 0, 0},
 		.buf_planes = 1,
 	}, {
 		.fmt = V4L2_PIX_FMT_BGR32,
 		.fmt_name = "BGR32",
 		.mbpp = { TO_MBPP(4), 0, 0 },
 		.planes = 1,
 		.buf_mbpp = { TO_MBPP(4), 0, 0 },
 		.buf_planes = 1,
 	}, {
 		.fmt = V4L2_PIX_FMT_RGB32,
 		.fmt_name = "RGB32",
 		.mbpp = { TO_MBPP(4), 0, 0 },
 		.planes = 1,
 		.buf_mbpp = { TO_MBPP(4), 0, 0 },
 		.buf_planes = 1,
 	}, {
 		.fmt = V4L2_PIX_FMT_YUV420,
 		.fmt_name = "YUV4:2:0",
 		.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 4), TO_MBPPDIV(1, 4) },
 		.planes = 3,
 		.buf_mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4),
 				0, 0 },
 		.buf_planes = 1,
 	}, {
 		.fmt = V4L2_PIX_FMT_NV12,
 		.fmt_name = "Y/CbCr4:2:0(NV12)",
 		.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4), 0 },
 		.planes = 2,
 		.buf_mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4),
 				0, 0 },
 		.buf_planes = 1,
 	}, {
 		.fmt = V4L2_PIX_FMT_NV21,
 		.fmt_name = "Y/CrCb4:2:0(NV21)",
 		.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4), 0 },
 		.planes = 2,
 		.buf_mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4),
 				0, 0 },
 		.buf_planes = 1,
 	}, {
 		.fmt = V4L2_PIX_FMT_NV12M,
 		.fmt_name = "Y/CbCr4:2:0(NV12M)",
 		.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4), 0 },
 		.planes = 2,
 		.buf_mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4),
 				0 },
 		.buf_planes = 2,
 	}, {
 		.fmt = V4L2_PIX_FMT_NV21M,
 		.fmt_name = "Y/CrCb4:2:0(NV21M)",
 		.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4), 0 },
 		.planes = 2,
 		.buf_mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4),
 				0 },
 		.buf_planes = 2,
 	}, {
 		.fmt = V4L2_PIX_FMT_YUV422P,
 		.fmt_name = "YUV4:2:2",
 		.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 2), TO_MBPPDIV(1, 2) },
 		.planes = 3,
 		.buf_mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 2) + TO_MBPPDIV(1, 2),
 				0, 0 },
 		.buf_planes = 1,
 	}, {
 		.fmt = V4L2_PIX_FMT_NV16,
 		.fmt_name = "Y/CbCr4:2:2(NV16)",
 		.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 2) + TO_MBPPDIV(1, 2), 0 },
 		.planes = 2,
 		.buf_mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 2) + TO_MBPPDIV(1, 2),
 				0, 0 },
 		.buf_planes = 1,
 	}, {
 		.fmt = V4L2_PIX_FMT_NV61,
 		.fmt_name = "Y/CrCb4:2:2(NV61)",
 		.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 2) + TO_MBPPDIV(1, 2), 0 },
 		.planes = 2,
 		.buf_mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 2) + TO_MBPPDIV(1, 2),
 				0, 0 },
 		.buf_planes = 1,
 	}, {
 		.fmt = V4L2_PIX_FMT_YUYV,
 		.fmt_name = "YUV4:2:2(YUYV)",
 		.mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 2) + TO_MBPPDIV(1, 2),
 				0, 0},
 		.planes = 1,
 		.buf_mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 2) + TO_MBPPDIV(1, 2),
 				0, 0 },
 		.buf_planes = 1,
 	}, {
 		.fmt = V4L2_PIX_FMT_YUV444,
 		.fmt_name = "YUV4:4:4",
 		.mbpp = { TO_MBPP(1), TO_MBPP(1), TO_MBPP(1) },
 		.planes = 3,
 		.buf_mbpp = { TO_MBPP(1) + TO_MBPP(1) + TO_MBPP(1), 0, 0 },
 		.buf_planes = 1,
 	},
 };

 static int m2m1shot_testdev_init_context(struct m2m1shot_context *ctx)
 {
 	ctx->priv = NULL; /* no timeout generated */

 	return 0;
 }

 static int m2m1shot_testdev_free_context(struct m2m1shot_context *ctx)
 {
 	return 0;
 }

 static int m2m1shot_testdev_prepare_format(struct m2m1shot_context *ctx,
 			struct m2m1shot_pix_format *fmt,
 			enum dma_data_direction dir,
 			size_t bytes_used[])
 {
 	size_t i, j;
 	for (i = 0; i < ARRAY_SIZE(m2m1shot_testdev_fmtlist); i++) {
 		if (fmt->fmt == m2m1shot_testdev_fmtlist[i].fmt)
 			break;
 	}

 	if (i == ARRAY_SIZE(m2m1shot_testdev_fmtlist)) {
 		dev_err(ctx->m21dev->dev, "Unknown format %#x\n", fmt->fmt);
 		return -EINVAL;
 	}

 	for (j = 0; j < m2m1shot_testdev_fmtlist[i].buf_planes; j++)
 		bytes_used[j] = TO_BPP(m2m1shot_testdev_fmtlist[i].buf_mbpp[j] *
 					fmt->width * fmt->height);
 	return m2m1shot_testdev_fmtlist[i].buf_planes;
 }

 static int m2m1shot_testdev_prepare_buffer(struct m2m1shot_context *ctx,
 			struct m2m1shot_buffer_dma *dma_buffer,
 			int plane,
 			enum dma_data_direction dir)
 {
 	return m2m1shot_map_dma_buf(ctx->m21dev->dev,
 				&dma_buffer->plane[plane], dir);
 }

 static void m2m1shot_testdev_finish_buffer(struct m2m1shot_context *ctx,
 			struct m2m1shot_buffer_dma *dma_buffer,
 			int plane,
 			enum dma_data_direction dir)
 {
 	m2m1shot_unmap_dma_buf(ctx->m21dev->dev, &dma_buffer->plane[plane], dir);
 }

 struct m2m1shot_testdev_work {
 	struct list_head node;
 	struct m2m1shot_context *ctx;
 	struct m2m1shot_task *task;
 };

 static int m2m1shot_testdev_worker(void *data)
 {
 	struct m2m1shot_testdev_drvdata *drvdata = data;

 	while (true) {
 		struct m2m1shot_testdev_work *work;
 		struct m2m1shot_task *task;

 		wait_event_freezable(drvdata->waitqueue,
 				     !list_empty(&drvdata->task_list));

 		spin_lock(&drvdata->lock);
 		BUG_ON(list_empty(&drvdata->task_list));
 		work = list_first_entry(&drvdata->task_list,
 					struct m2m1shot_testdev_work, node);
 		list_del(&work->node);
 		BUG_ON(!list_empty(&drvdata->task_list));
 		spin_unlock(&drvdata->lock);

 		msleep(20);

 		task = m2m1shot_get_current_task(drvdata->m21dev);
 		BUG_ON(!task);

 		BUG_ON(task != work->task);
 		BUG_ON(task->ctx != work->ctx);

 		kfree(work);

 		m2m1shot_task_finish(drvdata->m21dev, task, true);
 	}

 	return 0;

 }

 static int m2m1shot_testdev_device_run(struct m2m1shot_context *ctx,
 		struct m2m1shot_task *task)
 {
 	struct m2m1shot_testdev_work *work;
 	struct device *dev = ctx->m21dev->dev;
 	struct m2m1shot_testdev_drvdata *drvdata = dev_get_drvdata(dev);

 	if (ctx->priv) /* timeout generated */
 		return 0;

 	work = kmalloc(sizeof(*work), GFP_KERNEL);
 	if (!work) {
 		pr_err("%s: Failed to allocate work struct\n", __func__);
 		return -ENOMEM;
 	}

 	INIT_LIST_HEAD(&work->node);
 	work->ctx = ctx;
 	work->task = task;

 	spin_lock(&drvdata->lock);
 	BUG_ON(!list_empty(&drvdata->task_list));
 	list_add_tail(&work->node, &drvdata->task_list);
 	spin_unlock(&drvdata->lock);

 	if (current != drvdata->thread);
 		wake_up(&drvdata->waitqueue);

 	return 0;
 }

 static void m2m1shot_testdev_timeout_task(struct m2m1shot_context *ctx,
 		struct m2m1shot_task *task)
 {
 	dev_info(ctx->m21dev->dev, "%s: Timeout occurred\n", __func__);
 }

 static long m2m1shot_testdev_ioctl(struct m2m1shot_context *ctx,
 			unsigned int cmd, unsigned long arg)
 {
 	unsigned long timeout;

 	if (cmd != M2M1SHOT_TESTDEV_IOC_TIMEOUT) {
 		dev_err(ctx->m21dev->dev, "%s: Unknown ioctl cmd %#x\n",
 			__func__, cmd);
 		return -ENOSYS;
 	}

 	if (get_user(timeout, (unsigned long __user *)arg)) {
 		dev_err(ctx->m21dev->dev,
 			"%s: Failed to read user data\n", __func__);
 		return -EFAULT;
 	}

 	if (timeout)
 		ctx->priv = (void *)1; /* timeout generated */
 	else
 		ctx->priv = NULL; /* timeout not generated */

 	dev_info(ctx->m21dev->dev, "%s: Timeout geration is %s",
 			__func__, timeout ? "set" : "unset");

 	return 0;
 }

 static const struct m2m1shot_devops m2m1shot_testdev_ops = {
 	.init_context = m2m1shot_testdev_init_context,
 	.free_context = m2m1shot_testdev_free_context,
 	.prepare_format = m2m1shot_testdev_prepare_format,
 	.prepare_buffer = m2m1shot_testdev_prepare_buffer,
 	.finish_buffer = m2m1shot_testdev_finish_buffer,
 	.device_run = m2m1shot_testdev_device_run,
 	.timeout_task = m2m1shot_testdev_timeout_task,
 	.custom_ioctl = m2m1shot_testdev_ioctl,
 };

 static struct platform_device m2m1shot_testdev_pdev = {
 	.name = "m2m1shot_testdev",
 };

 static int m2m1shot_testdev_init(void)
 {
 	int ret = 0;
 	struct m2m1shot_device *m21dev;
 	struct m2m1shot_testdev_drvdata *drvdata;

 	drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL);
 	if (!drvdata) {
 		pr_err("%s: Failed allocate drvdata\n", __func__);
 		return -ENOMEM;
 	}
 	ret = platform_device_register(&m2m1shot_testdev_pdev);
 	if (ret) {
 		pr_err("%s: Failed to register platform device\n", __func__);
 		goto err_register;
 	}

 	m21dev = m2m1shot_create_device(&m2m1shot_testdev_pdev.dev,
 		&m2m1shot_testdev_ops, "testdev", -1, msecs_to_jiffies(500));
 	if (IS_ERR(m21dev)) {
 		pr_err("%s: Failed to create m2m1shot device\n", __func__);
 		ret = PTR_ERR(m21dev);
 		goto err_create;
 	}

 	drvdata->thread = kthread_run(m2m1shot_testdev_worker, drvdata,
 				"%s", "m2m1shot_tesdev_worker");
 	if (IS_ERR(drvdata->thread)) {
 		pr_err("%s: Failed create worker thread\n", __func__);
 		ret = PTR_ERR(drvdata->thread);
 		goto err_worker;
 	}

 	drvdata->m21dev = m21dev;
 	INIT_LIST_HEAD(&drvdata->task_list);
 	spin_lock_init(&drvdata->lock);
 	init_waitqueue_head(&drvdata->waitqueue);

 	dev_set_drvdata(&m2m1shot_testdev_pdev.dev, drvdata);

 	return 0;

 err_worker:
 	m2m1shot_destroy_device(m21dev);
 err_create:
 	platform_device_unregister(&m2m1shot_testdev_pdev);
 err_register:
 	kfree(drvdata);
 	return ret;
 }
 module_init(m2m1shot_testdev_init);
	/*
	* drivers/media/m2m1shot-testdev.c
	*
	* Copyright (C) 2014 Samsung Electronics Co., Ltd.
	*
	* Contact: Cho KyongHo <pullip.cho@samsung.com>
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* version 2 as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
	* 02110-1301 USA
	*
	*/

	#include <linux/kernel.h>
	#include <linux/device.h>
	#include <linux/uaccess.h>
	#include <linux/platform_device.h>
	#include <linux/jiffies.h>
	#include <linux/videodev2.h>
	#include <linux/slab.h>
	#include <linux/delay.h>
	#include <linux/list.h>
	#include <linux/kthread.h>
	#include <linux/freezer.h>

	#include <media/m2m1shot.h>
	#include <media/m2m1shot-helper.h>

	struct m2m1shot_testdev_drvdata {
	struct m2m1shot_device *m21dev;
	struct task_struct *thread;
	wait_queue_head_t waitqueue;
	struct list_head task_list;
	spinlock_t lock;
	};

	#define M2M1SHOT_TESTDEV_IOC_TIMEOUT _IOW('T', 0, unsigned long)

	struct m2m1shot_testdev_fmt {
	__u32 fmt;
	const char *fmt_name;
	__u8 mbpp[3]; /* bytes * 2 per pixel: should be divided by 2 */
	__u8 planes;
	__u8 buf_mbpp[3]; /* bytes * 2 per pixel: should be divided by 2 */
	__u8 buf_planes;
	};

	#define TO_MBPP(bpp) ((bpp) << 2)
	#define TO_MBPPDIV(bpp_diven, bpp_diver) (((bpp_diven) << 2) / (bpp_diver))
	#define TO_BPP(mbpp) ((mbpp) >> 2)

	static struct m2m1shot_testdev_fmt m2m1shot_testdev_fmtlist[] = {
	{
	.fmt = V4L2_PIX_FMT_RGB565,
	.fmt_name = "RGB565",
	.mbpp = { TO_MBPP(2), 0, 0},
	.planes = 1,
	.buf_mbpp = { TO_MBPP(2), 0, 0},
	.buf_planes = 1,
	}, {
	.fmt = V4L2_PIX_FMT_BGR32,
	.fmt_name = "BGR32",
	.mbpp = { TO_MBPP(4), 0, 0 },
	.planes = 1,
	.buf_mbpp = { TO_MBPP(4), 0, 0 },
	.buf_planes = 1,
	}, {
	.fmt = V4L2_PIX_FMT_RGB32,
	.fmt_name = "RGB32",
	.mbpp = { TO_MBPP(4), 0, 0 },
	.planes = 1,
	.buf_mbpp = { TO_MBPP(4), 0, 0 },
	.buf_planes = 1,
	}, {
	.fmt = V4L2_PIX_FMT_YUV420,
	.fmt_name = "YUV4:2:0",
	.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 4), TO_MBPPDIV(1, 4) },
	.planes = 3,
	.buf_mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4),
	0, 0 },
	.buf_planes = 1,
	}, {
	.fmt = V4L2_PIX_FMT_NV12,
	.fmt_name = "Y/CbCr4:2:0(NV12)",
	.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4), 0 },
	.planes = 2,
	.buf_mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4),
	0, 0 },
	.buf_planes = 1,
	}, {
	.fmt = V4L2_PIX_FMT_NV21,
	.fmt_name = "Y/CrCb4:2:0(NV21)",
	.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4), 0 },
	.planes = 2,
	.buf_mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4),
	0, 0 },
	.buf_planes = 1,
	}, {
	.fmt = V4L2_PIX_FMT_NV12M,
	.fmt_name = "Y/CbCr4:2:0(NV12M)",
	.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4), 0 },
	.planes = 2,
	.buf_mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4),
	0 },
	.buf_planes = 2,
	}, {
	.fmt = V4L2_PIX_FMT_NV21M,
	.fmt_name = "Y/CrCb4:2:0(NV21M)",
	.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4), 0 },
	.planes = 2,
	.buf_mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 4) + TO_MBPPDIV(1, 4),
	0 },
	.buf_planes = 2,
	}, {
	.fmt = V4L2_PIX_FMT_YUV422P,
	.fmt_name = "YUV4:2:2",
	.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 2), TO_MBPPDIV(1, 2) },
	.planes = 3,
	.buf_mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 2) + TO_MBPPDIV(1, 2),
	0, 0 },
	.buf_planes = 1,
	}, {
	.fmt = V4L2_PIX_FMT_NV16,
	.fmt_name = "Y/CbCr4:2:2(NV16)",
	.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 2) + TO_MBPPDIV(1, 2), 0 },
	.planes = 2,
	.buf_mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 2) + TO_MBPPDIV(1, 2),
	0, 0 },
	.buf_planes = 1,
	}, {
	.fmt = V4L2_PIX_FMT_NV61,
	.fmt_name = "Y/CrCb4:2:2(NV61)",
	.mbpp = { TO_MBPP(1), TO_MBPPDIV(1, 2) + TO_MBPPDIV(1, 2), 0 },
	.planes = 2,
	.buf_mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 2) + TO_MBPPDIV(1, 2),
	0, 0 },
	.buf_planes = 1,
	}, {
	.fmt = V4L2_PIX_FMT_YUYV,
	.fmt_name = "YUV4:2:2(YUYV)",
	.mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 2) + TO_MBPPDIV(1, 2),
	0, 0},
	.planes = 1,
	.buf_mbpp = { TO_MBPP(1) + TO_MBPPDIV(1, 2) + TO_MBPPDIV(1, 2),
	0, 0 },
	.buf_planes = 1,
	}, {
	.fmt = V4L2_PIX_FMT_YUV444,
	.fmt_name = "YUV4:4:4",
	.mbpp = { TO_MBPP(1), TO_MBPP(1), TO_MBPP(1) },
	.planes = 3,
	.buf_mbpp = { TO_MBPP(1) + TO_MBPP(1) + TO_MBPP(1), 0, 0 },
	.buf_planes = 1,
	},
	};

	static int m2m1shot_testdev_init_context(struct m2m1shot_context *ctx)
	{
	ctx->priv = NULL; /* no timeout generated */

	return 0;
	}

	static int m2m1shot_testdev_free_context(struct m2m1shot_context *ctx)
	{
	return 0;
	}

	static int m2m1shot_testdev_prepare_format(struct m2m1shot_context *ctx,
	struct m2m1shot_pix_format *fmt,
	enum dma_data_direction dir,
	size_t bytes_used[])
	{
	size_t i, j;
	for (i = 0; i < ARRAY_SIZE(m2m1shot_testdev_fmtlist); i++) {
	if (fmt->fmt == m2m1shot_testdev_fmtlist[i].fmt)
	break;
	}

	if (i == ARRAY_SIZE(m2m1shot_testdev_fmtlist)) {
	dev_err(ctx->m21dev->dev, "Unknown format %#x\n", fmt->fmt);
	return -EINVAL;
	}

	for (j = 0; j < m2m1shot_testdev_fmtlist[i].buf_planes; j++)
	bytes_used[j] = TO_BPP(m2m1shot_testdev_fmtlist[i].buf_mbpp[j] *
	fmt->width * fmt->height);
	return m2m1shot_testdev_fmtlist[i].buf_planes;
	}

	static int m2m1shot_testdev_prepare_buffer(struct m2m1shot_context *ctx,
	struct m2m1shot_buffer_dma *dma_buffer,
	int plane,
	enum dma_data_direction dir)
	{
	return m2m1shot_map_dma_buf(ctx->m21dev->dev,
	&dma_buffer->plane[plane], dir);
	}

	static void m2m1shot_testdev_finish_buffer(struct m2m1shot_context *ctx,
	struct m2m1shot_buffer_dma *dma_buffer,
	int plane,
	enum dma_data_direction dir)
	{
	m2m1shot_unmap_dma_buf(ctx->m21dev->dev, &dma_buffer->plane[plane], dir);
	}

	struct m2m1shot_testdev_work {
	struct list_head node;
	struct m2m1shot_context *ctx;
	struct m2m1shot_task *task;
	};

	static int m2m1shot_testdev_worker(void *data)
	{
	struct m2m1shot_testdev_drvdata *drvdata = data;

	while (true) {
	struct m2m1shot_testdev_work *work;
	struct m2m1shot_task *task;

	wait_event_freezable(drvdata->waitqueue,
	!list_empty(&drvdata->task_list));

	spin_lock(&drvdata->lock);
	BUG_ON(list_empty(&drvdata->task_list));
	work = list_first_entry(&drvdata->task_list,
	struct m2m1shot_testdev_work, node);
	list_del(&work->node);
	BUG_ON(!list_empty(&drvdata->task_list));
	spin_unlock(&drvdata->lock);

	msleep(20);

	task = m2m1shot_get_current_task(drvdata->m21dev);
	BUG_ON(!task);

	BUG_ON(task != work->task);
	BUG_ON(task->ctx != work->ctx);

	kfree(work);

	m2m1shot_task_finish(drvdata->m21dev, task, true);
	}

	return 0;

	}

	static int m2m1shot_testdev_device_run(struct m2m1shot_context *ctx,
	struct m2m1shot_task *task)
	{
	struct m2m1shot_testdev_work *work;
	struct device *dev = ctx->m21dev->dev;
	struct m2m1shot_testdev_drvdata *drvdata = dev_get_drvdata(dev);

	if (ctx->priv) /* timeout generated */
	return 0;

	work = kmalloc(sizeof(*work), GFP_KERNEL);
	if (!work) {
	pr_err("%s: Failed to allocate work struct\n", __func__);
	return -ENOMEM;
	}

	INIT_LIST_HEAD(&work->node);
	work->ctx = ctx;
	work->task = task;

	spin_lock(&drvdata->lock);
	BUG_ON(!list_empty(&drvdata->task_list));
	list_add_tail(&work->node, &drvdata->task_list);
	spin_unlock(&drvdata->lock);

	if (current != drvdata->thread);
	wake_up(&drvdata->waitqueue);

	return 0;
	}

	static void m2m1shot_testdev_timeout_task(struct m2m1shot_context *ctx,
	struct m2m1shot_task *task)
	{
	dev_info(ctx->m21dev->dev, "%s: Timeout occurred\n", __func__);
	}

	static long m2m1shot_testdev_ioctl(struct m2m1shot_context *ctx,
	unsigned int cmd, unsigned long arg)
	{
	unsigned long timeout;

	if (cmd != M2M1SHOT_TESTDEV_IOC_TIMEOUT) {
	dev_err(ctx->m21dev->dev, "%s: Unknown ioctl cmd %#x\n",
	__func__, cmd);
	return -ENOSYS;
	}

	if (get_user(timeout, (unsigned long __user *)arg)) {
	dev_err(ctx->m21dev->dev,
	"%s: Failed to read user data\n", __func__);
	return -EFAULT;
	}

	if (timeout)
	ctx->priv = (void )1; / timeout generated */
	else
	ctx->priv = NULL; /* timeout not generated */

	dev_info(ctx->m21dev->dev, "%s: Timeout geration is %s",
	__func__, timeout ? "set" : "unset");

	return 0;
	}

	static const struct m2m1shot_devops m2m1shot_testdev_ops = {
	.init_context = m2m1shot_testdev_init_context,
	.free_context = m2m1shot_testdev_free_context,
	.prepare_format = m2m1shot_testdev_prepare_format,
	.prepare_buffer = m2m1shot_testdev_prepare_buffer,
	.finish_buffer = m2m1shot_testdev_finish_buffer,
	.device_run = m2m1shot_testdev_device_run,
	.timeout_task = m2m1shot_testdev_timeout_task,
	.custom_ioctl = m2m1shot_testdev_ioctl,
	};

	static struct platform_device m2m1shot_testdev_pdev = {
	.name = "m2m1shot_testdev",
	};

	static int m2m1shot_testdev_init(void)
	{
	int ret = 0;
	struct m2m1shot_device *m21dev;
	struct m2m1shot_testdev_drvdata *drvdata;

	drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL);
	if (!drvdata) {
	pr_err("%s: Failed allocate drvdata\n", __func__);
	return -ENOMEM;
	}
	ret = platform_device_register(&m2m1shot_testdev_pdev);
	if (ret) {
	pr_err("%s: Failed to register platform device\n", __func__);
	goto err_register;
	}

	m21dev = m2m1shot_create_device(&m2m1shot_testdev_pdev.dev,
	&m2m1shot_testdev_ops, "testdev", -1, msecs_to_jiffies(500));
	if (IS_ERR(m21dev)) {
	pr_err("%s: Failed to create m2m1shot device\n", __func__);
	ret = PTR_ERR(m21dev);
	goto err_create;
	}

	drvdata->thread = kthread_run(m2m1shot_testdev_worker, drvdata,
	"%s", "m2m1shot_tesdev_worker");
	if (IS_ERR(drvdata->thread)) {
	pr_err("%s: Failed create worker thread\n", __func__);
	ret = PTR_ERR(drvdata->thread);
	goto err_worker;
	}

	drvdata->m21dev = m21dev;
	INIT_LIST_HEAD(&drvdata->task_list);
	spin_lock_init(&drvdata->lock);
	init_waitqueue_head(&drvdata->waitqueue);

	dev_set_drvdata(&m2m1shot_testdev_pdev.dev, drvdata);

	return 0;

	err_worker:
	m2m1shot_destroy_device(m21dev);
	err_create:
	platform_device_unregister(&m2m1shot_testdev_pdev);
	err_register:
	kfree(drvdata);
	return ret;
	}
	module_init(m2m1shot_testdev_init);