static void fimc_is_scc_buffer_queue(struct vb2_buffer *vb)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = vb->vb2_queue->drv_priv;
struct fimc_is_queue *queue;
struct fimc_is_device_ischain *device;
struct fimc_is_subdev *subdev;
BUG_ON(!vctx);
BUG_ON(!GET_DEVICE(vctx));
#ifdef DBG_STREAMING
mdbgv_scc("%s\n", vctx, __func__);
#endif
device = GET_DEVICE(vctx);
queue = GET_QUEUE(vctx);
subdev = &device->scc;
ret = fimc_is_queue_buffer_queue(queue, vb);
if (ret) {
merr("fimc_is_queue_buffer_queue is fail(%d)", device, ret);
return;
}
ret = fimc_is_subdev_buffer_queue(subdev, vb->v4l2_buf.index);
if (ret) {
merr("fimc_is_subdev_buffer_queue is fail(%d)", device, ret);
return;
}
}
static int fimc_is_scc_queue_setup(struct vb2_queue *vbq,
const struct v4l2_format *fmt,
unsigned int *num_buffers,
unsigned int *num_planes, unsigned int sizes[],
void *allocators[])
{
int ret = 0;
struct fimc_is_video_ctx *vctx = vbq->drv_priv;
struct fimc_is_video *video;
struct fimc_is_queue *queue;
BUG_ON(!vctx);
BUG_ON(!vctx->video);
mdbgv_scc("%s\n", vctx, __func__);
video = GET_VIDEO(vctx);
queue = GET_QUEUE(vctx);
ret = fimc_is_queue_setup(queue,
video->alloc_ctx,
num_planes,
sizes,
allocators);
if (ret)
merr("fimc_is_queue_setup is fail(%d)", vctx, ret);
return ret;
}
static int fimc_is_scc_start_streaming(struct vb2_queue *vbq,
unsigned int count)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = vbq->drv_priv;
struct fimc_is_queue *queue;
struct fimc_is_device_ischain *device;
BUG_ON(!vctx);
BUG_ON(!GET_DEVICE(vctx));
mdbgv_scc("%s\n", vctx, __func__);
device = GET_DEVICE(vctx);
queue = GET_QUEUE(vctx);
ret = fimc_is_queue_start_streaming(queue, device);
if (ret) {
merr("fimc_is_queue_start_streaming is fail(%d)", device, ret);
goto p_err;
}
p_err:
return ret;
}
static int fimc_is_scc_video_g_ctrl(struct file *file, void *priv,
struct v4l2_control *ctrl)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = file->private_data;
struct fimc_is_framemgr *framemgr;
BUG_ON(!vctx);
BUG_ON(!ctrl);
mdbgv_scc("%s\n", vctx, __func__);
framemgr = GET_FRAMEMGR(vctx);
switch (ctrl->id) {
case V4L2_CID_IS_G_COMPLETES:
ctrl->value = framemgr->queued_count[FS_COMPLETE];
break;
default:
err("unsupported ioctl(%d)\n", ctrl->id);
ret = -EINVAL;
break;
}
return ret;
}
static int fimc_is_scc_video_s_ctrl(struct file *file, void *priv,
struct v4l2_control *ctrl)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = file->private_data;
struct fimc_is_device_ischain *device;
BUG_ON(!vctx);
BUG_ON(!GET_DEVICE(vctx));
BUG_ON(!ctrl);
mdbgv_scc("%s\n", vctx, __func__);
device = GET_DEVICE(vctx);
switch (ctrl->id) {
default:
ret = fimc_is_video_s_ctrl(file, vctx, ctrl);
if (ret) {
err("fimc_is_video_s_ctrl is fail(%d)", ret);
goto p_err;
}
break;
}
p_err:
return ret;
}
static int fimc_is_scc_video_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *buf)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = file->private_data;
struct fimc_is_device_ischain *device;
struct fimc_is_subdev *leader, *subdev;
BUG_ON(!vctx);
BUG_ON(!GET_DEVICE(vctx));
BUG_ON(!GET_VIDEO(vctx));
mdbgv_scc("%s(buffers : %d)\n", vctx, __func__, buf->count);
device = GET_DEVICE(vctx);
subdev = &device->scc;
leader = subdev->leader;
if (leader && test_bit(FIMC_IS_SUBDEV_START, &leader->state)) {
err("leader%d still running, subdev%d req is not applied", leader->id, subdev->id);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_video_reqbufs(file, vctx, buf);
if (ret) {
merr("fimc_is_video_reqbufs is fail(%d)", device, ret);
goto p_err;
}
p_err:
return ret;
}
static int fimc_is_scc_stop_streaming(struct vb2_queue *q)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = q->drv_priv;
struct fimc_is_queue *queue;
struct fimc_is_device_ischain *device;
struct fimc_is_subdev *subdev;
mdbgv_scc("%s\n", vctx, __func__);
queue = GET_DST_QUEUE(vctx);
device = vctx->device;
if (!device) {
err("device is NULL");
ret = -EINVAL;
goto p_err;
}
subdev = &device->scc;
ret = fimc_is_queue_stop_streaming(queue, device, subdev, vctx);
if (ret)
merr("fimc_is_queue_stop_streaming is fail(%d)", vctx, ret);
p_err:
return ret;
}
static int fimc_is_scc_video_streamoff(struct file *file, void *priv,
enum v4l2_buf_type type)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = file->private_data;
mdbgv_scc("%s\n", vctx, __func__);
ret = fimc_is_video_streamoff(file, vctx, type);
if (ret)
merr("fimc_is_video_streamoff is fail(%d)", vctx, ret);
return ret;
}
static int fimc_is_scc_video_set_format_mplane(struct file *file, void *fh,
struct v4l2_format *format)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = file->private_data;
mdbgv_scc("%s\n", vctx, __func__);
ret = fimc_is_video_set_format_mplane(file, vctx, format);
if (ret)
merr("fimc_is_video_set_format_mplane is fail(%d)", vctx, ret);
return ret;
}
static int fimc_is_scc_video_qbuf(struct file *file, void *priv,
struct v4l2_buffer *buf)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = file->private_data;
#ifdef DBG_STREAMING
mdbgv_scc("%s(index : %d)\n", vctx, __func__, buf->index);
#endif
ret = CALL_VOPS(vctx, qbuf, buf);
if (ret)
merr("qbuf is fail(%d)", vctx, ret);
return ret;
}
static int fimc_is_scc_video_dqbuf(struct file *file, void *priv,
struct v4l2_buffer *buf)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = file->private_data;
#ifdef DBG_STREAMING
mdbgv_scc("%s\n", vctx, __func__);
#endif
ret = fimc_is_video_dqbuf(file, vctx, buf);
if (ret)
merr("fimc_is_video_dqbuf is fail(%d)", vctx, ret);
return ret;
}
static int fimc_is_scc_video_dqbuf(struct file *file, void *priv,
struct v4l2_buffer *buf)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = file->private_data;
bool blocking = file->f_flags & O_NONBLOCK;
#ifdef DBG_STREAMING
mdbgv_scc("%s\n", vctx, __func__);
#endif
ret = CALL_VOPS(vctx, dqbuf, buf, blocking);
if (ret)
merr("dqbuf is fail(%d)", vctx, ret);
return ret;
}
static int fimc_is_scc_buffer_finish(struct vb2_buffer *vb)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = vb->vb2_queue->drv_priv;
struct fimc_is_device_ischain *device;
struct fimc_is_subdev *subdev;
BUG_ON(!vctx);
#ifdef DBG_STREAMING
mdbgv_scc("%s(%d)\n", vctx, __func__, vb->v4l2_buf.index);
#endif
device = vctx->device;
subdev = &device->scc;
ret = fimc_is_subdev_buffer_finish(subdev, vb->v4l2_buf.index);
return ret;
}
static int fimc_is_scc_start_streaming(struct vb2_queue *q,
unsigned int count)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = q->drv_priv;
struct fimc_is_queue *queue;
struct fimc_is_device_ischain *device;
struct fimc_is_subdev *subdev;
BUG_ON(!vctx);
mdbgv_scc("%s\n", vctx, __func__);
queue = GET_DST_QUEUE(vctx);
device = vctx->device;
subdev = &device->scc;
ret = fimc_is_queue_start_streaming(queue, device, subdev, vctx);
if (ret)
merr("fimc_is_queue_start_streaming is fail(%d)", vctx, ret);
return ret;
}
static int fimc_is_scc_video_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *buf)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = file->private_data;
struct fimc_is_device_ischain *device;
struct fimc_is_subdev *subdev;
struct fimc_is_subdev *leader;
BUG_ON(!vctx);
mdbgv_scc("%s(buffers : %d)\n", vctx, __func__, buf->count);
device = vctx->device;
subdev = &device->scc;
leader = subdev->leader;
if (!leader) {
merr("leader is NULL ptr", vctx);
ret = -EINVAL;
goto p_err;
}
if (test_bit(FIMC_IS_SUBDEV_START, &leader->state)) {
merr("leader still running, not applied", vctx);
ret = -EINVAL;
goto p_err;
}
ret = fimc_is_video_reqbufs(file, vctx, buf);
if (ret)
merr("fimc_is_video_reqbufs is fail(%d)", vctx, ret);
p_err:
return ret;
}
static int fimc_is_scc_video_s_ctrl(struct file *file, void *priv,
struct v4l2_control *ctrl)
{
int ret = 0;
unsigned long flags;
struct fimc_is_video_ctx *vctx = file->private_data;
struct fimc_is_device_ischain *device;
struct fimc_is_framemgr *framemgr;
struct fimc_is_frame *frame;
BUG_ON(!vctx);
BUG_ON(!ctrl);
mdbgv_scc("%s\n", vctx, __func__);
device = vctx->device;
if (!device) {
merr("device is NULL", vctx);
ret = -EINVAL;
goto p_err;
}
framemgr = GET_DST_FRAMEMGR(vctx);
frame = NULL;
switch (ctrl->id) {
case V4L2_CID_IS_FORCE_DONE:
if (framemgr->frame_pro_cnt) {
err("force done can be performed(process count %d)",
framemgr->frame_pro_cnt);
ret = -EINVAL;
} else if (!framemgr->frame_req_cnt) {
err("force done can be performed(request count %d)",
framemgr->frame_req_cnt);
ret = -EINVAL;
} else {
framemgr_e_barrier_irqs(framemgr, 0, flags);
fimc_is_frame_request_head(framemgr, &frame);
if (frame) {
fimc_is_frame_trans_req_to_com(framemgr, frame);
buffer_done(vctx, frame->index);
} else {
err("frame is NULL");
ret = -EINVAL;
}
framemgr_x_barrier_irqr(framemgr, 0, flags);
}
break;
case V4L2_CID_IS_COLOR_RANGE:
if (test_bit(FIMC_IS_SUBDEV_START, &device->group_isp.leader.state)) {
err("failed to change color range: device started already (0x%08x)",
ctrl->value);
ret = -EINVAL;
} else {
device->setfile &= ~FIMC_IS_SCC_CRANGE_MASK;
if (ctrl->value)
device->setfile |=
(FIMC_IS_CRANGE_LIMITED << FIMC_IS_SCC_CRANGE_SHIFT);
}
break;
default:
merr("unsupported ioctl(%d)\n", vctx, ctrl->id);
ret = -EINVAL;
break;
}
p_err:
return ret;
}
