static int vidioc_reqbufs(struct file *file, void *__fh, struct v4l2_requestbuffers *b)
{
struct saa7146_fh *fh = __fh;
if (b->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
return videobuf_reqbufs(&fh->video_q, b);
if (b->type == V4L2_BUF_TYPE_VBI_CAPTURE)
return videobuf_reqbufs(&fh->vbi_q, b);
return -EINVAL;
}
static int vidioc_reqbufs(struct file *file, void *fh,
struct v4l2_requestbuffers *b)
{
struct omap24xxcam_fh *ofh = fh;
struct omap24xxcam_device *cam = ofh->cam;
int rval;
mutex_lock(&cam->mutex);
if (cam->streaming) {
mutex_unlock(&cam->mutex);
return -EBUSY;
}
omap24xxcam_vbq_free_mmap_buffers(&ofh->vbq);
mutex_unlock(&cam->mutex);
rval = videobuf_reqbufs(&ofh->vbq, b);
/*
* Either videobuf_reqbufs failed or the buffers are not
* memory-mapped (which would need special attention).
*/
if (rval < 0 || b->memory != V4L2_MEMORY_MMAP)
goto out;
rval = omap24xxcam_vbq_alloc_mmap_buffers(&ofh->vbq, rval);
if (rval)
omap24xxcam_vbq_free_mmap_buffers(&ofh->vbq);
out:
return rval;
}
static int atomisp_reqbufs_file(struct file *file, void *fh,
struct v4l2_requestbuffers *req)
{
int ret;
struct video_device *vdev = video_devdata(file);
struct atomisp_device *isp = video_get_drvdata(vdev);
struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
if (req->count == 0) {
atomisp_videobuf_free(&pipe->outq);
return 0;
}
ret = videobuf_reqbufs(&pipe->outq, req);
if (ret)
return ret;
if (isp->sw_contex.output_mode == OUTPUT_MODE_TEXT)
return 0;
/*
* TODO: Implement file input function
*/
return 0;
}
static int solo_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *req)
{
struct solo_filehandle *fh = priv;
return videobuf_reqbufs(&fh->vidq, req);
}
static int vpif_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *reqbuf)
{
struct vpif_fh *fh = priv;
struct channel_obj *ch = fh->channel;
struct common_obj *common;
enum v4l2_field field;
u8 index = 0;
/* This file handle has not initialized the channel,
It is not allowed to do settings */
if ((VPIF_CHANNEL2_VIDEO == ch->channel_id)
|| (VPIF_CHANNEL3_VIDEO == ch->channel_id)) {
if (!fh->initialized) {
vpif_err("Channel Busy\n");
return -EBUSY;
}
}
if (V4L2_BUF_TYPE_VIDEO_OUTPUT != reqbuf->type)
return -EINVAL;
index = VPIF_VIDEO_INDEX;
common = &ch->common[index];
if (common->fmt.type != reqbuf->type)
return -EINVAL;
if (0 != common->io_usrs)
return -EBUSY;
if (reqbuf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
if (common->fmt.fmt.pix.field == V4L2_FIELD_ANY)
field = V4L2_FIELD_INTERLACED;
else
field = common->fmt.fmt.pix.field;
} else {
field = V4L2_VBI_INTERLACED;
}
/* Initialize videobuf queue as per the buffer type */
videobuf_queue_dma_contig_init(&common->buffer_queue,
&video_qops, NULL,
&common->irqlock,
reqbuf->type, field,
sizeof(struct videobuf_buffer), fh,
&common->lock);
/* Set io allowed member of file handle to TRUE */
fh->io_allowed[index] = 1;
/* Increment io usrs member of channel object to 1 */
common->io_usrs = 1;
/* Store type of memory requested in channel object */
common->memory = reqbuf->memory;
INIT_LIST_HEAD(&common->dma_queue);
/* Allocate buffers */
return videobuf_reqbufs(&common->buffer_queue, reqbuf);
}
static int empress_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *p)
{
struct saa7134_dev *dev = file->private_data;
return videobuf_reqbufs(&dev->empress_tsq, p);
}
static int empress_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *p)
{
struct saa7134_fh *fh = priv;
struct saa7134_dev *dev = fh->dev;
return videobuf_reqbufs(&dev->empress_tsq, p);
}
static int vidioc_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *p)
{
int ret;
struct marucam_device *dev = priv;
dev->type = p->type;
ret = videobuf_reqbufs(&dev->vb_vidq, p);
if (ret) {
marucam_err("Failed to request the video buffers\n");
}
return ret;
}
static int vpif_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *reqbuf)
{
struct vpif_fh *fh = priv;
struct channel_obj *ch = fh->channel;
struct common_obj *common;
u8 index = 0;
vpif_dbg(2, debug, "vpif_reqbufs\n");
if ((VPIF_CHANNEL0_VIDEO == ch->channel_id)
|| (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
if (!fh->initialized) {
vpif_dbg(1, debug, "Channel Busy\n");
return -EBUSY;
}
}
if (V4L2_BUF_TYPE_VIDEO_CAPTURE != reqbuf->type)
return -EINVAL;
index = VPIF_VIDEO_INDEX;
common = &ch->common[index];
if (0 != common->io_usrs)
return -EBUSY;
videobuf_queue_dma_contig_init(&common->buffer_queue,
&video_qops, NULL,
&common->irqlock,
reqbuf->type,
common->fmt.fmt.pix.field,
sizeof(struct videobuf_buffer), fh,
&common->lock);
fh->io_allowed[index] = 1;
common->io_usrs = 1;
common->memory = reqbuf->memory;
INIT_LIST_HEAD(&common->dma_queue);
return videobuf_reqbufs(&common->buffer_queue, reqbuf);
}
static int fimc_cap_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *reqbufs)
{
struct fimc_ctx *ctx = priv;
struct fimc_dev *fimc = ctx->fimc_dev;
struct fimc_vid_cap *cap = &fimc->vid_cap;
int ret;
if (fimc_capture_active(ctx->fimc_dev))
return -EBUSY;
if (mutex_lock_interruptible(&fimc->lock))
return -ERESTARTSYS;
ret = videobuf_reqbufs(&cap->vbq, reqbufs);
if (!ret)
cap->reqbufs_count = reqbufs->count;
mutex_unlock(&fimc->lock);
return ret;
}
static int
camera_core_do_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
void *arg)
{
struct camera_fh *fh = file->private_data;
struct camera_device *cam = fh->cam;
int err;
switch (cmd) {
case VIDIOC_ENUMINPUT:
{
/* default handler assumes 1 video input (the camera) */
struct v4l2_input *input = (struct v4l2_input *)arg;
int index = input->index;
memset(input, 0, sizeof(*input));
input->index = index;
if (index > 0)
return -EINVAL;
strlcpy(input->name, "camera", sizeof(input->name));
input->type = V4L2_INPUT_TYPE_CAMERA;
return 0;
}
case VIDIOC_G_INPUT:
{
unsigned int *input = arg;
*input = 0;
return 0;
}
case VIDIOC_S_INPUT:
{
unsigned int *input = arg;
if (*input > 0)
return -EINVAL;
return 0;
}
case VIDIOC_ENUM_FMT:
{
struct v4l2_fmtdesc *fmt = arg;
return cam->cam_sensor->enum_pixformat(fmt, cam->sensor_data);
}
case VIDIOC_TRY_FMT:
{
struct v4l2_format *fmt = arg;
return cam->cam_sensor->try_format(&fmt->fmt.pix, cam->sensor_data);
}
case VIDIOC_G_FMT:
{
struct v4l2_format *fmt = arg;
/* get the current format */
memset(&fmt->fmt.pix, 0, sizeof (fmt->fmt.pix));
fmt->fmt.pix = cam->pix;
return 0;
}
case VIDIOC_S_FMT:
{
struct v4l2_format *fmt = arg;
unsigned int temp_sizeimage = 0;
temp_sizeimage = cam->pix.sizeimage;
cam->cam_sensor->try_format(&fmt->fmt.pix, cam->sensor_data);
cam->pix = fmt->fmt.pix;
cam->xclk = cam->cam_sensor->calc_xclk(&cam->pix,
&cam->nominal_timeperframe, cam->sensor_data);
cam->cparm.timeperframe = cam->nominal_timeperframe;
cam->xclk = cam->cam_hardware->set_xclk(cam->xclk, cam->hardware_data);
return cam->cam_sensor->configure(&cam->pix, cam->xclk,
&cam->cparm.timeperframe, cam->sensor_data);
}
case VIDIOC_QUERYCTRL:
{
struct v4l2_queryctrl *qc = arg;
return cam->cam_sensor->query_control(qc, cam->sensor_data);
}
case VIDIOC_G_CTRL:
{
struct v4l2_control *vc = arg;
return cam->cam_sensor->get_control(vc, cam->sensor_data);
}
case VIDIOC_S_CTRL:
{
struct v4l2_control *vc = arg;
return cam->cam_sensor->set_control(vc, cam->sensor_data);
}
case VIDIOC_QUERYCAP:
{
struct v4l2_capability *cap =
(struct v4l2_capability *) arg;
memset(cap, 0, sizeof(*cap));
strlcpy(cap->driver, CAM_NAME, sizeof(cap->driver));
strlcpy(cap->card, cam->vfd->name, sizeof(cap->card));
cap->bus_info[0] = '\0';
cap->version = KERNEL_VERSION(0, 0, 0);
cap->capabilities =
V4L2_CAP_VIDEO_CAPTURE |
V4L2_CAP_VIDEO_OVERLAY |
V4L2_CAP_READWRITE |
V4L2_CAP_STREAMING;
return 0;
}
case VIDIOC_G_FBUF: /* Get the frame buffer parameters */
{
struct v4l2_framebuffer *fbuf =
(struct v4l2_framebuffer *) arg;
spin_lock(&cam->img_lock);
*fbuf = cam->fbuf;
spin_unlock(&cam->img_lock);
return 0;
}
case VIDIOC_S_FBUF: /* set the frame buffer parameters */
{
struct v4l2_framebuffer *fbuf =
(struct v4l2_framebuffer *) arg;
spin_lock(&cam->img_lock);
if (cam->previewing) {
spin_unlock(&cam->img_lock);
return -EBUSY;
}
cam->fbuf.base = fbuf->base;
cam->fbuf.fmt = fbuf->fmt;
spin_unlock(&cam->img_lock);
return 0;
}
case VIDIOC_OVERLAY:
{
int enable = *((int *) arg);
/*
* check whether the capture format and
** the display format matches
* return failure if they are different
*/
if (cam->pix.pixelformat != cam->fbuf.fmt.pixelformat)
{
return -EINVAL;
}
/* If the camera image size is greater
** than LCD size return failure */
if ((cam->pix.width > cam->fbuf.fmt.height) ||
(cam->pix.height > cam->fbuf.fmt.width))
{
return -EINVAL;
}
if (!cam->previewing && enable)
{
cam->previewing = fh;
cam->overlay_cnt = 0;
camera_core_start_overlay(cam);
}
else if (!enable)
{
cam->previewing = NULL;
}
return 0;
}
case VIDIOC_REQBUFS:
return videobuf_reqbufs(&fh->vbq, arg);
case VIDIOC_QUERYBUF:
return videobuf_querybuf(&fh->vbq, arg);
case VIDIOC_QBUF:
return videobuf_qbuf(&fh->vbq, arg);
case VIDIOC_DQBUF:
return videobuf_dqbuf(&fh->vbq, arg, file->f_flags & O_NONBLOCK);
case VIDIOC_STREAMON:
{
spin_lock(&cam->img_lock);
if (cam->streaming || cam->reading) {
spin_unlock(&cam->img_lock);
return -EBUSY;
}
else {
cam->streaming = fh;
/* FIXME: start camera interface */
}
spin_unlock(&cam->img_lock);
/* Allocate dummy buffer. We will use this buffer then no
* videobufs available to prevent FIFO_FULL. Use the same
* field of camera_device structure as in 'read()' function
* (capture_base_phys and capture_base)
*/
if (!cam->capture_base) {
cam->capture_base = (unsigned long)dma_alloc_coherent(NULL, cam->pix.sizeimage,
(dma_addr_t *) &cam->capture_base_phys, GFP_KERNEL | GFP_DMA);
}
if (!cam->capture_base) {
printk(KERN_ERR CAM_NAME ": cannot allocate dummy buffer\n");
spin_lock(&cam->img_lock);
cam->streaming = NULL;
spin_unlock(&cam->img_lock);
return -ENOMEM;
}
return videobuf_streamon(&fh->vbq);
}
case VIDIOC_STREAMOFF:
{
struct videobuf_queue *q = &fh->vbq;
int i;
/* video-buf lib has trouble to turn off streaming while
* any buffer is still in QUEUED state. Let's wait until
* all queued buffers are filled.
* */
for (i = 0; i < VIDEO_MAX_FRAME; i++) {
if (NULL == q->bufs[i])
continue;
while (q->bufs[i]->state == STATE_QUEUED) {
schedule();
}
}
err = videobuf_streamoff(&fh->vbq);
if (err < 0)
return err;
spin_lock(&cam->img_lock);
if (cam->streaming == fh) {
cam->streaming = NULL;
}
spin_unlock(&cam->img_lock);
/* Wait for dma finished and remove dummy buffer */
cam->cam_hardware->finish_dma(cam->hardware_data);
if (cam->capture_base) {
dma_free_coherent(NULL, cam->pix.sizeimage,
(void *)cam->capture_base,
cam->capture_base_phys);
cam->capture_base = 0;
cam->capture_base_phys = 0;
}
return 0;
}
case VIDIOC_ENUMSTD:
case VIDIOC_G_STD:
case VIDIOC_S_STD:
case VIDIOC_QUERYSTD:
{
/* Digital cameras don't have an analog video standard,
* so we don't need to implement these ioctls.
*/
return -EINVAL;
}
case VIDIOC_G_AUDIO:
case VIDIOC_S_AUDIO:
case VIDIOC_G_AUDOUT:
case VIDIOC_S_AUDOUT:
{
/* we don't have any audio inputs or outputs */
return -EINVAL;
}
case VIDIOC_G_JPEGCOMP:
case VIDIOC_S_JPEGCOMP:
{
/* JPEG compression is not supported */
return -EINVAL;
}
case VIDIOC_G_TUNER:
case VIDIOC_S_TUNER:
case VIDIOC_G_MODULATOR:
case VIDIOC_S_MODULATOR:
case VIDIOC_G_FREQUENCY:
case VIDIOC_S_FREQUENCY:
{
/* we don't have a tuner or modulator */
return -EINVAL;
}
case VIDIOC_ENUMOUTPUT:
case VIDIOC_G_OUTPUT:
case VIDIOC_S_OUTPUT:
{
/* we don't have any video outputs */
return -EINVAL;
}
default:
{
/* unrecognized ioctl */
return -ENOIOCTLCMD;
}
}
return 0;
}
/*
* Initiate Memory Mapping or User Pointer I/O
*/
int atomisp_reqbufs(struct file *file, void *fh,
struct v4l2_requestbuffers *req)
{
struct video_device *vdev = video_devdata(file);
struct atomisp_device *isp = video_get_drvdata(vdev);
struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
struct sh_css_frame_info out_info, vf_info;
struct sh_css_frame *frame;
struct videobuf_vmalloc_memory *vm_mem;
int ret = 0, i = 0;
if (req->count == 0) {
atomisp_videobuf_free(&pipe->capq);
if ((!isp->isp_subdev.video_out_vf.opened) &&
(isp->vf_frame)) {
sh_css_frame_free(isp->vf_frame);
isp->vf_frame = NULL;
}
return 0;
}
if ((!pipe->is_main) && (!atomisp_is_viewfinder_support(isp)))
return -EINVAL;
ret = videobuf_reqbufs(&pipe->capq, req);
if (ret)
return ret;
switch (isp->sw_contex.run_mode) {
case CI_MODE_STILL_CAPTURE:
if (isp->main_format->out_sh_fmt != SH_CSS_FRAME_FORMAT_RAW) {
if (sh_css_capture_get_viewfinder_frame_info(&vf_info))
goto error;
if ((!isp->isp_subdev.video_out_vf.opened) &&
(sh_css_frame_allocate_from_info(&isp->vf_frame,
&vf_info)))
goto error;
}
if (sh_css_capture_get_output_frame_info(&out_info))
goto error;
break;
case CI_MODE_VIDEO:
if (sh_css_video_get_viewfinder_frame_info(&vf_info))
goto error;
if ((!isp->isp_subdev.video_out_vf.opened) &&
(sh_css_frame_allocate_from_info(&isp->vf_frame, &vf_info)))
goto error;
if (sh_css_video_get_output_frame_info(&out_info))
goto error;
break;
case CI_MODE_PREVIEW:
if (sh_css_preview_get_output_frame_info(&out_info))
goto error;
break;
default:
return -EINVAL;
}
/*
* for user pointer type, buffers are not really allcated here,
* buffers are setup in QBUF operation through v4l2_buffer structure
*/
if (req->memory == V4L2_MEMORY_USERPTR) {
v4l2_info(&atomisp_dev,
"user pointer, not really allocate"
" memory here.\n");
return 0;
}
if (!pipe->is_main)
/*
* Allocate the real frame here for preview node using our
* memery management function
*/
for (i = 0; i < req->count; i++) {
if (sh_css_frame_allocate_from_info(&frame, &vf_info))
goto error;
vm_mem = pipe->capq.bufs[i]->priv;
vm_mem->vaddr = frame;
}
else
/*
* Allocate the real frame here for capture node using our
* memery management function
*/
for (i = 0; i < req->count; i++) {
if (sh_css_frame_allocate_from_info(&frame, &out_info))
goto error;
vm_mem = pipe->capq.bufs[i]->priv;
vm_mem->vaddr = frame;
}
return ret;
error:
while (i--) {
vm_mem = pipe->capq.bufs[i]->priv;
sh_css_frame_free(vm_mem->vaddr);
}
if (isp->vf_frame)
sh_css_frame_free(isp->vf_frame);
return -ENOMEM;
}
int saa7146_video_do_ioctl(struct inode *inode, struct file *file, unsigned int cmd, void *arg)
{
struct saa7146_fh *fh = file->private_data;
struct saa7146_dev *dev = fh->dev;
struct saa7146_vv *vv = dev->vv_data;
int err = 0, result = 0, ee = 0;
struct saa7146_use_ops *ops;
struct videobuf_queue *q;
/* check if extension handles the command */
for(ee = 0; dev->ext_vv_data->ioctls[ee].flags != 0; ee++) {
if( cmd == dev->ext_vv_data->ioctls[ee].cmd )
break;
}
if( 0 != (dev->ext_vv_data->ioctls[ee].flags & SAA7146_EXCLUSIVE) ) {
DEB_D(("extension handles ioctl exclusive.\n"));
result = dev->ext_vv_data->ioctl(fh, cmd, arg);
return result;
}
if( 0 != (dev->ext_vv_data->ioctls[ee].flags & SAA7146_BEFORE) ) {
DEB_D(("extension handles ioctl before.\n"));
result = dev->ext_vv_data->ioctl(fh, cmd, arg);
if( -EAGAIN != result ) {
return result;
}
}
/* fixme: add handle "after" case (is it still needed?) */
switch (fh->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
ops = &saa7146_video_uops;
q = &fh->video_q;
break;
}
case V4L2_BUF_TYPE_VBI_CAPTURE: {
ops = &saa7146_vbi_uops;
q = &fh->vbi_q;
break;
}
default:
BUG();
return 0;
}
switch (cmd) {
case VIDIOC_QUERYCAP:
{
struct v4l2_capability *cap = arg;
memset(cap,0,sizeof(*cap));
DEB_EE(("VIDIOC_QUERYCAP\n"));
strcpy(cap->driver, "saa7146 v4l2");
strlcpy(cap->card, dev->ext->name, sizeof(cap->card));
sprintf(cap->bus_info,"PCI:%s", pci_name(dev->pci));
cap->version = SAA7146_VERSION_CODE;
cap->capabilities =
V4L2_CAP_VIDEO_CAPTURE |
V4L2_CAP_VIDEO_OVERLAY |
V4L2_CAP_READWRITE |
V4L2_CAP_STREAMING;
cap->capabilities |= dev->ext_vv_data->capabilities;
return 0;
}
case VIDIOC_G_FBUF:
{
struct v4l2_framebuffer *fb = arg;
DEB_EE(("VIDIOC_G_FBUF\n"));
*fb = vv->ov_fb;
fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
return 0;
}
case VIDIOC_S_FBUF:
{
struct v4l2_framebuffer *fb = arg;
struct saa7146_format *fmt;
DEB_EE(("VIDIOC_S_FBUF\n"));
if(!capable(CAP_SYS_ADMIN) &&
!capable(CAP_SYS_RAWIO))
return -EPERM;
/* check args */
fmt = format_by_fourcc(dev,fb->fmt.pixelformat);
if (NULL == fmt) {
return -EINVAL;
}
/* planar formats are not allowed for overlay video, clipping and video dma would clash */
if (0 != (fmt->flags & FORMAT_IS_PLANAR)) {
DEB_S(("planar pixelformat '%4.4s' not allowed for overlay\n",(char *)&fmt->pixelformat));
}
/* check if overlay is running */
if (IS_OVERLAY_ACTIVE(fh) != 0) {
if (vv->video_fh != fh) {
DEB_D(("refusing to change framebuffer informations while overlay is active in another open.\n"));
return -EBUSY;
}
}
down(&dev->lock);
/* ok, accept it */
vv->ov_fb = *fb;
vv->ov_fmt = fmt;
if (0 == vv->ov_fb.fmt.bytesperline)
vv->ov_fb.fmt.bytesperline =
vv->ov_fb.fmt.width*fmt->depth/8;
up(&dev->lock);
return 0;
}
case VIDIOC_ENUM_FMT:
{
struct v4l2_fmtdesc *f = arg;
int index;
switch (f->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
case V4L2_BUF_TYPE_VIDEO_OVERLAY: {
index = f->index;
if (index < 0 || index >= NUM_FORMATS) {
return -EINVAL;
}
memset(f,0,sizeof(*f));
f->index = index;
strlcpy(f->description,formats[index].name,sizeof(f->description));
f->pixelformat = formats[index].pixelformat;
break;
}
default:
return -EINVAL;
}
DEB_EE(("VIDIOC_ENUM_FMT: type:%d, index:%d\n",f->type,f->index));
return 0;
}
case VIDIOC_QUERYCTRL:
{
const struct v4l2_queryctrl *ctrl;
struct v4l2_queryctrl *c = arg;
if ((c->id < V4L2_CID_BASE ||
c->id >= V4L2_CID_LASTP1) &&
(c->id < V4L2_CID_PRIVATE_BASE ||
c->id >= V4L2_CID_PRIVATE_LASTP1))
return -EINVAL;
ctrl = ctrl_by_id(c->id);
if( NULL == ctrl ) {
return -EINVAL;
/*
c->flags = V4L2_CTRL_FLAG_DISABLED;
return 0;
*/
}
DEB_EE(("VIDIOC_QUERYCTRL: id:%d\n",c->id));
*c = *ctrl;
return 0;
}
case VIDIOC_G_CTRL: {
DEB_EE(("VIDIOC_G_CTRL\n"));
return get_control(fh,arg);
}
case VIDIOC_S_CTRL:
{
DEB_EE(("VIDIOC_S_CTRL\n"));
err = set_control(fh,arg);
return err;
}
case VIDIOC_G_PARM:
{
struct v4l2_streamparm *parm = arg;
if( parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ) {
return -EINVAL;
}
memset(&parm->parm.capture,0,sizeof(struct v4l2_captureparm));
parm->parm.capture.readbuffers = 1;
// fixme: only for PAL!
parm->parm.capture.timeperframe.numerator = 1;
parm->parm.capture.timeperframe.denominator = 25;
return 0;
}
case VIDIOC_G_FMT:
{
struct v4l2_format *f = arg;
DEB_EE(("VIDIOC_G_FMT\n"));
return g_fmt(fh,f);
}
case VIDIOC_S_FMT:
{
struct v4l2_format *f = arg;
DEB_EE(("VIDIOC_S_FMT\n"));
return s_fmt(fh,f);
}
case VIDIOC_TRY_FMT:
{
struct v4l2_format *f = arg;
DEB_EE(("VIDIOC_TRY_FMT\n"));
return try_fmt(fh,f);
}
case VIDIOC_G_STD:
{
v4l2_std_id *id = arg;
DEB_EE(("VIDIOC_G_STD\n"));
*id = vv->standard->id;
return 0;
}
/* the saa7146 supfhrts (used in conjunction with the saa7111a for example)
PAL / NTSC / SECAM. if your hardware does not (or does more)
-- override this function in your extension */
case VIDIOC_ENUMSTD:
{
struct v4l2_standard *e = arg;
if (e->index < 0 )
return -EINVAL;
if( e->index < dev->ext_vv_data->num_stds ) {
DEB_EE(("VIDIOC_ENUMSTD: index:%d\n",e->index));
v4l2_video_std_construct(e, dev->ext_vv_data->stds[e->index].id, dev->ext_vv_data->stds[e->index].name);
return 0;
}
return -EINVAL;
}
case VIDIOC_S_STD:
{
v4l2_std_id *id = arg;
int found = 0;
int i, err;
DEB_EE(("VIDIOC_S_STD\n"));
if ((vv->video_status & STATUS_CAPTURE) == STATUS_CAPTURE) {
DEB_D(("cannot change video standard while streaming capture is active\n"));
return -EBUSY;
}
if ((vv->video_status & STATUS_OVERLAY) != 0) {
vv->ov_suspend = vv->video_fh;
err = saa7146_stop_preview(vv->video_fh); /* side effect: video_status is now 0, video_fh is NULL */
if (0 != err) {
DEB_D(("suspending video failed. aborting\n"));
return err;
}
}
down(&dev->lock);
for(i = 0; i < dev->ext_vv_data->num_stds; i++)
if (*id & dev->ext_vv_data->stds[i].id)
break;
if (i != dev->ext_vv_data->num_stds) {
vv->standard = &dev->ext_vv_data->stds[i];
if( NULL != dev->ext_vv_data->std_callback )
dev->ext_vv_data->std_callback(dev, vv->standard);
found = 1;
}
up(&dev->lock);
if (vv->ov_suspend != NULL) {
saa7146_start_preview(vv->ov_suspend);
vv->ov_suspend = NULL;
}
if( 0 == found ) {
DEB_EE(("VIDIOC_S_STD: standard not found.\n"));
return -EINVAL;
}
DEB_EE(("VIDIOC_S_STD: set to standard to '%s'\n",vv->standard->name));
return 0;
}
case VIDIOC_OVERLAY:
{
int on = *(int *)arg;
int err = 0;
DEB_D(("VIDIOC_OVERLAY on:%d\n",on));
if (on != 0) {
err = saa7146_start_preview(fh);
} else {
err = saa7146_stop_preview(fh);
}
return err;
}
case VIDIOC_REQBUFS: {
struct v4l2_requestbuffers *req = arg;
DEB_D(("VIDIOC_REQBUFS, type:%d\n",req->type));
return videobuf_reqbufs(q,req);
}
case VIDIOC_QUERYBUF: {
struct v4l2_buffer *buf = arg;
DEB_D(("VIDIOC_QUERYBUF, type:%d, offset:%d\n",buf->type,buf->m.offset));
return videobuf_querybuf(q,buf);
}
case VIDIOC_QBUF: {
struct v4l2_buffer *buf = arg;
int ret = 0;
ret = videobuf_qbuf(q,buf);
DEB_D(("VIDIOC_QBUF: ret:%d, index:%d\n",ret,buf->index));
return ret;
}
case VIDIOC_DQBUF: {
struct v4l2_buffer *buf = arg;
int ret = 0;
ret = videobuf_dqbuf(q,buf,file->f_flags & O_NONBLOCK);
DEB_D(("VIDIOC_DQBUF: ret:%d, index:%d\n",ret,buf->index));
return ret;
}
case VIDIOC_STREAMON: {
int *type = arg;
DEB_D(("VIDIOC_STREAMON, type:%d\n",*type));
err = video_begin(fh);
if( 0 != err) {
return err;
}
err = videobuf_streamon(q);
return err;
}
case VIDIOC_STREAMOFF: {
int *type = arg;
DEB_D(("VIDIOC_STREAMOFF, type:%d\n",*type));
/* ugly: we need to copy some checks from video_end(),
because videobuf_streamoff() relies on the capture running.
check and fix this */
if ((vv->video_status & STATUS_CAPTURE) != STATUS_CAPTURE) {
DEB_S(("not capturing.\n"));
return 0;
}
if (vv->video_fh != fh) {
DEB_S(("capturing, but in another open.\n"));
return -EBUSY;
}
err = videobuf_streamoff(q);
if (0 != err) {
DEB_D(("warning: videobuf_streamoff() failed.\n"));
video_end(fh, file);
} else {
err = video_end(fh, file);
}
return err;
}
case VIDIOCGMBUF:
{
struct video_mbuf *mbuf = arg;
struct videobuf_queue *q;
int i;
/* fixme: number of capture buffers and sizes for v4l apps */
int gbuffers = 2;
int gbufsize = 768*576*4;
DEB_D(("VIDIOCGMBUF \n"));
q = &fh->video_q;
down(&q->lock);
err = videobuf_mmap_setup(q,gbuffers,gbufsize,
V4L2_MEMORY_MMAP);
if (err < 0) {
up(&q->lock);
return err;
}
memset(mbuf,0,sizeof(*mbuf));
mbuf->frames = gbuffers;
mbuf->size = gbuffers * gbufsize;
for (i = 0; i < gbuffers; i++)
mbuf->offsets[i] = i * gbufsize;
up(&q->lock);
return 0;
}
default:
return v4l_compat_translate_ioctl(inode,file,cmd,arg,
saa7146_video_do_ioctl);
}
return 0;
}
/**
* vpif_reqbufs() - request buffer handler
* @file: file ptr
* @priv: file handle
* @reqbuf: request buffer structure ptr
*/
static int vpif_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *reqbuf)
{
struct vpif_fh *fh = priv;
struct channel_obj *ch = fh->channel;
struct common_obj *common;
u8 index = 0;
int ret = 0;
vpif_dbg(2, debug, "vpif_reqbufs\n");
/**
* This file handle has not initialized the channel,
* It is not allowed to do settings
*/
if ((VPIF_CHANNEL0_VIDEO == ch->channel_id)
|| (VPIF_CHANNEL1_VIDEO == ch->channel_id)) {
if (!fh->initialized) {
vpif_dbg(1, debug, "Channel Busy\n");
return -EBUSY;
}
}
if (V4L2_BUF_TYPE_VIDEO_CAPTURE != reqbuf->type)
return -EINVAL;
index = VPIF_VIDEO_INDEX;
common = &ch->common[index];
if (mutex_lock_interruptible(&common->lock))
return -ERESTARTSYS;
if (0 != common->io_usrs) {
ret = -EBUSY;
goto reqbuf_exit;
}
/* Initialize videobuf queue as per the buffer type */
videobuf_queue_dma_contig_init(&common->buffer_queue,
&video_qops, NULL,
&common->irqlock,
reqbuf->type,
common->fmt.fmt.pix.field,
sizeof(struct videobuf_buffer), fh);
/* Set io allowed member of file handle to TRUE */
fh->io_allowed[index] = 1;
/* Increment io usrs member of channel object to 1 */
common->io_usrs = 1;
/* Store type of memory requested in channel object */
common->memory = reqbuf->memory;
INIT_LIST_HEAD(&common->dma_queue);
/* Allocate buffers */
ret = videobuf_reqbufs(&common->buffer_queue, reqbuf);
reqbuf_exit:
mutex_unlock(&common->lock);
return ret;
}
/**
* previewer_ioctl - I/O control function for Preview Wrapper
* @inode: Inode structure associated with the Preview Wrapper.
* @file: File structure associated with the Preview Wrapper.
* @cmd: Type of command to execute.
* @arg: Argument to send to requested command.
*
* Returns 0 if successful, -1 if bad command passed or access is denied,
* -EFAULT if copy_from_user() or copy_to_user() fails, -EINVAL if parameter
* validation fails or parameter structure is not present
**/
static int previewer_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
int ret = 0;
struct prev_params params;
struct prev_fh *fh = file->private_data;
struct prev_device *device = fh->device;
dev_dbg(prev_dev, "Entering previewer_ioctl()\n");
if ((_IOC_TYPE(cmd) != PREV_IOC_BASE)
|| (_IOC_NR(cmd) > PREV_IOC_MAXNR)) {
dev_err(prev_dev, "Bad command Value \n");
goto err_minusone;
}
if (_IOC_DIR(cmd) & _IOC_READ)
ret = !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd));
else if (_IOC_DIR(cmd) & _IOC_WRITE)
ret = !access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd));
if (ret) {
dev_err(prev_dev, "access denied\n");
goto err_minusone;
}
switch (cmd) {
case PREV_REQBUF:
{
struct v4l2_requestbuffers *req;
if (mutex_lock_interruptible(&device->prevwrap_mutex))
goto err_eintr;
req = (struct v4l2_requestbuffers *) arg;
if (req->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
ret = videobuf_reqbufs(&fh->inout_vbq, (void *) arg);
else if (req->type == V4L2_BUF_TYPE_PRIVATE)
ret = videobuf_reqbufs(&fh->lsc_vbq, (void *) arg);
else
ret = -EINVAL;
mutex_unlock(&device->prevwrap_mutex);
break;
}
case PREV_QUERYBUF:
{
struct v4l2_buffer *b;
if (mutex_lock_interruptible(&device->prevwrap_mutex))
goto err_eintr;
b = (struct v4l2_buffer *) arg;
if (b->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
ret = videobuf_querybuf(&fh->inout_vbq, (void *) arg);
else if (b->type == V4L2_BUF_TYPE_PRIVATE)
ret = videobuf_querybuf(&fh->lsc_vbq, (void *) arg);
else
ret = -EINVAL;
mutex_unlock(&device->prevwrap_mutex);
break;
}
case PREV_QUEUEBUF:
{
struct v4l2_buffer *b;
if (mutex_lock_interruptible(&device->prevwrap_mutex))
goto err_eintr;
b = (struct v4l2_buffer *) arg;
if (b->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
ret = videobuf_qbuf(&fh->inout_vbq, (void *) arg);
else if (b->type == V4L2_BUF_TYPE_PRIVATE)
ret = videobuf_qbuf(&fh->lsc_vbq, (void *) arg);
else
ret = -EINVAL;
mutex_unlock(&device->prevwrap_mutex);
break;
}
case PREV_SET_PARAM:
if (mutex_lock_interruptible(&device->prevwrap_mutex))
goto err_eintr;
DPRINTK_PREVIEWER("%s PREV_SET_PARAMS before copy from user:\n",
__func__);
if (copy_from_user(¶ms, (struct prev_params *)arg,
sizeof(struct prev_params))) {
mutex_unlock(&device->prevwrap_mutex);
return -EFAULT;
}
DPRINTK_PREVIEWER("%s PREV_SET_PARAMS before prev validate "
"params:\n", __func__);
ret = prev_validate_params(¶ms);
if (ret < 0) {
dev_err(prev_dev, "Error validating parameters!\n");
mutex_unlock(&device->prevwrap_mutex);
goto out;
}
DPRINTK_PREVIEWER("%s PREV_SET_PARAMSbefore memcopy:\n",
__func__);
if (device->params)
memcpy(device->params, ¶ms,
sizeof(struct prev_params));
else {
mutex_unlock(&device->prevwrap_mutex);
return -EINVAL;
}
/* ret = prev_hw_setup(device->params); */
mutex_unlock(&device->prevwrap_mutex);
break;
case PREV_GET_PARAM:
if (copy_to_user((struct prev_params *)arg, device->params,
sizeof(struct prev_params)))
ret = -EFAULT;
break;
case PREV_GET_STATUS:
ret = prev_get_status((struct prev_status *)arg);
break;
case PREV_PREVIEW:
if (mutex_lock_interruptible(&device->prevwrap_mutex))
goto err_eintr;
ret = prev_do_preview(device, (int *)arg);
mutex_unlock(&device->prevwrap_mutex);
break;
case PREV_GET_CROPSIZE:
{
struct prev_cropsize outputsize;
prev_calculate_crop(device, &outputsize);
if (copy_to_user((struct prev_cropsize *)arg, &outputsize,
sizeof(struct prev_cropsize)))
ret = -EFAULT;
}
break;
default:
dev_err(prev_dev, "previewer_ioctl: Invalid Command Value\n");
ret = -EINVAL;
}
out:
return ret;
err_minusone:
return -1;
err_eintr:
return -EINTR;
}
/**
* prev2resz_ioctl - I/O control function for device
*/
static int prev2resz_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct prev2resz_fhdl *fh = file->private_data;
long rval = 0;
if ((_IOC_TYPE(cmd) != PREV2RESZ_IOC_BASE) && (_IOC_TYPE(cmd) != 'M') &&
(cmd < BASE_VIDIOC_PRIVATE)) {
dev_err(p2r_device, "Bad command value.\n");
return -EFAULT;
}
if (_IOC_DIR(cmd) & _IOC_READ)
rval = !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd));
else if (_IOC_DIR(cmd) & _IOC_WRITE)
rval = !access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd));
if (rval) {
dev_err(p2r_device, "Access denied\n");
return -EFAULT;
}
switch (cmd) {
case PREV2RESZ_REQBUF:
{
struct v4l2_requestbuffers v4l2_req;
if (copy_from_user(&v4l2_req, (void *)arg,
sizeof(struct v4l2_requestbuffers)))
return -EIO;
if (v4l2_req.type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
if (videobuf_reqbufs(&fh->src_vbq, &v4l2_req) < 0)
return -EINVAL;
} else if (v4l2_req.type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
if (videobuf_reqbufs(&fh->dst_vbq, &v4l2_req) < 0)
return -EINVAL;
}
if (copy_to_user((void *)arg, &v4l2_req,
sizeof(struct v4l2_requestbuffers)))
return -EIO;
break;
}
case PREV2RESZ_QUERYBUF:
{
struct v4l2_buffer v4l2_buf;
if (copy_from_user(&v4l2_buf, (void *)arg,
sizeof(struct v4l2_buffer)))
return -EIO;
if (v4l2_buf.type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
if (videobuf_querybuf(&fh->src_vbq, &v4l2_buf) < 0)
return -EINVAL;
} else if (v4l2_buf.type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
if (videobuf_querybuf(&fh->dst_vbq, &v4l2_buf) < 0)
return -EINVAL;
}
if (copy_to_user((void *)arg, &v4l2_buf,
sizeof(struct v4l2_buffer)))
return -EIO;
break;
}
case PREV2RESZ_QUEUEBUF:
{
struct v4l2_buffer v4l2_buf;
if (copy_from_user(&v4l2_buf, (void *)arg,
sizeof(struct v4l2_buffer)))
return -EIO;
if (v4l2_buf.type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
if (videobuf_qbuf(&fh->src_vbq, &v4l2_buf) < 0)
return -EINVAL;
} else if (v4l2_buf.type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
if (videobuf_qbuf(&fh->dst_vbq, &v4l2_buf) < 0)
return -EINVAL;
}
if (copy_to_user((void *)arg, &v4l2_buf,
sizeof(struct v4l2_buffer)))
return -EIO;
break;
}
case PREV2RESZ_SET_CONFIG:
if (copy_from_user(&fh->pipe, (void *)arg,
sizeof(fh->pipe)))
return -EIO;
if (prev2resz_ioc_set_config(fh) < 0)
return -EINVAL;
if (copy_to_user((void *)arg, &fh->pipe,
sizeof(fh->pipe)))
return -EIO;
break;
case PREV2RESZ_GET_CONFIG:
if (copy_to_user((void *)arg, &fh->pipe,
sizeof(fh->pipe)))
return -EIO;
break;
case PREV2RESZ_RUN_ENGINE:
if (file->f_flags & O_NONBLOCK) {
if (isppreview_busy(fh->isp_prev))
return -EBUSY;
if (ispresizer_busy(fh->isp_resz))
return -EBUSY;
}
if (prev2resz_ioc_run_engine(fh) < 0)
return -EINVAL;
break;
case PREV2RESZ_GET_STATUS:
{
struct prev2resz_status *status =
(struct prev2resz_status *)arg;
status->prv_busy = isppreview_busy(fh->isp_prev);
status->rsz_busy = ispresizer_busy(fh->isp_resz);
break;
}
case VIDIOC_QUERYCAP:
{
struct v4l2_capability v4l2_cap;
if (copy_from_user(&v4l2_cap, (void *)arg,
sizeof(struct v4l2_capability)))
return -EIO;
strcpy(v4l2_cap.driver, "omap3wrapper");
strcpy(v4l2_cap.card, "omap3wrapper/prev-resz");
v4l2_cap.version = 1.0;;
v4l2_cap.capabilities = V4L2_CAP_VIDEO_CAPTURE |
V4L2_CAP_READWRITE;
if (copy_to_user((void *)arg, &v4l2_cap,
sizeof(struct v4l2_capability)))
return -EIO;
break;
}
case VIDIOC_PRIVATE_ISP_PRV_CFG:
if (isppreview_config(fh->isp_prev, (void *)arg))
return -EIO;
break;
default:
dev_err(p2r_device, "IOC: Invalid Command Value!\n");
return -EINVAL;
}
return 0;
}
static int vidioc_reqbufs(struct file *file, void *priv, struct v4l2_requestbuffers *p)
{
struct unicorn_fh *fh = priv;
return videobuf_reqbufs(&fh->vidq, p);
}
static int myvivi_vidioc_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *p)
{
return (videobuf_reqbufs(&myvivi_vb_vidquene, p));
}
