static void fimc_is_ixc_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_video *video;
struct fimc_is_device_ischain *device;
struct fimc_is_subdev *subdev;
BUG_ON(!vctx);
BUG_ON(!GET_DEVICE(vctx));
BUG_ON(!GET_VIDEO(vctx));
#ifdef DBG_STREAMING
mdbgv_ixc("%s(%d)\n", vctx, __func__, vb->v4l2_buf.index);
#endif
device = GET_DEVICE(vctx);
video = GET_VIDEO(vctx);
queue = GET_QUEUE(vctx);
subdev = &device->ixc;
ret = fimc_is_queue_buffer_queue(queue, video->vb2, 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;
}
}
int fimc_is_video_close(struct fimc_is_video_ctx *vctx)
{
int ret = 0;
struct fimc_is_video *video;
struct fimc_is_queue *queue;
BUG_ON(!vctx);
BUG_ON(!GET_VIDEO(vctx));
video = GET_VIDEO(vctx);
queue = GET_QUEUE(vctx);
if (vctx->state < BIT(FIMC_IS_VIDEO_OPEN)) {
mverr("already close(%lX)", vctx, video, vctx->state);
return -ENOENT;
}
fimc_is_queue_close(queue);
vb2_queue_release(queue->vbq);
kfree(queue->vbq);
/*
* vb2 release can call stop callback
* not if video node is not stream off
*/
vctx->device = NULL;
vctx->state = BIT(FIMC_IS_VIDEO_CLOSE);
return ret;
}
static int fimc_is_ixc_video_close(struct file *file)
{
int ret = 0;
int refcount;
struct fimc_is_video_ctx *vctx = file->private_data;
struct fimc_is_video *video;
struct fimc_is_device_ischain *device;
BUG_ON(!file);
BUG_ON(!vctx);
BUG_ON(!GET_VIDEO(vctx));
BUG_ON(!GET_DEVICE(vctx));
video = GET_VIDEO(vctx);
device = GET_DEVICE(vctx);
ret = fimc_is_ischain_subdev_close(device, vctx);
if (ret)
merr("fimc_is_ischain_subdev_close is fail(%d)", device, ret);
ret = fimc_is_video_close(vctx);
if (ret)
merr("fimc_is_video_close is fail(%d)", device, ret);
refcount = close_vctx(file, video, vctx);
if (refcount < 0)
merr("close_vctx is fail(%d)", device, refcount);
minfo("[I%dC:V] %s(%d,%d):%d\n", device, GET_IXC_ID(video), __func__, atomic_read(&device->open_cnt), refcount, ret);
return ret;
}
static int fimc_is_ssx_video_close(struct file *file)
{
int ret = 0;
int refcount;
struct fimc_is_video_ctx *vctx = file->private_data;
struct fimc_is_video *video;
struct fimc_is_device_sensor *device;
BUG_ON(!vctx);
BUG_ON(!GET_VIDEO(vctx));
BUG_ON(!GET_DEVICE(vctx));
video = GET_VIDEO(vctx);
device = GET_DEVICE(vctx);
ret = fimc_is_sensor_close(device);
if (ret)
merr("fimc_is_sensor_close is fail(%d)", device, ret);
ret = fimc_is_video_close(vctx);
if (ret)
merr("fimc_is_video_close is fail(%d)", device, ret);
refcount = close_vctx(file, video, vctx);
if (refcount < 0)
merr("close_vctx is fail(%d)", device, refcount);
minfo("[SS%d:V] %s(%d):%d\n", device, GET_SSX_ID(video), __func__, refcount, ret);
return ret;
}
int fimc_is_video_dqbuf(struct file *file,
struct fimc_is_video_ctx *vctx,
struct v4l2_buffer *buf)
{
int ret = 0;
bool blocking;
struct fimc_is_video *video;
struct fimc_is_queue *queue;
BUG_ON(!file);
BUG_ON(!vctx);
BUG_ON(!GET_VIDEO(vctx));
BUG_ON(!buf);
blocking = file->f_flags & O_NONBLOCK;
video = GET_VIDEO(vctx);
queue = GET_QUEUE(vctx);
if (!queue->vbq) {
mverr("vbq is NULL", vctx, video);
ret = -EINVAL;
goto p_err;
}
if (buf->type != queue->vbq->type) {
mverr("buf type is invalid(%d != %d)", vctx, video, buf->type, queue->vbq->type);
ret = -EINVAL;
goto p_err;
}
if (!test_bit(FIMC_IS_QUEUE_STREAM_ON, &queue->state)) {
mverr("queue is not streamon(%ld)", vctx, video, queue->state);
ret = -EINVAL;
goto p_err;
}
queue->buf_dqe++;
ret = vb2_dqbuf(queue->vbq, buf, blocking);
if (ret) {
mverr("vb2_dqbuf is fail(%d)", vctx, video, ret);
goto p_err;
}
#ifdef DBG_IMAGE_DUMP
if ((vctx->video->id == DBG_IMAGE_DUMP_VIDEO) && (buf->index == DBG_IMAGE_DUMP_INDEX))
imgdump_request(queue->buf_box[buf->index][0], queue->buf_kva[buf->index][0], queue->framecfg.size[0]);
#endif
p_err:
return ret;
}
static int fimc_is_ixc_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_ixc("%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_ixc_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_ixc("%s(buffers : %d)\n", vctx, __func__, buf->count);
device = GET_DEVICE(vctx);
subdev = &device->ixc;
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;
}
int fimc_is_video_set_format_mplane(struct file *file,
struct fimc_is_video_ctx *vctx,
struct v4l2_format *format)
{
int ret = 0;
u32 condition;
void *device;
struct fimc_is_video *video;
struct fimc_is_queue *queue;
BUG_ON(!vctx);
BUG_ON(!GET_DEVICE(vctx));
BUG_ON(!GET_VIDEO(vctx));
BUG_ON(!format);
device = GET_DEVICE(vctx);
video = GET_VIDEO(vctx);
queue = GET_QUEUE(vctx);
/* capture video node can skip s_input */
if (video->type == FIMC_IS_VIDEO_TYPE_LEADER)
condition = BIT(FIMC_IS_VIDEO_S_INPUT) | BIT(FIMC_IS_VIDEO_S_BUFS);
else
condition = BIT(FIMC_IS_VIDEO_S_INPUT) | BIT(FIMC_IS_VIDEO_S_BUFS) | BIT(FIMC_IS_VIDEO_OPEN);
if (!(vctx->state & condition)) {
err("[V%02d] invalid s_format is requested(%lX)", video->id, vctx->state);
return -EINVAL;
}
ret = fimc_is_queue_set_format_mplane(queue, device, format);
if (ret) {
err("[V%02d] fimc_is_queue_set_format_mplane is fail(%d)", video->id, ret);
goto p_err;
}
vctx->state = BIT(FIMC_IS_VIDEO_S_FORMAT);
p_err:
mdbgv_vid("set_format(%d x %d)\n", queue->framecfg.width, queue->framecfg.height);
return ret;
}
static int queue_init(void *priv, struct vb2_queue *vbq,
struct vb2_queue *vbq_dst)
{
int ret = 0;
struct fimc_is_video_ctx *vctx = priv;
struct fimc_is_video *video;
u32 type;
BUG_ON(!vctx);
BUG_ON(!GET_VIDEO(vctx));
BUG_ON(!vbq);
video = GET_VIDEO(vctx);
if (video->type == FIMC_IS_VIDEO_TYPE_CAPTURE)
type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
else
type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
vbq->type = type;
vbq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
vbq->drv_priv = vctx;
vbq->ops = vctx->vb2_ops;
vbq->mem_ops = vctx->mem_ops;
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0))
vbq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY;
#endif
ret = vb2_queue_init(vbq);
if (ret) {
err("vb2_queue_init fail(%d)", ret);
goto p_err;
}
vctx->queue.vbq = vbq;
p_err:
return ret;
}
int fimc_is_video_s_ctrl(struct file *file,
struct fimc_is_video_ctx *vctx,
struct v4l2_control *ctrl)
{
int ret = 0;
/* hack for 64bit addr */
ulong value_to_addr = 0;
struct fimc_is_video *video;
struct fimc_is_device_ischain *device;
struct fimc_is_resourcemgr *resourcemgr;
BUG_ON(!vctx);
BUG_ON(!GET_DEVICE(vctx));
BUG_ON(!GET_VIDEO(vctx));
BUG_ON(!ctrl);
device = GET_DEVICE(vctx);
video = GET_VIDEO(vctx);
resourcemgr = device->resourcemgr;
switch (ctrl->id) {
case V4L2_CID_IS_END_OF_STREAM:
ret = fimc_is_ischain_open_wrap(device, true);
if (ret) {
merr("fimc_is_ischain_open_wrap is fail(%d)", device, ret);
goto p_err;
}
break;
case V4L2_CID_IS_SET_SETFILE:
if (test_bit(FIMC_IS_ISCHAIN_START, &device->state)) {
merr("device is already started, setfile applying is fail", device);
ret = -EINVAL;
goto p_err;
}
device->setfile = ctrl->value;
break;
case V4L2_CID_IS_HAL_VERSION:
if (ctrl->value < 0 || ctrl->value >= IS_HAL_VER_MAX) {
merr("hal version(%d) is invalid", device, ctrl->value);
ret = -EINVAL;
goto p_err;
}
resourcemgr->hal_version = ctrl->value;
break;
case V4L2_CID_IS_DEBUG_DUMP:
info("Print fimc-is info dump by HAL");
fimc_is_hw_logdump(device->interface);
fimc_is_hw_regdump(device->interface);
CALL_POPS(device, print_clk);
if (ctrl->value)
panic("intentional panic from camera HAL");
break;
case V4L2_CID_IS_DVFS_CLUSTER0:
case V4L2_CID_IS_DVFS_CLUSTER1:
fimc_is_resource_ioctl(resourcemgr, ctrl);
break;
case V4L2_CID_IS_DEBUG_SYNC_LOG:
fimc_is_logsync(device->interface, ctrl->value, IS_MSG_TEST_SYNC_LOG);
break;
case V4L2_CID_IS_MAP_BUFFER:
{
struct fimc_is_queue *queue;
struct fimc_is_framemgr *framemgr;
struct fimc_is_frame *frame;
struct dma_buf *dmabuf;
struct dma_buf_attachment *attachment;
dma_addr_t dva;
struct v4l2_buffer *buf;
struct v4l2_plane *planes;
size_t size;
u32 plane, group_id;
size = sizeof(struct v4l2_buffer);
buf = kmalloc(size, GFP_KERNEL);
if (!buf) {
mverr("kmalloc is fail(%p)", device, video, buf);
ret = -EINVAL;
goto p_err;
}
/* hack for 64bit addr */
value_to_addr = ctrl->value;
ret = copy_from_user(buf, (void __user *)value_to_addr, size);
if (ret) {
mverr("copy_from_user is fail(%d)", device, video, ret);
kfree(buf);
ret = -EINVAL;
goto p_err;
}
if (!V4L2_TYPE_IS_OUTPUT(buf->type)) {
mverr("capture video type is not supported", device, video);
kfree(buf);
ret = -EINVAL;
goto p_err;
}
if (!V4L2_TYPE_IS_MULTIPLANAR(buf->type)) {
mverr("single plane is not supported", device, video);
kfree(buf);
ret = -EINVAL;
goto p_err;
}
if (buf->index >= FRAMEMGR_MAX_REQUEST) {
mverr("buffer index is invalid(%d)", device, video, buf->index);
kfree(buf);
ret = -EINVAL;
goto p_err;
}
if (buf->length > VIDEO_MAX_PLANES) {
mverr("planes[%d] is invalid", device, video, buf->length);
kfree(buf);
ret = -EINVAL;
goto p_err;
}
queue = GET_QUEUE(vctx);
if (queue->vbq->memory != V4L2_MEMORY_DMABUF) {
mverr("memory type(%d) is not supported", device, video, queue->vbq->memory);
kfree(buf);
ret = -EINVAL;
goto p_err;
}
size = sizeof(struct v4l2_plane) * buf->length;
planes = kmalloc(size, GFP_KERNEL);
if (!planes) {
mverr("kmalloc is fail(%p)", device, video, planes);
kfree(buf);
ret = -EINVAL;
goto p_err;
}
ret = copy_from_user(planes, (void __user *)buf->m.planes, size);
if (ret) {
mverr("copy_from_user is fail(%d)", device, video, ret);
kfree(planes);
kfree(buf);
ret = -EINVAL;
goto p_err;
}
framemgr = &queue->framemgr;
frame = &framemgr->frame[buf->index];
if (test_bit(FRAME_MAP_MEM, &frame->memory)) {
mverr("this buffer(%d) is already mapped", device, video, buf->index);
kfree(planes);
kfree(buf);
ret = -EINVAL;
goto p_err;
}
/* only last buffer need to map */
if (buf->length <= 1) {
mverr("this buffer(%d) have no meta plane", device, video, buf->length);
kfree(planes);
kfree(buf);
ret = -EINVAL;
goto p_err;
}
plane = buf->length - 1;
dmabuf = dma_buf_get(planes[plane].m.fd);
if (IS_ERR(dmabuf)) {
mverr("dma_buf_get is fail(%p)", device, video, dmabuf);
kfree(planes);
kfree(buf);
ret = -EINVAL;
goto p_err;
}
attachment = dma_buf_attach(dmabuf, &device->pdev->dev);
if (IS_ERR(attachment)) {
mverr("dma_buf_attach is fail(%p)", device, video, attachment);
kfree(planes);
kfree(buf);
dma_buf_put(dmabuf);
ret = -EINVAL;
goto p_err;
}
/* only support output(read) video node */
dva = ion_iovmm_map(attachment, 0, dmabuf->size, 0, plane);
if (IS_ERR_VALUE(dva)) {
mverr("ion_iovmm_map is fail(%pa)", device, video, &dva);
kfree(planes);
kfree(buf);
dma_buf_detach(dmabuf, attachment);
dma_buf_put(dmabuf);
ret = -EINVAL;
goto p_err;
}
group_id = GROUP_ID(device->group_3aa.id);
ret = fimc_is_itf_map(device, group_id, dva, dmabuf->size);
if (ret) {
mverr("fimc_is_itf_map is fail(%d)", device, video, ret);
kfree(planes);
kfree(buf);
dma_buf_detach(dmabuf, attachment);
dma_buf_put(dmabuf);
goto p_err;
}
mvinfo(" B%d.P%d MAP\n", device, video, buf->index, plane);
set_bit(FRAME_MAP_MEM, &frame->memory);
dma_buf_detach(dmabuf, attachment);
dma_buf_put(dmabuf);
kfree(planes);
kfree(buf);
}
break;
default:
err("unsupported ioctl(0x%X)", ctrl->id);
ret = -EINVAL;
break;
}
p_err:
return ret;
}
