2 * drivers/sbus/char/vfc_dev.c
4 * Driver for the Videopix Frame Grabber.
6 * In order to use the VFC you need to program the video controller
7 * chip. This chip is the Phillips SAA9051. You need to call their
8 * documentation ordering line to get the docs.
10 * There is very little documentation on the VFC itself. There is
11 * some useful info that can be found in the manuals that come with
12 * the card. I will hopefully write some better docs at a later date.
14 * Copyright (C) 1996 Manish Vachharajani (mvachhar@noc.rutgers.edu)
17 #include <linux/module.h>
18 #include <linux/kernel.h>
19 #include <linux/string.h>
20 #include <linux/slab.h>
21 #include <linux/errno.h>
22 #include <linux/sched.h>
24 #include <linux/smp_lock.h>
25 #include <linux/delay.h>
26 #include <linux/spinlock.h>
29 #include <asm/openprom.h>
30 #include <asm/oplib.h>
32 #include <asm/system.h>
35 #include <asm/pgtable.h>
36 #include <asm/uaccess.h>
38 #define VFC_MAJOR (60)
41 #define VFC_IOCTL_DEBUG
45 #include <asm/vfc_ioctls.h>
47 static struct file_operations vfc_fops;
48 struct vfc_dev **vfc_dev_lst;
49 static char vfcstr[]="vfc";
50 static unsigned char saa9051_init_array[VFC_SAA9051_NR] = {
51 0x00, 0x64, 0x72, 0x52,
52 0x36, 0x18, 0xff, 0x20,
53 0xfc, 0x77, 0xe3, 0x50,
57 void vfc_lock_device(struct vfc_dev *dev)
59 down(&dev->device_lock_sem);
62 void vfc_unlock_device(struct vfc_dev *dev)
64 up(&dev->device_lock_sem);
68 void vfc_captstat_reset(struct vfc_dev *dev)
70 dev->control_reg |= VFC_CONTROL_CAPTRESET;
71 sbus_writel(dev->control_reg, &dev->regs->control);
72 dev->control_reg &= ~VFC_CONTROL_CAPTRESET;
73 sbus_writel(dev->control_reg, &dev->regs->control);
74 dev->control_reg |= VFC_CONTROL_CAPTRESET;
75 sbus_writel(dev->control_reg, &dev->regs->control);
78 void vfc_memptr_reset(struct vfc_dev *dev)
80 dev->control_reg |= VFC_CONTROL_MEMPTR;
81 sbus_writel(dev->control_reg, &dev->regs->control);
82 dev->control_reg &= ~VFC_CONTROL_MEMPTR;
83 sbus_writel(dev->control_reg, &dev->regs->control);
84 dev->control_reg |= VFC_CONTROL_MEMPTR;
85 sbus_writel(dev->control_reg, &dev->regs->control);
88 int vfc_csr_init(struct vfc_dev *dev)
90 dev->control_reg = 0x80000000;
91 sbus_writel(dev->control_reg, &dev->regs->control);
93 dev->control_reg &= ~0x80000000;
94 sbus_writel(dev->control_reg, &dev->regs->control);
96 sbus_writel(0x0f000000, &dev->regs->i2c_magic2);
98 vfc_memptr_reset(dev);
100 dev->control_reg &= ~VFC_CONTROL_DIAGMODE;
101 dev->control_reg &= ~VFC_CONTROL_CAPTURE;
102 dev->control_reg |= 0x40000000;
103 sbus_writel(dev->control_reg, &dev->regs->control);
105 vfc_captstat_reset(dev);
110 int vfc_saa9051_init(struct vfc_dev *dev)
114 for (i = 0; i < VFC_SAA9051_NR; i++)
115 dev->saa9051_state_array[i] = saa9051_init_array[i];
117 vfc_i2c_sendbuf(dev,VFC_SAA9051_ADDR,
118 dev->saa9051_state_array, VFC_SAA9051_NR);
122 int init_vfc_hw(struct vfc_dev *dev)
124 vfc_lock_device(dev);
127 vfc_pcf8584_init(dev);
128 vfc_init_i2c_bus(dev); /* hopefully this doesn't undo the magic
130 vfc_saa9051_init(dev);
131 vfc_unlock_device(dev);
135 int init_vfc_devstruct(struct vfc_dev *dev, int instance)
137 dev->instance=instance;
138 init_MUTEX(&dev->device_lock_sem);
140 init_waitqueue_head(&dev->poll_wait);
145 int init_vfc_device(struct sbus_dev *sdev,struct vfc_dev *dev, int instance)
148 printk(KERN_ERR "VFC: Bogus pointer passed\n");
151 printk("Initializing vfc%d\n",instance);
153 dev->regs = (volatile struct vfc_regs *)
154 sbus_ioremap(&sdev->resource[0], 0,
155 sizeof(struct vfc_regs), vfcstr);
156 dev->which_io = sdev->reg_addrs[0].which_io;
157 dev->phys_regs = (struct vfc_regs *) sdev->reg_addrs[0].phys_addr;
158 if (dev->regs == NULL)
161 printk("vfc%d: registers mapped at phys_addr: 0x%lx\n virt_addr: 0x%lx\n",
162 instance,(unsigned long)sdev->reg_addrs[0].phys_addr,(unsigned long)dev->regs);
164 if (init_vfc_devstruct(dev, instance))
166 if (init_vfc_hw(dev))
169 devfs_mk_cdev(MKDEV(VFC_MAJOR, instance),
170 S_IFCHR | S_IRUSR | S_IWUSR,
176 struct vfc_dev *vfc_get_dev_ptr(int instance)
178 return vfc_dev_lst[instance];
181 static spinlock_t vfc_dev_lock = SPIN_LOCK_UNLOCKED;
183 static int vfc_open(struct inode *inode, struct file *file)
187 spin_lock(&vfc_dev_lock);
188 dev = vfc_get_dev_ptr(iminor(inode));
190 spin_unlock(&vfc_dev_lock);
194 spin_unlock(&vfc_dev_lock);
199 spin_unlock(&vfc_dev_lock);
201 vfc_lock_device(dev);
204 vfc_pcf8584_init(dev);
205 vfc_init_i2c_bus(dev);
206 vfc_saa9051_init(dev);
207 vfc_memptr_reset(dev);
208 vfc_captstat_reset(dev);
210 vfc_unlock_device(dev);
214 static int vfc_release(struct inode *inode,struct file *file)
218 spin_lock(&vfc_dev_lock);
219 dev = vfc_get_dev_ptr(iminor(inode));
220 if (!dev || !dev->busy) {
221 spin_unlock(&vfc_dev_lock);
225 spin_unlock(&vfc_dev_lock);
229 static int vfc_debug(struct vfc_dev *dev, int cmd, unsigned long arg)
231 struct vfc_debug_inout inout;
232 unsigned char *buffer;
234 if (!capable(CAP_SYS_ADMIN))
239 if(copy_from_user(&inout, (void *)arg, sizeof(inout)))
242 buffer = kmalloc(inout.len*sizeof(char), GFP_KERNEL);
246 if(copy_from_user(buffer, inout.buffer,
247 inout.len*sizeof(char))) {
253 vfc_lock_device(dev);
255 vfc_i2c_sendbuf(dev,inout.addr & 0xff,
256 inout.buffer,inout.len);
258 if (copy_to_user((void *)arg,&inout,sizeof(inout))) {
262 vfc_unlock_device(dev);
266 if (copy_from_user(&inout, (void *)arg, sizeof(inout)))
269 buffer = kmalloc(inout.len, GFP_KERNEL);
273 memset(buffer,0,inout.len*sizeof(char));
274 vfc_lock_device(dev);
276 vfc_i2c_recvbuf(dev,inout.addr & 0xff
278 vfc_unlock_device(dev);
280 if (copy_to_user(inout.buffer, buffer, inout.len)) {
284 if (copy_to_user((void *)arg,&inout,sizeof(inout))) {
297 int vfc_capture_start(struct vfc_dev *dev)
299 vfc_captstat_reset(dev);
300 dev->control_reg = sbus_readl(&dev->regs->control);
301 if((dev->control_reg & VFC_STATUS_CAPTURE)) {
302 printk(KERN_ERR "vfc%d: vfc capture status not reset\n",
307 vfc_lock_device(dev);
308 dev->control_reg &= ~VFC_CONTROL_CAPTURE;
309 sbus_writel(dev->control_reg, &dev->regs->control);
310 dev->control_reg |= VFC_CONTROL_CAPTURE;
311 sbus_writel(dev->control_reg, &dev->regs->control);
312 dev->control_reg &= ~VFC_CONTROL_CAPTURE;
313 sbus_writel(dev->control_reg, &dev->regs->control);
314 vfc_unlock_device(dev);
319 int vfc_capture_poll(struct vfc_dev *dev)
324 if (dev->regs->control & VFC_STATUS_CAPTURE)
326 vfc_i2c_delay_no_busy(dev, 100);
329 printk(KERN_WARNING "vfc%d: capture timed out\n",
338 static int vfc_set_control_ioctl(struct inode *inode, struct file *file,
339 struct vfc_dev *dev, unsigned long arg)
343 if (copy_from_user(&setcmd,(void *)arg,sizeof(unsigned int)))
346 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCSCTRL) arg=0x%x\n",
347 dev->instance,setcmd));
351 vfc_lock_device(dev);
352 vfc_memptr_reset(dev);
353 vfc_unlock_device(dev);
357 vfc_capture_start(dev);
358 vfc_capture_poll(dev);
361 if(capable(CAP_SYS_ADMIN)) {
362 vfc_lock_device(dev);
363 dev->control_reg |= VFC_CONTROL_DIAGMODE;
364 sbus_writel(dev->control_reg, &dev->regs->control);
365 vfc_unlock_device(dev);
372 vfc_lock_device(dev);
373 dev->control_reg &= ~VFC_CONTROL_DIAGMODE;
374 sbus_writel(dev->control_reg, &dev->regs->control);
375 vfc_unlock_device(dev);
379 vfc_capture_start(dev);
383 vfc_capture_poll(dev);
395 int vfc_port_change_ioctl(struct inode *inode, struct file *file,
396 struct vfc_dev *dev, unsigned long arg)
401 if(copy_from_user(&cmd, (void *)arg, sizeof(unsigned int))) {
402 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
403 "vfc_port_change_ioctl\n",
408 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCPORTCHG) arg=0x%x\n",
409 dev->instance, cmd));
414 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_START) = 0x72;
415 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_STOP) = 0x52;
416 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_START) = 0x36;
417 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_STOP) = 0x18;
418 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) = VFC_SAA9051_BP2;
419 VFC_SAA9051_SA(dev,VFC_SAA9051_C3) = VFC_SAA9051_CT | VFC_SAA9051_SS3;
420 VFC_SAA9051_SA(dev,VFC_SAA9051_SECAM_DELAY) = 0x3e;
423 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_START) = 0x3a;
424 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_STOP) = 0x17;
425 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_START) = 0xfa;
426 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_STOP) = 0xde;
427 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) =
428 VFC_SAA9051_BY | VFC_SAA9051_PF | VFC_SAA9051_BP2;
429 VFC_SAA9051_SA(dev,VFC_SAA9051_C3) = VFC_SAA9051_YC;
430 VFC_SAA9051_SA(dev,VFC_SAA9051_SECAM_DELAY) = 0;
431 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) &=
432 ~(VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
442 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) |=
443 (VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
446 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) &=
447 ~(VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
448 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) |= VFC_SAA9051_SS0;
457 VFC_SAA9051_SA(dev,VFC_SAA9051_C3) &= ~(VFC_SAA9051_SS2);
458 ret=vfc_update_saa9051(dev);
460 VFC_SAA9051_SA(dev,VFC_SAA9051_C3) |= (VFC_SAA9051_SS2);
461 ret=vfc_update_saa9051(dev);
465 int vfc_set_video_ioctl(struct inode *inode, struct file *file,
466 struct vfc_dev *dev, unsigned long arg)
471 if(copy_from_user(&cmd, (void *)arg, sizeof(unsigned int))) {
472 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
473 "vfc_set_video_ioctl\n",
478 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCSVID) arg=0x%x\n",
479 dev->instance, cmd));
482 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~VFC_SAA9051_ALT;
483 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_YPN |
484 VFC_SAA9051_CCFR0 | VFC_SAA9051_CCFR1 | VFC_SAA9051_FS;
485 ret = vfc_update_saa9051(dev);
488 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~(VFC_SAA9051_YPN |
492 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_ALT;
493 ret = vfc_update_saa9051(dev);
497 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_CO;
498 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) &=
499 ~(VFC_SAA9051_BY | VFC_SAA9051_PF);
500 ret = vfc_update_saa9051(dev);
503 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~(VFC_SAA9051_CO);
504 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) |=
505 (VFC_SAA9051_BY | VFC_SAA9051_PF);
506 ret = vfc_update_saa9051(dev);
516 int vfc_get_video_ioctl(struct inode *inode, struct file *file,
517 struct vfc_dev *dev, unsigned long arg)
520 unsigned int status = NO_LOCK;
521 unsigned char buf[1];
523 if(vfc_i2c_recvbuf(dev, VFC_SAA9051_ADDR, buf, 1)) {
524 printk(KERN_ERR "vfc%d: Unable to get status\n",
529 if(buf[0] & VFC_SAA9051_HLOCK) {
531 } else if(buf[0] & VFC_SAA9051_FD) {
532 if(buf[0] & VFC_SAA9051_CD)
535 status = NTSC_NOCOLOR;
537 if(buf[0] & VFC_SAA9051_CD)
540 status = PAL_NOCOLOR;
542 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCGVID) returning status 0x%x; "
543 "buf[0]=%x\n", dev->instance, status, buf[0]));
545 if (copy_to_user((void *)arg,&status,sizeof(unsigned int))) {
546 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
547 "vfc_get_video_ioctl\n",
554 static int vfc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
561 dev = vfc_get_dev_ptr(iminor(inode));
565 switch(cmd & 0x0000ffff) {
568 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCGCTRL)\n", dev->instance));
570 tmp = sbus_readl(&dev->regs->control);
571 if(copy_to_user((void *)arg, &tmp, sizeof(unsigned int))) {
578 ret = vfc_set_control_ioctl(inode, file, dev, arg);
581 ret = vfc_get_video_ioctl(inode, file, dev, arg);
584 ret = vfc_set_video_ioctl(inode, file, dev, arg);
587 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCHUE)\n", dev->instance));
588 if(copy_from_user(&tmp,(void *)arg,sizeof(unsigned int))) {
589 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer "
590 "to IOCTL(VFCHUE)", dev->instance));
593 VFC_SAA9051_SA(dev,VFC_SAA9051_HUE) = tmp;
594 vfc_update_saa9051(dev);
599 ret = vfc_port_change_ioctl(inode, file, dev, arg);
603 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCRDINFO)\n", dev->instance));
606 ret = vfc_debug(vfc_get_dev_ptr(iminor(inode)),
614 static int vfc_mmap(struct inode *inode, struct file *file,
615 struct vm_area_struct *vma)
617 unsigned int map_size, ret, map_offset;
620 dev = vfc_get_dev_ptr(iminor(inode));
624 map_size = vma->vm_end - vma->vm_start;
625 if(map_size > sizeof(struct vfc_regs))
626 map_size = sizeof(struct vfc_regs);
629 (VM_SHM | VM_LOCKED | VM_IO | VM_MAYREAD | VM_MAYWRITE | VM_MAYSHARE);
630 map_offset = (unsigned int) (long)dev->phys_regs;
631 ret = io_remap_page_range(vma, vma->vm_start, map_offset, map_size,
632 vma->vm_page_prot, dev->which_io);
641 static struct file_operations vfc_fops = {
642 .owner = THIS_MODULE,
647 .release = vfc_release,
650 static int vfc_probe(void)
652 struct sbus_bus *sbus;
653 struct sbus_dev *sdev = NULL;
655 int instance = 0, cards = 0;
657 for_all_sbusdev(sdev, sbus) {
658 if (strcmp(sdev->prom_name, "vfc") == 0) {
667 vfc_dev_lst = (struct vfc_dev **)kmalloc(sizeof(struct vfc_dev *) *
670 if (vfc_dev_lst == NULL)
672 memset(vfc_dev_lst, 0, sizeof(struct vfc_dev *) * (cards + 1));
673 vfc_dev_lst[cards] = NULL;
675 ret = register_chrdev(VFC_MAJOR, vfcstr, &vfc_fops);
677 printk(KERN_ERR "Unable to get major number %d\n", VFC_MAJOR);
683 for_all_sbusdev(sdev, sbus) {
684 if (strcmp(sdev->prom_name, "vfc") == 0) {
685 vfc_dev_lst[instance]=(struct vfc_dev *)
686 kmalloc(sizeof(struct vfc_dev), GFP_KERNEL);
687 if (vfc_dev_lst[instance] == NULL)
689 ret = init_vfc_device(sdev,
690 vfc_dev_lst[instance],
693 printk(KERN_ERR "Unable to initialize"
708 int init_module(void)
717 static void deinit_vfc_device(struct vfc_dev *dev)
721 devfs_remove("vfc/%d", dev->instance);
722 sbus_iounmap((unsigned long)dev->regs, sizeof(struct vfc_regs));
726 void cleanup_module(void)
728 struct vfc_dev **devp;
730 unregister_chrdev(VFC_MAJOR,vfcstr);
732 for (devp = vfc_dev_lst; *devp; devp++)
733 deinit_vfc_device(*devp);
741 MODULE_LICENSE("GPL");