ppdev: space prohibited between function name and parenthesis

checkpatch was complaining about space between function name and open
parenthesis.

Signed-off-by: Sudip Mukherjee <sudip@vectorindia.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/char/ppdev.c b/drivers/char/ppdev.c
index 9e98d015314815d651b3dc331be037afc9e787ca..80ab757de8d3120f057bc29b107d56b835cbe434 100644 (file)
--- a/drivers/char/ppdev.c
+++ b/drivers/char/ppdev.c
@@ -106,13 +106,13 @@ static DEFINE_MUTEX(pp_do_mutex);
 #define PPGETTIME64    _IOR(PP_IOCTL, 0x95, s64[2])
 #define PPSETTIME64    _IOW(PP_IOCTL, 0x96, s64[2])
 
-static inline void pp_enable_irq (struct pp_struct *pp)
+static inline void pp_enable_irq(struct pp_struct *pp)
 {
        struct parport *port = pp->pdev->port;
-       port->ops->enable_irq (port);
+       port->ops->enable_irq(port);
 }
 
-static ssize_t pp_read (struct file * file, char __user * buf, size_t count,
+static ssize_t pp_read(struct file * file, char __user * buf, size_t count,
                        loff_t * ppos)
 {
        unsigned int minor = iminor(file_inode(file));
@@ -139,7 +139,7 @@ static ssize_t pp_read (struct file * file, char __user * buf, size_t count,
        pport = pp->pdev->port;
        mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
 
-       parport_set_timeout (pp->pdev,
+       parport_set_timeout(pp->pdev,
                             (file->f_flags & O_NONBLOCK) ?
                             PARPORT_INACTIVITY_O_NONBLOCK :
                             pp->default_inactivity);
@@ -165,7 +165,7 @@ static ssize_t pp_read (struct file * file, char __user * buf, size_t count,
                        }
                        bytes_read = (*fn)(pport, kbuffer, need, flags);
                } else {
-                       bytes_read = parport_read (pport, kbuffer, need);
+                       bytes_read = parport_read(pport, kbuffer, need);
                }
 
                if (bytes_read != 0)
@@ -176,7 +176,7 @@ static ssize_t pp_read (struct file * file, char __user * buf, size_t count,
                        break;
                }
 
-               if (signal_pending (current)) {
+               if (signal_pending(current)) {
                        bytes_read = -ERESTARTSYS;
                        break;
                }
@@ -184,17 +184,17 @@ static ssize_t pp_read (struct file * file, char __user * buf, size_t count,
                cond_resched();
        }
 
-       parport_set_timeout (pp->pdev, pp->default_inactivity);
+       parport_set_timeout(pp->pdev, pp->default_inactivity);
 
-       if (bytes_read > 0 && copy_to_user (buf, kbuffer, bytes_read))
+       if (bytes_read > 0 && copy_to_user(buf, kbuffer, bytes_read))
                bytes_read = -EFAULT;
 
-       kfree (kbuffer);
-       pp_enable_irq (pp);
+       kfree(kbuffer);
+       pp_enable_irq(pp);
        return bytes_read;
 }
 
-static ssize_t pp_write (struct file * file, const char __user * buf,
+static ssize_t pp_write(struct file * file, const char __user * buf,
                         size_t count, loff_t * ppos)
 {
        unsigned int minor = iminor(file_inode(file));
@@ -218,7 +218,7 @@ static ssize_t pp_write (struct file * file, const char __user * buf,
        pport = pp->pdev->port;
        mode = pport->ieee1284.mode & ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
 
-       parport_set_timeout (pp->pdev,
+       parport_set_timeout(pp->pdev,
                             (file->f_flags & O_NONBLOCK) ?
                             PARPORT_INACTIVITY_O_NONBLOCK :
                             pp->default_inactivity);
@@ -226,7 +226,7 @@ static ssize_t pp_write (struct file * file, const char __user * buf,
        while (bytes_written < count) {
                ssize_t n = min_t(unsigned long, count - bytes_written, PP_BUFFER_SIZE);
 
-               if (copy_from_user (kbuffer, buf + bytes_written, n)) {
+               if (copy_from_user(kbuffer, buf + bytes_written, n)) {
                        bytes_written = -EFAULT;
                        break;
                }
@@ -234,14 +234,14 @@ static ssize_t pp_write (struct file * file, const char __user * buf,
                if ((pp->flags & PP_FASTWRITE) && (mode == IEEE1284_MODE_EPP)) {
                        /* do a fast EPP write */
                        if (pport->ieee1284.mode & IEEE1284_ADDR) {
-                               wrote = pport->ops->epp_write_addr (pport,
+                               wrote = pport->ops->epp_write_addr(pport,
                                        kbuffer, n, PARPORT_EPP_FAST);
                        } else {
-                               wrote = pport->ops->epp_write_data (pport,
+                               wrote = pport->ops->epp_write_data(pport,
                                        kbuffer, n, PARPORT_EPP_FAST);
                        }
                } else {
-                       wrote = parport_write (pp->pdev->port, kbuffer, n);
+                       wrote = parport_write(pp->pdev->port, kbuffer, n);
                }
 
                if (wrote <= 0) {
@@ -259,33 +259,33 @@ static ssize_t pp_write (struct file * file, const char __user * buf,
                        break;
                }
 
-               if (signal_pending (current))
+               if (signal_pending(current))
                        break;
 
                cond_resched();
        }
 
-       parport_set_timeout (pp->pdev, pp->default_inactivity);
+       parport_set_timeout(pp->pdev, pp->default_inactivity);
 
-       kfree (kbuffer);
-       pp_enable_irq (pp);
+       kfree(kbuffer);
+       pp_enable_irq(pp);
        return bytes_written;
 }
 
-static void pp_irq (void *private)
+static void pp_irq(void *private)
 {
        struct pp_struct *pp = private;
 
        if (pp->irqresponse) {
-               parport_write_control (pp->pdev->port, pp->irqctl);
+               parport_write_control(pp->pdev->port, pp->irqctl);
                pp->irqresponse = 0;
        }
 
-       atomic_inc (&pp->irqc);
-       wake_up_interruptible (&pp->irq_wait);
+       atomic_inc(&pp->irqc);
+       wake_up_interruptible(&pp->irq_wait);
 }
 
-static int register_device (int minor, struct pp_struct *pp)
+static int register_device(int minor, struct pp_struct *pp)
 {
        struct parport *port;
        struct pardevice * pdev = NULL;
@@ -296,21 +296,21 @@ static int register_device (int minor, struct pp_struct *pp)
        if (name == NULL)
                return -ENOMEM;
 
-       port = parport_find_number (minor);
+       port = parport_find_number(minor);
        if (!port) {
-               printk (KERN_WARNING "%s: no associated port!\n", name);
-               kfree (name);
+               printk(KERN_WARNING "%s: no associated port!\n", name);
+               kfree(name);
                return -ENXIO;
        }
 
        fl = (pp->flags & PP_EXCL) ? PARPORT_FLAG_EXCL : 0;
-       pdev = parport_register_device (port, name, NULL,
+       pdev = parport_register_device(port, name, NULL,
                                        NULL, pp_irq, fl, pp);
-       parport_put_port (port);
+       parport_put_port(port);
 
        if (!pdev) {
-               printk (KERN_WARNING "%s: failed to register device!\n", name);
-               kfree (name);
+               printk(KERN_WARNING "%s: failed to register device!\n", name);
+               kfree(name);
                return -ENXIO;
        }
 
@@ -319,7 +319,7 @@ static int register_device (int minor, struct pp_struct *pp)
        return 0;
 }
 
-static enum ieee1284_phase init_phase (int mode)
+static enum ieee1284_phase init_phase(int mode)
 {
        switch (mode & ~(IEEE1284_DEVICEID
                         | IEEE1284_ADDR)) {
@@ -367,13 +367,13 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 
                /* Deferred device registration. */
                if (!pp->pdev) {
-                       int err = register_device (minor, pp);
+                       int err = register_device(minor, pp);
                        if (err) {
                                return err;
                        }
                }
 
-               ret = parport_claim_or_block (pp->pdev);
+               ret = parport_claim_or_block(pp->pdev);
                if (ret < 0)
                        return ret;
 
@@ -381,7 +381,7 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 
                /* For interrupt-reporting to work, we need to be
                 * informed of each interrupt. */
-               pp_enable_irq (pp);
+               pp_enable_irq(pp);
 
                /* We may need to fix up the state machine. */
                info = &pp->pdev->port->ieee1284;
@@ -389,8 +389,8 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                pp->saved_state.phase = info->phase;
                info->mode = pp->state.mode;
                info->phase = pp->state.phase;
-               pp->default_inactivity = parport_set_timeout (pp->pdev, 0);
-               parport_set_timeout (pp->pdev, pp->default_inactivity);
+               pp->default_inactivity = parport_set_timeout(pp->pdev, 0);
+               parport_set_timeout(pp->pdev, pp->default_inactivity);
 
                return 0;
            }
@@ -412,11 +412,11 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
        case PPSETMODE:
            {
                int mode;
-               if (copy_from_user (&mode, argp, sizeof (mode)))
+               if (copy_from_user(&mode, argp, sizeof(mode)))
                        return -EFAULT;
                /* FIXME: validate mode */
                pp->state.mode = mode;
-               pp->state.phase = init_phase (mode);
+               pp->state.phase = init_phase(mode);
 
                if (pp->flags & PP_CLAIMED) {
                        pp->pdev->port->ieee1284.mode = mode;
@@ -434,7 +434,7 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                } else {
                        mode = pp->state.mode;
                }
-               if (copy_to_user (argp, &mode, sizeof (mode))) {
+               if (copy_to_user(argp, &mode, sizeof(mode))) {
                        return -EFAULT;
                }
                return 0;
@@ -442,7 +442,7 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
        case PPSETPHASE:
            {
                int phase;
-               if (copy_from_user (&phase, argp, sizeof (phase))) {
+               if (copy_from_user(&phase, argp, sizeof(phase))) {
                        return -EFAULT;
                }
                /* FIXME: validate phase */
@@ -463,7 +463,7 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                } else {
                        phase = pp->state.phase;
                }
-               if (copy_to_user (argp, &phase, sizeof (phase))) {
+               if (copy_to_user(argp, &phase, sizeof(phase))) {
                        return -EFAULT;
                }
                return 0;
@@ -472,13 +472,13 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
            {
                unsigned int modes;
 
-               port = parport_find_number (minor);
+               port = parport_find_number(minor);
                if (!port)
                        return -ENODEV;
 
                modes = port->modes;
                parport_put_port(port);
-               if (copy_to_user (argp, &modes, sizeof (modes))) {
+               if (copy_to_user(argp, &modes, sizeof(modes))) {
                        return -EFAULT;
                }
                return 0;
@@ -487,7 +487,7 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
            {
                int uflags;
 
-               if (copy_from_user (&uflags, argp, sizeof (uflags))) {
+               if (copy_from_user(&uflags, argp, sizeof(uflags))) {
                        return -EFAULT;
                }
                pp->flags &= ~PP_FLAGMASK;
@@ -499,7 +499,7 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                int uflags;
 
                uflags = pp->flags & PP_FLAGMASK;
-               if (copy_to_user (argp, &uflags, sizeof (uflags))) {
+               if (copy_to_user(argp, &uflags, sizeof(uflags))) {
                        return -EFAULT;
                }
                return 0;
@@ -525,22 +525,22 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                int ret;
 
        case PPRSTATUS:
-               reg = parport_read_status (port);
-               if (copy_to_user (argp, &reg, sizeof (reg)))
+               reg = parport_read_status(port);
+               if (copy_to_user(argp, &reg, sizeof(reg)))
                        return -EFAULT;
                return 0;
        case PPRDATA:
-               reg = parport_read_data (port);
-               if (copy_to_user (argp, &reg, sizeof (reg)))
+               reg = parport_read_data(port);
+               if (copy_to_user(argp, &reg, sizeof(reg)))
                        return -EFAULT;
                return 0;
        case PPRCONTROL:
-               reg = parport_read_control (port);
-               if (copy_to_user (argp, &reg, sizeof (reg)))
+               reg = parport_read_control(port);
+               if (copy_to_user(argp, &reg, sizeof(reg)))
                        return -EFAULT;
                return 0;
        case PPYIELD:
-               parport_yield_blocking (pp->pdev);
+               parport_yield_blocking(pp->pdev);
                return 0;
 
        case PPRELEASE:
@@ -550,45 +550,45 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                pp->state.phase = info->phase;
                info->mode = pp->saved_state.mode;
                info->phase = pp->saved_state.phase;
-               parport_release (pp->pdev);
+               parport_release(pp->pdev);
                pp->flags &= ~PP_CLAIMED;
                return 0;
 
        case PPWCONTROL:
-               if (copy_from_user (&reg, argp, sizeof (reg)))
+               if (copy_from_user(&reg, argp, sizeof(reg)))
                        return -EFAULT;
-               parport_write_control (port, reg);
+               parport_write_control(port, reg);
                return 0;
 
        case PPWDATA:
-               if (copy_from_user (&reg, argp, sizeof (reg)))
+               if (copy_from_user(&reg, argp, sizeof(reg)))
                        return -EFAULT;
-               parport_write_data (port, reg);
+               parport_write_data(port, reg);
                return 0;
 
        case PPFCONTROL:
-               if (copy_from_user (&mask, argp,
-                                   sizeof (mask)))
+               if (copy_from_user(&mask, argp,
+                                   sizeof(mask)))
                        return -EFAULT;
-               if (copy_from_user (&reg, 1 + (unsigned char __user *) arg,
-                                   sizeof (reg)))
+               if (copy_from_user(&reg, 1 + (unsigned char __user *) arg,
+                                   sizeof(reg)))
                        return -EFAULT;
-               parport_frob_control (port, mask, reg);
+               parport_frob_control(port, mask, reg);
                return 0;
 
        case PPDATADIR:
-               if (copy_from_user (&mode, argp, sizeof (mode)))
+               if (copy_from_user(&mode, argp, sizeof(mode)))
                        return -EFAULT;
                if (mode)
-                       port->ops->data_reverse (port);
+                       port->ops->data_reverse(port);
                else
-                       port->ops->data_forward (port);
+                       port->ops->data_forward(port);
                return 0;
 
        case PPNEGOT:
-               if (copy_from_user (&mode, argp, sizeof (mode)))
+               if (copy_from_user(&mode, argp, sizeof(mode)))
                        return -EFAULT;
-               switch ((ret = parport_negotiate (port, mode))) {
+               switch ((ret = parport_negotiate(port, mode))) {
                case 0: break;
                case -1: /* handshake failed, peripheral not IEEE 1284 */
                        ret = -EIO;
@@ -597,11 +597,11 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                        ret = -ENXIO;
                        break;
                }
-               pp_enable_irq (pp);
+               pp_enable_irq(pp);
                return ret;
 
        case PPWCTLONIRQ:
-               if (copy_from_user (&reg, argp, sizeof (reg)))
+               if (copy_from_user(&reg, argp, sizeof(reg)))
                        return -EFAULT;
 
                /* Remember what to set the control lines to, for next
@@ -611,10 +611,10 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                return 0;
 
        case PPCLRIRQ:
-               ret = atomic_read (&pp->irqc);
-               if (copy_to_user (argp, &ret, sizeof (ret)))
+               ret = atomic_read(&pp->irqc);
+               if (copy_to_user(argp, &ret, sizeof(ret)))
                        return -EFAULT;
-               atomic_sub (ret, &pp->irqc);
+               atomic_sub(ret, &pp->irqc);
                return 0;
 
        case PPSETTIME32:
@@ -679,7 +679,7 @@ static long pp_compat_ioctl(struct file *file, unsigned int cmd,
 }
 #endif
 
-static int pp_open (struct inode * inode, struct file * file)
+static int pp_open(struct inode * inode, struct file * file)
 {
        unsigned int minor = iminor(inode);
        struct pp_struct *pp;
@@ -687,16 +687,16 @@ static int pp_open (struct inode * inode, struct file * file)
        if (minor >= PARPORT_MAX)
                return -ENXIO;
 
-       pp = kmalloc (sizeof (struct pp_struct), GFP_KERNEL);
+       pp = kmalloc(sizeof(struct pp_struct), GFP_KERNEL);
        if (!pp)
                return -ENOMEM;
 
        pp->state.mode = IEEE1284_MODE_COMPAT;
-       pp->state.phase = init_phase (pp->state.mode);
+       pp->state.phase = init_phase(pp->state.mode);
        pp->flags = 0;
        pp->irqresponse = 0;
-       atomic_set (&pp->irqc, 0);
-       init_waitqueue_head (&pp->irq_wait);
+       atomic_set(&pp->irqc, 0);
+       init_waitqueue_head(&pp->irq_wait);
 
        /* Defer the actual device registration until the first claim.
         * That way, we know whether or not the driver wants to have
@@ -708,7 +708,7 @@ static int pp_open (struct inode * inode, struct file * file)
        return 0;
 }
 
-static int pp_release (struct inode * inode, struct file * file)
+static int pp_release(struct inode * inode, struct file * file)
 {
        unsigned int minor = iminor(inode);
        struct pp_struct *pp = file->private_data;
@@ -720,7 +720,7 @@ static int pp_release (struct inode * inode, struct file * file)
                struct ieee1284_info *info;
 
                /* parport released, but not in compatibility mode */
-               parport_claim_or_block (pp->pdev);
+               parport_claim_or_block(pp->pdev);
                pp->flags |= PP_CLAIMED;
                info = &pp->pdev->port->ieee1284;
                pp->saved_state.mode = info->mode;
@@ -733,7 +733,7 @@ static int pp_release (struct inode * inode, struct file * file)
                compat_negot = 2;
        }
        if (compat_negot) {
-               parport_negotiate (pp->pdev->port, IEEE1284_MODE_COMPAT);
+               parport_negotiate(pp->pdev->port, IEEE1284_MODE_COMPAT);
                pr_debug(CHRDEV "%x: negotiated back to compatibility "
                        "mode because user-space forgot\n", minor);
        }
@@ -746,7 +746,7 @@ static int pp_release (struct inode * inode, struct file * file)
                pp->state.phase = info->phase;
                info->mode = pp->saved_state.mode;
                info->phase = pp->saved_state.phase;
-               parport_release (pp->pdev);
+               parport_release(pp->pdev);
                if (compat_negot != 1) {
                        pr_debug(CHRDEV "%x: released pardevice "
                                "because user-space forgot\n", minor);
@@ -755,25 +755,25 @@ static int pp_release (struct inode * inode, struct file * file)
 
        if (pp->pdev) {
                const char *name = pp->pdev->name;
-               parport_unregister_device (pp->pdev);
-               kfree (name);
+               parport_unregister_device(pp->pdev);
+               kfree(name);
                pp->pdev = NULL;
                pr_debug(CHRDEV "%x: unregistered pardevice\n", minor);
        }
 
-       kfree (pp);
+       kfree(pp);
 
        return 0;
 }
 
 /* No kernel lock held - fine */
-static unsigned int pp_poll (struct file * file, poll_table * wait)
+static unsigned int pp_poll(struct file * file, poll_table * wait)
 {
        struct pp_struct *pp = file->private_data;
        unsigned int mask = 0;
 
-       poll_wait (file, &pp->irq_wait, wait);
-       if (atomic_read (&pp->irqc))
+       poll_wait(file, &pp->irq_wait, wait);
+       if (atomic_read(&pp->irqc))
                mask |= POLLIN | POLLRDNORM;
 
        return mask;
@@ -812,12 +812,12 @@ static struct parport_driver pp_driver = {
        .detach         = pp_detach,
 };
 
-static int __init ppdev_init (void)
+static int __init ppdev_init(void)
 {
        int err = 0;
 
-       if (register_chrdev (PP_MAJOR, CHRDEV, &pp_fops)) {
-               printk (KERN_WARNING CHRDEV ": unable to get major %d\n",
+       if (register_chrdev(PP_MAJOR, CHRDEV, &pp_fops)) {
+               printk(KERN_WARNING CHRDEV ": unable to get major %d\n",
                        PP_MAJOR);
                return -EIO;
        }
@@ -828,11 +828,11 @@ static int __init ppdev_init (void)
        }
        err = parport_register_driver(&pp_driver);
        if (err < 0) {
-               printk (KERN_WARNING CHRDEV ": unable to register with parport\n");
+               printk(KERN_WARNING CHRDEV ": unable to register with parport\n");
                goto out_class;
        }
 
-       printk (KERN_INFO PP_VERSION "\n");
+       printk(KERN_INFO PP_VERSION "\n");
        goto out;
 
 out_class:
@@ -843,12 +843,12 @@ out:
        return err;
 }
 
-static void __exit ppdev_cleanup (void)
+static void __exit ppdev_cleanup(void)
 {
        /* Clean up all parport stuff */
        parport_unregister_driver(&pp_driver);
        class_destroy(ppdev_class);
-       unregister_chrdev (PP_MAJOR, CHRDEV);
+       unregister_chrdev(PP_MAJOR, CHRDEV);
 }
 
 module_init(ppdev_init);