Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 742 insertions, 0 deletions

diff --git a/drivers/sbus/char/vfc_dev.c b/drivers/sbus/char/vfc_dev.c
new file mode 100644
index 00000000000..86ce5413095
--- /dev/null
+++ b/drivers/sbus/char/vfc_dev.c
@@ -0,0 +1,742 @@
+/*
+ * 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");
+