391 lines
10 KiB
C
Executable File
391 lines
10 KiB
C
Executable File
/*
|
|
* 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);
|