* transfer the data directly into the user space buffers.
  */
 static ssize_t resource_to_user(int minor, char __user *buf, size_t count,
-       loff_t *ppos)
+                               loff_t *ppos)
 {
        ssize_t retval;
        ssize_t copied = 0;
  * transfer the data directly from the user space buffers out to VME.
  */
 static ssize_t resource_from_user(unsigned int minor, const char __user *buf,
-       size_t count, loff_t *ppos)
+                                 size_t count, loff_t *ppos)
 {
        ssize_t retval;
        ssize_t copied = 0;
 }
 
 static ssize_t buffer_to_user(unsigned int minor, char __user *buf,
-       size_t count, loff_t *ppos)
+                             size_t count, loff_t *ppos)
 {
        void *image_ptr;
        ssize_t retval;
 }
 
 static ssize_t buffer_from_user(unsigned int minor, const char __user *buf,
-       size_t count, loff_t *ppos)
+                               size_t count, loff_t *ppos)
 {
        void *image_ptr;
        size_t retval;
 }
 
 static ssize_t vme_user_read(struct file *file, char __user *buf, size_t count,
-                       loff_t *ppos)
+                            loff_t *ppos)
 {
        unsigned int minor = MINOR(file_inode(file)->i_rdev);
        ssize_t retval;
 }
 
 static ssize_t vme_user_write(struct file *file, const char __user *buf,
-                       size_t count, loff_t *ppos)
+                             size_t count, loff_t *ppos)
 {
        unsigned int minor = MINOR(file_inode(file)->i_rdev);
        ssize_t retval;
  * already been defined.
  */
 static int vme_user_ioctl(struct inode *inode, struct file *file,
-       unsigned int cmd, unsigned long arg)
+                         unsigned int cmd, unsigned long arg)
 {
        struct vme_master master;
        struct vme_slave slave;
                         *      to userspace as they are
                         */
                        retval = vme_master_get(image[minor].resource,
-                               &master.enable, &master.vme_addr,
-                               &master.size, &master.aspace,
-                               &master.cycle, &master.dwidth);
+                                               &master.enable,
+                                               &master.vme_addr,
+                                               &master.size, &master.aspace,
+                                               &master.cycle, &master.dwidth);
 
                        copied = copy_to_user(argp, &master,
-                               sizeof(struct vme_master));
+                                             sizeof(struct vme_master));
                        if (copied != 0) {
                                pr_warn("Partial copy to userspace\n");
                                return -EFAULT;
                         *      to userspace as they are
                         */
                        retval = vme_slave_get(image[minor].resource,
-                               &slave.enable, &slave.vme_addr,
-                               &slave.size, &pci_addr, &slave.aspace,
-                               &slave.cycle);
+                                              &slave.enable, &slave.vme_addr,
+                                              &slave.size, &pci_addr,
+                                              &slave.aspace, &slave.cycle);
 
                        copied = copy_to_user(argp, &slave,
-                               sizeof(struct vme_slave));
+                                             sizeof(struct vme_slave));
                        if (copied != 0) {
                                pr_warn("Partial copy to userspace\n");
                                return -EFAULT;
 
        /* Assign major and minor numbers for the driver */
        err = register_chrdev_region(MKDEV(VME_MAJOR, 0), VME_DEVS,
-               driver_name);
+                                    driver_name);
        if (err) {
                dev_warn(&vdev->dev, "Error getting Major Number %d for driver.\n",
                         VME_MAJOR);