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>
28 #include <asm/openprom.h>
29 #include <asm/oplib.h>
31 #include <asm/system.h>
34 #include <asm/pgtable.h>
35 #include <asm/uaccess.h>
37 #define VFC_MAJOR (60)
40 #define VFC_IOCTL_DEBUG
44 #include <asm/vfc_ioctls.h>
46 static struct file_operations vfc_fops;
47 static devfs_handle_t devfs_handle; /* For the directory */
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)
150 printk(KERN_ERR "VFC: Bogus pointer passed\n");
153 printk("Initializing vfc%d\n",instance);
155 dev->regs = (volatile struct vfc_regs *)
156 sbus_ioremap(&sdev->resource[0], 0,
157 sizeof(struct vfc_regs), vfcstr);
158 dev->which_io = sdev->reg_addrs[0].which_io;
159 dev->phys_regs = (struct vfc_regs *) sdev->reg_addrs[0].phys_addr;
160 if (dev->regs == NULL)
163 printk("vfc%d: registers mapped at phys_addr: 0x%lx\n virt_addr: 0x%lx\n",
164 instance,(unsigned long)sdev->reg_addrs[0].phys_addr,(unsigned long)dev->regs);
166 if (init_vfc_devstruct(dev, instance))
168 if (init_vfc_hw(dev))
171 sprintf (devname, "%d", instance);
172 dev->de = devfs_register (devfs_handle, devname, DEVFS_FL_DEFAULT,
174 S_IFCHR | S_IRUSR | S_IWUSR,
180 struct vfc_dev *vfc_get_dev_ptr(int instance)
182 return vfc_dev_lst[instance];
185 static spinlock_t vfc_dev_lock = SPIN_LOCK_UNLOCKED;
187 static int vfc_open(struct inode *inode, struct file *file)
191 spin_lock(&vfc_dev_lock);
192 dev = vfc_get_dev_ptr(MINOR(inode->i_rdev));
194 spin_unlock(&vfc_dev_lock);
198 spin_unlock(&vfc_dev_lock);
203 spin_unlock(&vfc_dev_lock);
205 vfc_lock_device(dev);
208 vfc_pcf8584_init(dev);
209 vfc_init_i2c_bus(dev);
210 vfc_saa9051_init(dev);
211 vfc_memptr_reset(dev);
212 vfc_captstat_reset(dev);
214 vfc_unlock_device(dev);
218 static int vfc_release(struct inode *inode,struct file *file)
222 spin_lock(&vfc_dev_lock);
223 dev = vfc_get_dev_ptr(MINOR(inode->i_rdev));
224 if (!dev || !dev->busy) {
225 spin_unlock(&vfc_dev_lock);
229 spin_unlock(&vfc_dev_lock);
233 static int vfc_debug(struct vfc_dev *dev, int cmd, unsigned long arg)
235 struct vfc_debug_inout inout;
236 unsigned char *buffer;
238 if (!capable(CAP_SYS_ADMIN))
243 if(copy_from_user(&inout, (void *)arg, sizeof(inout)))
246 buffer = kmalloc(inout.len*sizeof(char), GFP_KERNEL);
250 if(copy_from_user(buffer, inout.buffer,
251 inout.len*sizeof(char))) {
257 vfc_lock_device(dev);
259 vfc_i2c_sendbuf(dev,inout.addr & 0xff,
260 inout.buffer,inout.len);
262 if (copy_to_user((void *)arg,&inout,sizeof(inout))) {
266 vfc_unlock_device(dev);
270 if (copy_from_user(&inout, (void *)arg, sizeof(inout)))
273 buffer = kmalloc(inout.len, GFP_KERNEL);
277 memset(buffer,0,inout.len*sizeof(char));
278 vfc_lock_device(dev);
280 vfc_i2c_recvbuf(dev,inout.addr & 0xff
282 vfc_unlock_device(dev);
284 if (copy_to_user(inout.buffer, buffer, inout.len)) {
288 if (copy_to_user((void *)arg,&inout,sizeof(inout))) {
301 int vfc_capture_start(struct vfc_dev *dev)
303 vfc_captstat_reset(dev);
304 dev->control_reg = sbus_readl(&dev->regs->control);
305 if((dev->control_reg & VFC_STATUS_CAPTURE)) {
306 printk(KERN_ERR "vfc%d: vfc capture status not reset\n",
311 vfc_lock_device(dev);
312 dev->control_reg &= ~VFC_CONTROL_CAPTURE;
313 sbus_writel(dev->control_reg, &dev->regs->control);
314 dev->control_reg |= VFC_CONTROL_CAPTURE;
315 sbus_writel(dev->control_reg, &dev->regs->control);
316 dev->control_reg &= ~VFC_CONTROL_CAPTURE;
317 sbus_writel(dev->control_reg, &dev->regs->control);
318 vfc_unlock_device(dev);
323 int vfc_capture_poll(struct vfc_dev *dev)
328 if (dev->regs->control & VFC_STATUS_CAPTURE)
330 vfc_i2c_delay_no_busy(dev, 100);
333 printk(KERN_WARNING "vfc%d: capture timed out\n",
342 static int vfc_set_control_ioctl(struct inode *inode, struct file *file,
343 struct vfc_dev *dev, unsigned long arg)
347 if (copy_from_user(&setcmd,(void *)arg,sizeof(unsigned int)))
350 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCSCTRL) arg=0x%x\n",
351 dev->instance,setcmd));
355 vfc_lock_device(dev);
356 vfc_memptr_reset(dev);
357 vfc_unlock_device(dev);
361 vfc_capture_start(dev);
362 vfc_capture_poll(dev);
365 if(capable(CAP_SYS_ADMIN)) {
366 vfc_lock_device(dev);
367 dev->control_reg |= VFC_CONTROL_DIAGMODE;
368 sbus_writel(dev->control_reg, &dev->regs->control);
369 vfc_unlock_device(dev);
376 vfc_lock_device(dev);
377 dev->control_reg &= ~VFC_CONTROL_DIAGMODE;
378 sbus_writel(dev->control_reg, &dev->regs->control);
379 vfc_unlock_device(dev);
383 vfc_capture_start(dev);
387 vfc_capture_poll(dev);
399 int vfc_port_change_ioctl(struct inode *inode, struct file *file,
400 struct vfc_dev *dev, unsigned long arg)
405 if(copy_from_user(&cmd, (void *)arg, sizeof(unsigned int))) {
406 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
407 "vfc_port_change_ioctl\n",
412 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCPORTCHG) arg=0x%x\n",
413 dev->instance, cmd));
418 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_START) = 0x72;
419 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_STOP) = 0x52;
420 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_START) = 0x36;
421 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_STOP) = 0x18;
422 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) = VFC_SAA9051_BP2;
423 VFC_SAA9051_SA(dev,VFC_SAA9051_C3) = VFC_SAA9051_CT | VFC_SAA9051_SS3;
424 VFC_SAA9051_SA(dev,VFC_SAA9051_SECAM_DELAY) = 0x3e;
427 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_START) = 0x3a;
428 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_STOP) = 0x17;
429 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_START) = 0xfa;
430 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_STOP) = 0xde;
431 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) =
432 VFC_SAA9051_BY | VFC_SAA9051_PF | VFC_SAA9051_BP2;
433 VFC_SAA9051_SA(dev,VFC_SAA9051_C3) = VFC_SAA9051_YC;
434 VFC_SAA9051_SA(dev,VFC_SAA9051_SECAM_DELAY) = 0;
435 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) &=
436 ~(VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
446 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) |=
447 (VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
450 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) &=
451 ~(VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
452 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) |= VFC_SAA9051_SS0;
461 VFC_SAA9051_SA(dev,VFC_SAA9051_C3) &= ~(VFC_SAA9051_SS2);
462 ret=vfc_update_saa9051(dev);
464 VFC_SAA9051_SA(dev,VFC_SAA9051_C3) |= (VFC_SAA9051_SS2);
465 ret=vfc_update_saa9051(dev);
469 int vfc_set_video_ioctl(struct inode *inode, struct file *file,
470 struct vfc_dev *dev, unsigned long arg)
475 if(copy_from_user(&cmd, (void *)arg, sizeof(unsigned int))) {
476 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
477 "vfc_set_video_ioctl\n",
482 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCSVID) arg=0x%x\n",
483 dev->instance, cmd));
486 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~VFC_SAA9051_ALT;
487 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_YPN |
488 VFC_SAA9051_CCFR0 | VFC_SAA9051_CCFR1 | VFC_SAA9051_FS;
489 ret = vfc_update_saa9051(dev);
492 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~(VFC_SAA9051_YPN |
496 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_ALT;
497 ret = vfc_update_saa9051(dev);
501 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_CO;
502 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) &=
503 ~(VFC_SAA9051_BY | VFC_SAA9051_PF);
504 ret = vfc_update_saa9051(dev);
507 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~(VFC_SAA9051_CO);
508 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) |=
509 (VFC_SAA9051_BY | VFC_SAA9051_PF);
510 ret = vfc_update_saa9051(dev);
520 int vfc_get_video_ioctl(struct inode *inode, struct file *file,
521 struct vfc_dev *dev, unsigned long arg)
524 unsigned int status = NO_LOCK;
525 unsigned char buf[1];
527 if(vfc_i2c_recvbuf(dev, VFC_SAA9051_ADDR, buf, 1)) {
528 printk(KERN_ERR "vfc%d: Unable to get status\n",
533 if(buf[0] & VFC_SAA9051_HLOCK) {
535 } else if(buf[0] & VFC_SAA9051_FD) {
536 if(buf[0] & VFC_SAA9051_CD)
539 status = NTSC_NOCOLOR;
541 if(buf[0] & VFC_SAA9051_CD)
544 status = PAL_NOCOLOR;
546 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCGVID) returning status 0x%x; "
547 "buf[0]=%x\n", dev->instance, status, buf[0]));
549 if (copy_to_user((void *)arg,&status,sizeof(unsigned int))) {
550 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
551 "vfc_get_video_ioctl\n",
558 static int vfc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
565 dev = vfc_get_dev_ptr(MINOR(inode->i_rdev));
569 switch(cmd & 0x0000ffff) {
572 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCGCTRL)\n", dev->instance));
574 tmp = sbus_readl(&dev->regs->control);
575 if(copy_to_user((void *)arg, &tmp, sizeof(unsigned int))) {
582 ret = vfc_set_control_ioctl(inode, file, dev, arg);
585 ret = vfc_get_video_ioctl(inode, file, dev, arg);
588 ret = vfc_set_video_ioctl(inode, file, dev, arg);
591 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCHUE)\n", dev->instance));
592 if(copy_from_user(&tmp,(void *)arg,sizeof(unsigned int))) {
593 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer "
594 "to IOCTL(VFCHUE)", dev->instance));
597 VFC_SAA9051_SA(dev,VFC_SAA9051_HUE) = tmp;
598 vfc_update_saa9051(dev);
603 ret = vfc_port_change_ioctl(inode, file, dev, arg);
607 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCRDINFO)\n", dev->instance));
610 ret = vfc_debug(vfc_get_dev_ptr(MINOR(inode->i_rdev)),
618 static int vfc_mmap(struct inode *inode, struct file *file,
619 struct vm_area_struct *vma)
621 unsigned int map_size, ret, map_offset;
624 dev = vfc_get_dev_ptr(MINOR(inode->i_rdev));
628 map_size = vma->vm_end - vma->vm_start;
629 if(map_size > sizeof(struct vfc_regs))
630 map_size = sizeof(struct vfc_regs);
633 (VM_SHM | VM_LOCKED | VM_IO | VM_MAYREAD | VM_MAYWRITE | VM_MAYSHARE);
634 map_offset = (unsigned int) (long)dev->phys_regs;
635 ret = io_remap_page_range(vma->vm_start, map_offset, map_size,
636 vma->vm_page_prot, dev->which_io);
645 static struct file_operations vfc_fops = {
651 release: vfc_release,
654 static int vfc_probe(void)
656 struct sbus_bus *sbus;
657 struct sbus_dev *sdev = NULL;
659 int instance = 0, cards = 0;
661 for_all_sbusdev(sdev, sbus) {
662 if (strcmp(sdev->prom_name, "vfc") == 0) {
671 vfc_dev_lst = (struct vfc_dev **)kmalloc(sizeof(struct vfc_dev *) *
674 if (vfc_dev_lst == NULL)
676 memset(vfc_dev_lst, 0, sizeof(struct vfc_dev *) * (cards + 1));
677 vfc_dev_lst[cards] = NULL;
679 ret = devfs_register_chrdev(VFC_MAJOR, vfcstr, &vfc_fops);
681 printk(KERN_ERR "Unable to get major number %d\n", VFC_MAJOR);
685 devfs_handle = devfs_mk_dir (NULL, "vfc", NULL);
688 for_all_sbusdev(sdev, sbus) {
689 if (strcmp(sdev->prom_name, "vfc") == 0) {
690 vfc_dev_lst[instance]=(struct vfc_dev *)
691 kmalloc(sizeof(struct vfc_dev), GFP_KERNEL);
692 if (vfc_dev_lst[instance] == NULL)
694 ret = init_vfc_device(sdev,
695 vfc_dev_lst[instance],
698 printk(KERN_ERR "Unable to initialize"
713 int init_module(void)
722 static void deinit_vfc_device(struct vfc_dev *dev)
726 devfs_unregister (dev->de);
727 sbus_iounmap((unsigned long)dev->regs, sizeof(struct vfc_regs));
731 void cleanup_module(void)
733 struct vfc_dev **devp;
735 devfs_unregister_chrdev(VFC_MAJOR,vfcstr);
737 for (devp = vfc_dev_lst; *devp; devp++)
738 deinit_vfc_device(*devp);
740 devfs_unregister (devfs_handle);
746 MODULE_LICENSE("GPL");