/* video4linux integration */
/****************************************************************************/
-static int meye_open(struct video_device *dev, int flags) {
- int i;
+static int meye_open(struct inode *inode, struct file *file) {
+ int i, err;
- down(&meye.lock);
- if (meye.open_count) {
- up(&meye.lock);
- return -EBUSY;
- }
- meye.open_count++;
+ err = video_exclusive_open(inode,file);
+ if (err < 0)
+ return err;
+
if (mchip_dma_alloc()) {
printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
- up(&meye.lock);
+ video_exclusive_release(inode,file);
return -ENOBUFS;
}
mchip_hic_stop();
meye_initq(&meye.grabq);
for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
- up(&meye.lock);
return 0;
}
-static void meye_close(struct video_device *dev) {
- down(&meye.lock);
- meye.open_count--;
+static int meye_release(struct inode *inode, struct file *file) {
mchip_hic_stop();
- up(&meye.lock);
+ video_exclusive_release(inode,file);
+ return 0;
}
-static int meye_ioctl(struct video_device *dev, unsigned int cmd, void *arg) {
+static int meye_ioctl(struct inode *inode, struct file *file,
+ unsigned int cmd, void *arg) {
switch (cmd) {
case VIDIOCGCAP: {
- struct video_capability b;
- strcpy(b.name,meye.video_dev.name);
- b.type = VID_TYPE_CAPTURE;
- b.channels = 1;
- b.audios = 0;
- b.maxwidth = 640;
- b.maxheight = 480;
- b.minwidth = 320;
- b.minheight = 240;
- if(copy_to_user(arg,&b,sizeof(b)))
- return -EFAULT;
+ struct video_capability *b = arg;
+ strcpy(b->name,meye.video_dev.name);
+ b->type = VID_TYPE_CAPTURE;
+ b->channels = 1;
+ b->audios = 0;
+ b->maxwidth = 640;
+ b->maxheight = 480;
+ b->minwidth = 320;
+ b->minheight = 240;
break;
}
case VIDIOCGCHAN: {
- struct video_channel v;
- if(copy_from_user(&v, arg,sizeof(v)))
- return -EFAULT;
- v.flags = 0;
- v.tuners = 0;
- v.type = VIDEO_TYPE_CAMERA;
- if (v.channel != 0)
+ struct video_channel *v = arg;
+ v->flags = 0;
+ v->tuners = 0;
+ v->type = VIDEO_TYPE_CAMERA;
+ if (v->channel != 0)
return -EINVAL;
- strcpy(v.name,"Camera");
- if(copy_to_user(arg,&v,sizeof(v)))
- return -EFAULT;
+ strcpy(v->name,"Camera");
break;
}
case VIDIOCSCHAN: {
- struct video_channel v;
- if(copy_from_user(&v, arg,sizeof(v)))
- return -EFAULT;
- if (v.channel != 0)
+ struct video_channel *v = arg;
+ if (v->channel != 0)
return -EINVAL;
break;
}
case VIDIOCGPICT: {
- struct video_picture p = meye.picture;
- if(copy_to_user(arg, &p, sizeof(p)))
- return -EFAULT;
+ struct video_picture *p = arg;
+ *p = meye.picture;
break;
}
case VIDIOCSPICT: {
- struct video_picture p;
- if(copy_from_user(&p, arg,sizeof(p)))
- return -EFAULT;
- if (p.depth != 2)
+ struct video_picture *p = arg;
+ if (p->depth != 2)
return -EINVAL;
- if (p.palette != VIDEO_PALETTE_YUV422)
+ if (p->palette != VIDEO_PALETTE_YUV422)
return -EINVAL;
down(&meye.lock);
sonypi_camera_command(SONYPI_COMMAND_SETCAMERABRIGHTNESS,
- p.brightness >> 10);
+ p->brightness >> 10);
sonypi_camera_command(SONYPI_COMMAND_SETCAMERAHUE,
- p.hue >> 10);
+ p->hue >> 10);
sonypi_camera_command(SONYPI_COMMAND_SETCAMERACOLOR,
- p.colour >> 10);
+ p->colour >> 10);
sonypi_camera_command(SONYPI_COMMAND_SETCAMERACONTRAST,
- p.contrast >> 10);
- memcpy(&meye.picture, &p, sizeof(p));
+ p->contrast >> 10);
+ meye.picture = *p;
up(&meye.lock);
break;
}
case VIDIOCSYNC: {
- int i;
+ int *i = arg;
DECLARE_WAITQUEUE(wait, current);
- if(copy_from_user((void *)&i,arg,sizeof(int)))
- return -EFAULT;
- if (i < 0 || i >= gbuffers)
+ if (*i < 0 || *i >= gbuffers)
return -EINVAL;
- switch (meye.grab_buffer[i].state) {
+ switch (meye.grab_buffer[*i].state) {
case MEYE_BUF_UNUSED:
return -EINVAL;
case MEYE_BUF_USING:
add_wait_queue(&meye.grabq.proc_list, &wait);
current->state = TASK_INTERRUPTIBLE;
- while (meye.grab_buffer[i].state == MEYE_BUF_USING) {
+ while (meye.grab_buffer[*i].state == MEYE_BUF_USING) {
schedule();
if(signal_pending(current)) {
remove_wait_queue(&meye.grabq.proc_list, &wait);
current->state = TASK_RUNNING;
/* fall through */
case MEYE_BUF_DONE:
- meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
+ meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
}
break;
}
case VIDIOCMCAPTURE: {
- struct video_mmap vm;
+ struct video_mmap *vm = arg;
int restart = 0;
- if(copy_from_user((void *) &vm, (void *) arg, sizeof(vm)))
- return -EFAULT;
- if (vm.frame >= gbuffers || vm.frame < 0)
+ if (vm->frame >= gbuffers || vm->frame < 0)
return -EINVAL;
- if (vm.format != VIDEO_PALETTE_YUV422)
+ if (vm->format != VIDEO_PALETTE_YUV422)
return -EINVAL;
- if (vm.height * vm.width * 2 > gbufsize)
+ if (vm->height * vm->width * 2 > gbufsize)
return -EINVAL;
if (!meye.grab_fbuffer)
return -EINVAL;
- if (meye.grab_buffer[vm.frame].state != MEYE_BUF_UNUSED)
+ if (meye.grab_buffer[vm->frame].state != MEYE_BUF_UNUSED)
return -EBUSY;
down(&meye.lock);
- if (vm.width == 640 && vm.height == 480) {
+ if (vm->width == 640 && vm->height == 480) {
if (meye.params.subsample) {
meye.params.subsample = 0;
restart = 1;
}
}
- else if (vm.width == 320 && vm.height == 240) {
+ else if (vm->width == 320 && vm->height == 240) {
if (!meye.params.subsample) {
meye.params.subsample = 1;
restart = 1;
if (restart || meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT)
mchip_continuous_start();
- meye.grab_buffer[vm.frame].state = MEYE_BUF_USING;
- meye_pushq(&meye.grabq, vm.frame);
+ meye.grab_buffer[vm->frame].state = MEYE_BUF_USING;
+ meye_pushq(&meye.grabq, vm->frame);
up(&meye.lock);
break;
}
case VIDIOCGMBUF: {
- struct video_mbuf vm;
+ struct video_mbuf *vm = arg;
int i;
- memset(&vm, 0 , sizeof(vm));
- vm.size = gbufsize * gbuffers;
- vm.frames = gbuffers;
+ memset(vm, 0 , sizeof(*vm));
+ vm->size = gbufsize * gbuffers;
+ vm->frames = gbuffers;
for (i = 0; i < gbuffers; i++)
- vm.offsets[i] = i * gbufsize;
- if(copy_to_user((void *)arg, (void *)&vm, sizeof(vm)))
- return -EFAULT;
+ vm->offsets[i] = i * gbufsize;
break;
}
case MEYEIOC_G_PARAMS: {
- if (copy_to_user(arg, &meye.params, sizeof(meye.params)))
- return -EFAULT;
+ struct meye_params *p = arg;
+ *p = meye.params;
break;
}
case MEYEIOC_S_PARAMS: {
- struct meye_params jp;
- if (copy_from_user(&jp, arg, sizeof(jp)))
- return -EFAULT;
- if (jp.subsample > 1)
+ struct meye_params *jp = arg;
+ if (jp->subsample > 1)
return -EINVAL;
- if (jp.quality > 10)
+ if (jp->quality > 10)
return -EINVAL;
- if (jp.sharpness > 63 || jp.agc > 63 || jp.picture > 63)
+ if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
return -EINVAL;
- if (jp.framerate > 31)
+ if (jp->framerate > 31)
return -EINVAL;
down(&meye.lock);
- if (meye.params.subsample != jp.subsample ||
- meye.params.quality != jp.quality)
+ if (meye.params.subsample != jp->subsample ||
+ meye.params.quality != jp->quality)
mchip_hic_stop(); /* need restart */
- memcpy(&meye.params, &jp, sizeof(jp));
+ meye.params = *jp;
sonypi_camera_command(SONYPI_COMMAND_SETCAMERASHARPNESS,
meye.params.sharpness);
sonypi_camera_command(SONYPI_COMMAND_SETCAMERAAGC,
}
case MEYEIOC_QBUF_CAPT: {
- int nb;
-
- if (copy_from_user((void *) &nb, (void *) arg, sizeof(int)))
- return -EFAULT;
+ int *nb = arg;
if (!meye.grab_fbuffer)
return -EINVAL;
- if (nb >= gbuffers)
+ if (*nb >= gbuffers)
return -EINVAL;
- if (nb < 0) {
+ if (*nb < 0) {
/* stop capture */
mchip_hic_stop();
return 0;
}
- if (meye.grab_buffer[nb].state != MEYE_BUF_UNUSED)
+ if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
return -EBUSY;
down(&meye.lock);
if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
mchip_cont_compression_start();
- meye.grab_buffer[nb].state = MEYE_BUF_USING;
- meye_pushq(&meye.grabq, nb);
+ meye.grab_buffer[*nb].state = MEYE_BUF_USING;
+ meye_pushq(&meye.grabq, *nb);
up(&meye.lock);
break;
}
case MEYEIOC_SYNC: {
- int i;
+ int *i = arg;
DECLARE_WAITQUEUE(wait, current);
- if(copy_from_user((void *)&i,arg,sizeof(int)))
- return -EFAULT;
- if (i < 0 || i >= gbuffers)
+ if (*i < 0 || *i >= gbuffers)
return -EINVAL;
- switch (meye.grab_buffer[i].state) {
+ switch (meye.grab_buffer[*i].state) {
case MEYE_BUF_UNUSED:
return -EINVAL;
case MEYE_BUF_USING:
add_wait_queue(&meye.grabq.proc_list, &wait);
current->state = TASK_INTERRUPTIBLE;
- while (meye.grab_buffer[i].state == MEYE_BUF_USING) {
+ while (meye.grab_buffer[*i].state == MEYE_BUF_USING) {
schedule();
if(signal_pending(current)) {
remove_wait_queue(&meye.grabq.proc_list, &wait);
current->state = TASK_RUNNING;
/* fall through */
case MEYE_BUF_DONE:
- meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
+ meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
}
- i = meye.grab_buffer[i].size;
- if (copy_to_user(arg, (void *)&i, sizeof(int)))
- return -EFAULT;
+ *i = meye.grab_buffer[*i].size;
break;
}
}
case MEYEIOC_STILLJCAPT: {
- int len = -1;
+ int *len = arg;
if (!meye.grab_fbuffer)
return -EINVAL;
return -EBUSY;
down(&meye.lock);
meye.grab_buffer[0].state = MEYE_BUF_USING;
- while (len == -1) {
+ *len = -1;
+ while (*len == -1) {
mchip_take_picture();
- len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
+ *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
}
meye.grab_buffer[0].state = MEYE_BUF_DONE;
up(&meye.lock);
- if (copy_to_user(arg, (void *)&len, sizeof(int)))
- return -EFAULT;
break;
}
return 0;
}
-static int meye_mmap(struct vm_area_struct *vma, struct video_device *dev, const char *adr,
- unsigned long size) {
- unsigned long start=(unsigned long) adr;
- unsigned long page,pos;
+static int meye_mmap(struct file *file, struct vm_area_struct *vma) {
+ unsigned long start = vma->vm_start;
+ unsigned long size = vma->vm_end - vma->vm_start;
+ unsigned long page, pos;
down(&meye.lock);
if (size > gbuffers * gbufsize) {
return 0;
}
+static struct file_operations meye_fops = {
+ owner: THIS_MODULE,
+ open: meye_open,
+ release: meye_release,
+ mmap: meye_mmap,
+ ioctl: video_generic_ioctl,
+ llseek: no_llseek,
+};
+
static struct video_device meye_template = {
owner: THIS_MODULE,
name: "meye",
type: VID_TYPE_CAPTURE,
hardware: VID_HARDWARE_MEYE,
- open: meye_open,
- close: meye_close,
- ioctl: meye_ioctl,
- mmap: meye_mmap,
+ fops: &meye_fops,
+ kernel_ioctl: meye_ioctl,
};
static int __devinit meye_probe(struct pci_dev *pcidev,
projects / linux / commitdiff