/* * drivers/sbus/char/vfc_dev.c * * Driver for the Videopix Frame Grabber. * * In order to use the VFC you need to program the video controller * chip. This chip is the Phillips SAA9051. You need to call their * documentation ordering line to get the docs. * * There is very little documentation on the VFC itself. There is * some useful info that can be found in the manuals that come with * the card. I will hopefully write some better docs at a later date. * * Copyright (C) 1996 Manish Vachharajani (mvachhar@noc.rutgers.edu) * */ #include <linux/module.h> #include <linux/kernel.h> #include <linux/string.h> #include <linux/slab.h> #include <linux/errno.h> #include <linux/sched.h> #include <linux/fs.h> #include <linux/smp_lock.h> #include <linux/delay.h> #include <linux/spinlock.h> #include <linux/mm.h> #include <asm/openprom.h> #include <asm/oplib.h> #include <asm/io.h> #include <asm/system.h> #include <asm/sbus.h> #include <asm/page.h> #include <asm/pgtable.h> #include <asm/uaccess.h> #define VFC_MAJOR (60) #if 0 #define VFC_IOCTL_DEBUG #endif #include "vfc.h" #include <asm/vfc_ioctls.h> static struct file_operations vfc_fops; struct vfc_dev **vfc_dev_lst; static char vfcstr[]="vfc"; static unsigned char saa9051_init_array[VFC_SAA9051_NR] = { 0x00, 0x64, 0x72, 0x52, 0x36, 0x18, 0xff, 0x20, 0xfc, 0x77, 0xe3, 0x50, 0x3e }; void vfc_lock_device(struct vfc_dev *dev) { down(&dev->device_lock_sem); } void vfc_unlock_device(struct vfc_dev *dev) { up(&dev->device_lock_sem); } void vfc_captstat_reset(struct vfc_dev *dev) { dev->control_reg |= VFC_CONTROL_CAPTRESET; sbus_writel(dev->control_reg, &dev->regs->control); dev->control_reg &= ~VFC_CONTROL_CAPTRESET; sbus_writel(dev->control_reg, &dev->regs->control); dev->control_reg |= VFC_CONTROL_CAPTRESET; sbus_writel(dev->control_reg, &dev->regs->control); } void vfc_memptr_reset(struct vfc_dev *dev) { dev->control_reg |= VFC_CONTROL_MEMPTR; sbus_writel(dev->control_reg, &dev->regs->control); dev->control_reg &= ~VFC_CONTROL_MEMPTR; sbus_writel(dev->control_reg, &dev->regs->control); dev->control_reg |= VFC_CONTROL_MEMPTR; sbus_writel(dev->control_reg, &dev->regs->control); } int vfc_csr_init(struct vfc_dev *dev) { dev->control_reg = 0x80000000; sbus_writel(dev->control_reg, &dev->regs->control); udelay(200); dev->control_reg &= ~0x80000000; sbus_writel(dev->control_reg, &dev->regs->control); udelay(100); sbus_writel(0x0f000000, &dev->regs->i2c_magic2); vfc_memptr_reset(dev); dev->control_reg &= ~VFC_CONTROL_DIAGMODE; dev->control_reg &= ~VFC_CONTROL_CAPTURE; dev->control_reg |= 0x40000000; sbus_writel(dev->control_reg, &dev->regs->control); vfc_captstat_reset(dev); return 0; } int vfc_saa9051_init(struct vfc_dev *dev) { int i; for (i = 0; i < VFC_SAA9051_NR; i++) dev->saa9051_state_array[i] = saa9051_init_array[i]; vfc_i2c_sendbuf(dev,VFC_SAA9051_ADDR, dev->saa9051_state_array, VFC_SAA9051_NR); return 0; } int init_vfc_hw(struct vfc_dev *dev) { vfc_lock_device(dev); vfc_csr_init(dev); vfc_pcf8584_init(dev); vfc_init_i2c_bus(dev); /* hopefully this doesn't undo the magic sun code above*/ vfc_saa9051_init(dev); vfc_unlock_device(dev); return 0; } int init_vfc_devstruct(struct vfc_dev *dev, int instance) { dev->instance=instance; init_MUTEX(&dev->device_lock_sem); dev->control_reg=0; init_waitqueue_head(&dev->poll_wait); dev->busy=0; return 0; } int init_vfc_device(struct sbus_dev *sdev,struct vfc_dev *dev, int instance) { if(dev == NULL) { printk(KERN_ERR "VFC: Bogus pointer passed\n"); return -ENOMEM; } printk("Initializing vfc%d\n",instance); dev->regs = NULL; dev->regs = (volatile struct vfc_regs *) sbus_ioremap(&sdev->resource[0], 0, sizeof(struct vfc_regs), vfcstr); dev->which_io = sdev->reg_addrs[0].which_io; dev->phys_regs = (struct vfc_regs *) sdev->reg_addrs[0].phys_addr; if (dev->regs == NULL) return -EIO; printk("vfc%d: registers mapped at phys_addr: 0x%lx\n virt_addr: 0x%lx\n", instance,(unsigned long)sdev->reg_addrs[0].phys_addr,(unsigned long)dev->regs); if (init_vfc_devstruct(dev, instance)) return -EINVAL; if (init_vfc_hw(dev)) return -EIO; devfs_mk_cdev(MKDEV(VFC_MAJOR, instance), S_IFCHR | S_IRUSR | S_IWUSR, "vfc/%d", instance); return 0; } struct vfc_dev *vfc_get_dev_ptr(int instance) { return vfc_dev_lst[instance]; } static DEFINE_SPINLOCK(vfc_dev_lock); static int vfc_open(struct inode *inode, struct file *file) { struct vfc_dev *dev; spin_lock(&vfc_dev_lock); dev = vfc_get_dev_ptr(iminor(inode)); if (dev == NULL) { spin_unlock(&vfc_dev_lock); return -ENODEV; } if (dev->busy) { spin_unlock(&vfc_dev_lock); return -EBUSY; } dev->busy = 1; spin_unlock(&vfc_dev_lock); vfc_lock_device(dev); vfc_csr_init(dev); vfc_pcf8584_init(dev); vfc_init_i2c_bus(dev); vfc_saa9051_init(dev); vfc_memptr_reset(dev); vfc_captstat_reset(dev); vfc_unlock_device(dev); return 0; } static int vfc_release(struct inode *inode,struct file *file) { struct vfc_dev *dev; spin_lock(&vfc_dev_lock); dev = vfc_get_dev_ptr(iminor(inode)); if (!dev || !dev->busy) { spin_unlock(&vfc_dev_lock); return -EINVAL; } dev->busy = 0; spin_unlock(&vfc_dev_lock); return 0; } static int vfc_debug(struct vfc_dev *dev, int cmd, void __user *argp) { struct vfc_debug_inout inout; unsigned char *buffer; if (!capable(CAP_SYS_ADMIN)) return -EPERM; switch(cmd) { case VFC_I2C_SEND: if(copy_from_user(&inout, argp, sizeof(inout))) return -EFAULT; buffer = kmalloc(inout.len, GFP_KERNEL); if (buffer == NULL) return -ENOMEM; if(copy_from_user(buffer, inout.buffer, inout.len)) { kfree(buffer); return -EFAULT; } vfc_lock_device(dev); inout.ret= vfc_i2c_sendbuf(dev,inout.addr & 0xff, buffer,inout.len); if (copy_to_user(argp,&inout,sizeof(inout))) { kfree(buffer); return -EFAULT; } vfc_unlock_device(dev); break; case VFC_I2C_RECV: if (copy_from_user(&inout, argp, sizeof(inout))) return -EFAULT; buffer = kmalloc(inout.len, GFP_KERNEL); if (buffer == NULL) return -ENOMEM; memset(buffer,0,inout.len); vfc_lock_device(dev); inout.ret= vfc_i2c_recvbuf(dev,inout.addr & 0xff ,buffer,inout.len); vfc_unlock_device(dev); if (copy_to_user(inout.buffer, buffer, inout.len)) { kfree(buffer); return -EFAULT; } if (copy_to_user(argp,&inout,sizeof(inout))) { kfree(buffer); return -EFAULT; } kfree(buffer); break; default: return -EINVAL; }; return 0; } int vfc_capture_start(struct vfc_dev *dev) { vfc_captstat_reset(dev); dev->control_reg = sbus_readl(&dev->regs->control); if((dev->control_reg & VFC_STATUS_CAPTURE)) { printk(KERN_ERR "vfc%d: vfc capture status not reset\n", dev->instance); return -EIO; } vfc_lock_device(dev); dev->control_reg &= ~VFC_CONTROL_CAPTURE; sbus_writel(dev->control_reg, &dev->regs->control); dev->control_reg |= VFC_CONTROL_CAPTURE; sbus_writel(dev->control_reg, &dev->regs->control); dev->control_reg &= ~VFC_CONTROL_CAPTURE; sbus_writel(dev->control_reg, &dev->regs->control); vfc_unlock_device(dev); return 0; } int vfc_capture_poll(struct vfc_dev *dev) { int timeout = 1000; while (!timeout--) { if (dev->regs->control & VFC_STATUS_CAPTURE) break; vfc_i2c_delay_no_busy(dev, 100); } if(!timeout) { printk(KERN_WARNING "vfc%d: capture timed out\n", dev->instance); return -ETIMEDOUT; } return 0; } static int vfc_set_control_ioctl(struct inode *inode, struct file *file, struct vfc_dev *dev, unsigned long arg) { int setcmd, ret = 0; if (copy_from_user(&setcmd,(void __user *)arg,sizeof(unsigned int))) return -EFAULT; VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCSCTRL) arg=0x%x\n", dev->instance,setcmd)); switch(setcmd) { case MEMPRST: vfc_lock_device(dev); vfc_memptr_reset(dev); vfc_unlock_device(dev); ret=0; break; case CAPTRCMD: vfc_capture_start(dev); vfc_capture_poll(dev); break; case DIAGMODE: if(capable(CAP_SYS_ADMIN)) { vfc_lock_device(dev); dev->control_reg |= VFC_CONTROL_DIAGMODE; sbus_writel(dev->control_reg, &dev->regs->control); vfc_unlock_device(dev); ret = 0; } else { ret = -EPERM; } break; case NORMMODE: vfc_lock_device(dev); dev->control_reg &= ~VFC_CONTROL_DIAGMODE; sbus_writel(dev->control_reg, &dev->regs->control); vfc_unlock_device(dev); ret = 0; break; case CAPTRSTR: vfc_capture_start(dev); ret = 0; break; case CAPTRWAIT: vfc_capture_poll(dev); ret = 0; break; default: ret = -EINVAL; break; }; return ret; } int vfc_port_change_ioctl(struct inode *inode, struct file *file, struct vfc_dev *dev, unsigned long arg) { int ret = 0; int cmd; if(copy_from_user(&cmd, (void __user *)arg, sizeof(unsigned int))) { VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to " "vfc_port_change_ioctl\n", dev->instance)); return -EFAULT; } VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCPORTCHG) arg=0x%x\n", dev->instance, cmd)); switch(cmd) { case 1: case 2: VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_START) = 0x72; VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_STOP) = 0x52; VFC_SAA9051_SA(dev,VFC_SAA9051_HC_START) = 0x36; VFC_SAA9051_SA(dev,VFC_SAA9051_HC_STOP) = 0x18; VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) = VFC_SAA9051_BP2; VFC_SAA9051_SA(dev,VFC_SAA9051_C3) = VFC_SAA9051_CT | VFC_SAA9051_SS3; VFC_SAA9051_SA(dev,VFC_SAA9051_SECAM_DELAY) = 0x3e; break; case 3: VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_START) = 0x3a; VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_STOP) = 0x17; VFC_SAA9051_SA(dev,VFC_SAA9051_HC_START) = 0xfa; VFC_SAA9051_SA(dev,VFC_SAA9051_HC_STOP) = 0xde; VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) = VFC_SAA9051_BY | VFC_SAA9051_PF | VFC_SAA9051_BP2; VFC_SAA9051_SA(dev,VFC_SAA9051_C3) = VFC_SAA9051_YC; VFC_SAA9051_SA(dev,VFC_SAA9051_SECAM_DELAY) = 0; VFC_SAA9051_SA(dev,VFC_SAA9051_C2) &= ~(VFC_SAA9051_SS0 | VFC_SAA9051_SS1); break; default: ret = -EINVAL; return ret; break; } switch(cmd) { case 1: VFC_SAA9051_SA(dev,VFC_SAA9051_C2) |= (VFC_SAA9051_SS0 | VFC_SAA9051_SS1); break; case 2: VFC_SAA9051_SA(dev,VFC_SAA9051_C2) &= ~(VFC_SAA9051_SS0 | VFC_SAA9051_SS1); VFC_SAA9051_SA(dev,VFC_SAA9051_C2) |= VFC_SAA9051_SS0; break; case 3: break; default: ret = -EINVAL; return ret; break; } VFC_SAA9051_SA(dev,VFC_SAA9051_C3) &= ~(VFC_SAA9051_SS2); ret=vfc_update_saa9051(dev); udelay(500); VFC_SAA9051_SA(dev,VFC_SAA9051_C3) |= (VFC_SAA9051_SS2); ret=vfc_update_saa9051(dev); return ret; } int vfc_set_video_ioctl(struct inode *inode, struct file *file, struct vfc_dev *dev, unsigned long arg) { int ret = 0; int cmd; if(copy_from_user(&cmd, (void __user *)arg, sizeof(unsigned int))) { VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to " "vfc_set_video_ioctl\n", dev->instance)); return ret; } VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCSVID) arg=0x%x\n", dev->instance, cmd)); switch(cmd) { case STD_NTSC: VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~VFC_SAA9051_ALT; VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_YPN | VFC_SAA9051_CCFR0 | VFC_SAA9051_CCFR1 | VFC_SAA9051_FS; ret = vfc_update_saa9051(dev); break; case STD_PAL: VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~(VFC_SAA9051_YPN | VFC_SAA9051_CCFR1 | VFC_SAA9051_CCFR0 | VFC_SAA9051_FS); VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_ALT; ret = vfc_update_saa9051(dev); break; case COLOR_ON: VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_CO; VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) &= ~(VFC_SAA9051_BY | VFC_SAA9051_PF); ret = vfc_update_saa9051(dev); break; case MONO: VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~(VFC_SAA9051_CO); VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) |= (VFC_SAA9051_BY | VFC_SAA9051_PF); ret = vfc_update_saa9051(dev); break; default: ret = -EINVAL; break; }; return ret; } int vfc_get_video_ioctl(struct inode *inode, struct file *file, struct vfc_dev *dev, unsigned long arg) { int ret = 0; unsigned int status = NO_LOCK; unsigned char buf[1]; if(vfc_i2c_recvbuf(dev, VFC_SAA9051_ADDR, buf, 1)) { printk(KERN_ERR "vfc%d: Unable to get status\n", dev->instance); return -EIO; } if(buf[0] & VFC_SAA9051_HLOCK) { status = NO_LOCK; } else if(buf[0] & VFC_SAA9051_FD) { if(buf[0] & VFC_SAA9051_CD) status = NTSC_COLOR; else status = NTSC_NOCOLOR; } else { if(buf[0] & VFC_SAA9051_CD) status = PAL_COLOR; else status = PAL_NOCOLOR; } VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCGVID) returning status 0x%x; " "buf[0]=%x\n", dev->instance, status, buf[0])); if (copy_to_user((void __user *)arg,&status,sizeof(unsigned int))) { VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to " "vfc_get_video_ioctl\n", dev->instance)); return ret; } return ret; } static int vfc_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { int ret = 0; unsigned int tmp; struct vfc_dev *dev; void __user *argp = (void __user *)arg; dev = vfc_get_dev_ptr(iminor(inode)); if(dev == NULL) return -ENODEV; switch(cmd & 0x0000ffff) { case VFCGCTRL: #if 0 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCGCTRL)\n", dev->instance)); #endif tmp = sbus_readl(&dev->regs->control); if(copy_to_user(argp, &tmp, sizeof(unsigned int))) { ret = -EFAULT; break; } ret = 0; break; case VFCSCTRL: ret = vfc_set_control_ioctl(inode, file, dev, arg); break; case VFCGVID: ret = vfc_get_video_ioctl(inode, file, dev, arg); break; case VFCSVID: ret = vfc_set_video_ioctl(inode, file, dev, arg); break; case VFCHUE: VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCHUE)\n", dev->instance)); if(copy_from_user(&tmp,argp,sizeof(unsigned int))) { VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer " "to IOCTL(VFCHUE)", dev->instance)); ret = -EFAULT; } else { VFC_SAA9051_SA(dev,VFC_SAA9051_HUE) = tmp; vfc_update_saa9051(dev); ret = 0; } break; case VFCPORTCHG: ret = vfc_port_change_ioctl(inode, file, dev, arg); break; case VFCRDINFO: ret = -EINVAL; VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCRDINFO)\n", dev->instance)); break; default: ret = vfc_debug(vfc_get_dev_ptr(iminor(inode)), cmd, argp); break; }; return ret; } static int vfc_mmap(struct file *file, struct vm_area_struct *vma) { unsigned int map_size, ret, map_offset; struct vfc_dev *dev; dev = vfc_get_dev_ptr(iminor(file->f_dentry->d_inode)); if(dev == NULL) return -ENODEV; map_size = vma->vm_end - vma->vm_start; if(map_size > sizeof(struct vfc_regs)) map_size = sizeof(struct vfc_regs); vma->vm_flags |= (VM_SHM | VM_LOCKED | VM_IO | VM_MAYREAD | VM_MAYWRITE | VM_MAYSHARE); map_offset = (unsigned int) (long)dev->phys_regs; ret = io_remap_pfn_range(vma, vma->vm_start, MK_IOSPACE_PFN(dev->which_io, map_offset >> PAGE_SHIFT), map_size, vma->vm_page_prot); if(ret) return -EAGAIN; return 0; } static struct file_operations vfc_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .ioctl = vfc_ioctl, .mmap = vfc_mmap, .open = vfc_open, .release = vfc_release, }; static int vfc_probe(void) { struct sbus_bus *sbus; struct sbus_dev *sdev = NULL; int ret; int instance = 0, cards = 0; for_all_sbusdev(sdev, sbus) { if (strcmp(sdev->prom_name, "vfc") == 0) { cards++; continue; } } if (!cards) return -ENODEV; vfc_dev_lst = (struct vfc_dev **)kmalloc(sizeof(struct vfc_dev *) * (cards+1), GFP_KERNEL); if (vfc_dev_lst == NULL) return -ENOMEM; memset(vfc_dev_lst, 0, sizeof(struct vfc_dev *) * (cards + 1)); vfc_dev_lst[cards] = NULL; ret = register_chrdev(VFC_MAJOR, vfcstr, &vfc_fops); if(ret) { printk(KERN_ERR "Unable to get major number %d\n", VFC_MAJOR); kfree(vfc_dev_lst); return -EIO; } devfs_mk_dir("vfc"); instance = 0; for_all_sbusdev(sdev, sbus) { if (strcmp(sdev->prom_name, "vfc") == 0) { vfc_dev_lst[instance]=(struct vfc_dev *) kmalloc(sizeof(struct vfc_dev), GFP_KERNEL); if (vfc_dev_lst[instance] == NULL) return -ENOMEM; ret = init_vfc_device(sdev, vfc_dev_lst[instance], instance); if(ret) { printk(KERN_ERR "Unable to initialize" " vfc%d device\n", instance); } else { } instance++; continue; } } return 0; } #ifdef MODULE int init_module(void) #else int vfc_init(void) #endif { return vfc_probe(); } #ifdef MODULE static void deinit_vfc_device(struct vfc_dev *dev) { if(dev == NULL) return; devfs_remove("vfc/%d", dev->instance); sbus_iounmap((unsigned long)dev->regs, sizeof(struct vfc_regs)); kfree(dev); } void cleanup_module(void) { struct vfc_dev **devp; unregister_chrdev(VFC_MAJOR,vfcstr); for (devp = vfc_dev_lst; *devp; devp++) deinit_vfc_device(*devp); devfs_remove("vfc"); kfree(vfc_dev_lst); return; } #endif MODULE_LICENSE("GPL");