From CARLOS.PALMINHA at synopsys.com  Mon Jul 17 09:36:57 2017
From: CARLOS.PALMINHA at synopsys.com (Carlos Palminha)
Date: Mon, 17 Jul 2017 17:36:57 +0100
Subject: [Linux-parport] [PATCH 0/5] parport: cleanup several checkpatch
 issues
Message-ID: <20170717163702.17427-1-palminha@synopsys.com>

cleanup 6 type of checkpatch issues, each type per patch:
  - trailing statements should be on next line
  - space prohibited between function name and open parenthesis '('
  - do not initialise statics to 0 / NULL
  - that open brace { should be on the previous line
  - braces {} are not necessary for any arm of this statement

The patchset was based on linux next, tag next-20170714

Carlos Palminha (5):
  parport: add newline to trailing statements
  parport: cleanup prohibited space after functions name
  parport: cleanup statics initialization to NULL or 0
  parport: move open braces to the same line
  parport: remove unnecessary braces

 drivers/parport/daisy.c          |  12 +-
 drivers/parport/ieee1284.c       | 267 +++++++++++++++---------------
 drivers/parport/ieee1284_ops.c   | 345 ++++++++++++++++++++-------------------
 drivers/parport/parport_atari.c  |   6 +-
 drivers/parport/parport_cs.c     |   4 +-
 drivers/parport/parport_gsc.c    |  78 ++++-----
 drivers/parport/parport_ip32.c   |   2 +-
 drivers/parport/parport_mfc3.c   |   4 +-
 drivers/parport/parport_pc.c     |   3 +-
 drivers/parport/parport_serial.c |  52 +++---
 drivers/parport/parport_sunbpp.c |  29 ++--
 drivers/parport/probe.c          |  46 +++---
 drivers/parport/procfs.c         |  28 ++--
 13 files changed, 438 insertions(+), 438 deletions(-)

-- 
2.11.0



From CARLOS.PALMINHA at synopsys.com  Mon Jul 17 09:36:58 2017
From: CARLOS.PALMINHA at synopsys.com (Carlos Palminha)
Date: Mon, 17 Jul 2017 17:36:58 +0100
Subject: [Linux-parport] [PATCH 1/5] parport: add newline to trailing
 statements
In-Reply-To: <20170717163702.17427-1-palminha@synopsys.com>
References: <20170717163702.17427-1-palminha@synopsys.com>
Message-ID: <20170717163702.17427-2-palminha@synopsys.com>

based on checkpatch, add newline to trailing statements

Signed-off-by: Carlos Palminha <palminha at synopsys.com>
---
 drivers/parport/daisy.c        |  7 +++++--
 drivers/parport/ieee1284.c     | 17 +++++++++--------
 drivers/parport/ieee1284_ops.c |  8 ++++++--
 drivers/parport/parport_cs.c   |  4 +++-
 drivers/parport/parport_gsc.c  |  6 ++++--
 drivers/parport/probe.c        |  4 +++-
 6 files changed, 30 insertions(+), 16 deletions(-)

diff --git a/drivers/parport/daisy.c b/drivers/parport/daisy.c
index 46eb15fb57ff..209f3e61964e 100644
--- a/drivers/parport/daisy.c
+++ b/drivers/parport/daisy.c
@@ -191,7 +191,9 @@ void parport_daisy_fini(struct parport *port)
 	/* Gaps in the numbering could be handled better.  How should
            someone enumerate through all IEEE1284.3 devices in the
            topology?. */
-	if (!topology) numdevs = 0;
+	if (!topology)
+		numdevs = 0;
+
 	spin_unlock(&topology_lock);
 	return;
 }
@@ -472,7 +474,8 @@ static int assign_addrs(struct parport *port)
 
 	/* Ask the new devices to introduce themselves. */
 	deviceid = kmalloc(1024, GFP_KERNEL);
-	if (!deviceid) return 0;
+	if (!deviceid)
+		return 0;
 
 	for (daisy = 0; thisdev < numdevs; thisdev++, daisy++)
 		parport_device_id(thisdev, deviceid, 1024);
diff --git a/drivers/parport/ieee1284.c b/drivers/parport/ieee1284.c
index 74cc6dd982d2..b40ee76d519d 100644
--- a/drivers/parport/ieee1284.c
+++ b/drivers/parport/ieee1284.c
@@ -536,16 +536,17 @@ int parport_negotiate (struct parport *port, int mode)
 		port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
 		DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n",
 			 port->name);
-	} else switch (mode) {
-	case IEEE1284_MODE_NIBBLE:
-	case IEEE1284_MODE_BYTE:
-		port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
-		break;
-	default:
-		port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
+	} else {
+		switch (mode) {
+		case IEEE1284_MODE_NIBBLE:
+		case IEEE1284_MODE_BYTE:
+			port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
+			break;
+		default:
+			port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
+		}
 	}
 
-
 	return 0;
 #endif /* IEEE1284 support */
 }
diff --git a/drivers/parport/ieee1284_ops.c b/drivers/parport/ieee1284_ops.c
index a959224d011b..bfc9cde9a21d 100644
--- a/drivers/parport/ieee1284_ops.c
+++ b/drivers/parport/ieee1284_ops.c
@@ -468,7 +468,9 @@ size_t parport_ieee1284_ecp_write_data (struct parport *port,
 		DPRINTK (KERN_DEBUG "%s: Host transfer recovered\n",
 			 port->name);
 
-		if (time_after_eq (jiffies, expire)) break;
+		if (time_after_eq (jiffies, expire))
+			break;
+
 		goto try_again;
 	success:
 		parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
@@ -704,7 +706,9 @@ size_t parport_ieee1284_ecp_write_addr (struct parport *port,
 		DPRINTK (KERN_DEBUG "%s: Host transfer recovered\n",
 			 port->name);
 
-		if (time_after_eq (jiffies, expire)) break;
+		if (time_after_eq (jiffies, expire))
+			break;
+
 		goto try_again;
 	success:
 		parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
diff --git a/drivers/parport/parport_cs.c b/drivers/parport/parport_cs.c
index e9b52e4a4648..993565fef73b 100644
--- a/drivers/parport/parport_cs.c
+++ b/drivers/parport/parport_cs.c
@@ -88,7 +88,9 @@ static int parport_probe(struct pcmcia_device *link)
 
     /* Create new parport device */
     info = kzalloc(sizeof(*info), GFP_KERNEL);
-    if (!info) return -ENOMEM;
+    if (!info)
+        return -ENOMEM;
+
     link->priv = info;
     info->p_dev = link;
 
diff --git a/drivers/parport/parport_gsc.c b/drivers/parport/parport_gsc.c
index 3858b87fd0bb..fc1c4192121b 100644
--- a/drivers/parport/parport_gsc.c
+++ b/drivers/parport/parport_gsc.c
@@ -211,10 +211,12 @@ static int parport_PS2_supported(struct parport *pb)
 	parport_gsc_data_reverse (pb);
 	
 	parport_gsc_write_data(pb, 0x55);
-	if (parport_gsc_read_data(pb) != 0x55) ok++;
+	if (parport_gsc_read_data(pb) != 0x55)
+		ok++;
 
 	parport_gsc_write_data(pb, 0xaa);
-	if (parport_gsc_read_data(pb) != 0xaa) ok++;
+	if (parport_gsc_read_data(pb) != 0xaa)
+		ok++;
 
 	/* cancel input mode */
 	parport_gsc_data_forward (pb);
diff --git a/drivers/parport/probe.c b/drivers/parport/probe.c
index 4d1d6eaf333d..f2618cc1c793 100644
--- a/drivers/parport/probe.c
+++ b/drivers/parport/probe.c
@@ -64,7 +64,9 @@ static void parse_data(struct parport *port, int device, char *str)
 	while (p) {
 		char *sep;
 		q = strchr(p, ';');
-		if (q) *q = 0;
+		if (q)
+			*q = 0;
+
 		sep = strchr(p, ':');
 		if (sep) {
 			char *u;
-- 
2.11.0



From CARLOS.PALMINHA at synopsys.com  Mon Jul 17 09:37:01 2017
From: CARLOS.PALMINHA at synopsys.com (Carlos Palminha)
Date: Mon, 17 Jul 2017 17:37:01 +0100
Subject: [Linux-parport] [PATCH 4/5] parport: move open braces to the same
 line
In-Reply-To: <20170717163702.17427-1-palminha@synopsys.com>
References: <20170717163702.17427-1-palminha@synopsys.com>
Message-ID: <20170717163702.17427-5-palminha@synopsys.com>

based on checkpatch, cleanup the open braces that "should be on the
previous line".

Signed-off-by: Carlos Palminha <palminha at synopsys.com>
---
 drivers/parport/daisy.c          | 3 +--
 drivers/parport/parport_gsc.c    | 3 +--
 drivers/parport/parport_sunbpp.c | 3 +--
 3 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/drivers/parport/daisy.c b/drivers/parport/daisy.c
index 568d3733ae4e..b19d7f632edb 100644
--- a/drivers/parport/daisy.c
+++ b/drivers/parport/daisy.c
@@ -354,8 +354,7 @@ void parport_daisy_deselect_all(struct parport *port)
 
 int parport_daisy_select(struct parport *port, int daisy, int mode)
 {
-	switch (mode)
-	{
+	switch (mode) {
 		// For these modes we should switch to EPP mode:
 		case IEEE1284_MODE_EPP:
 		case IEEE1284_MODE_EPPSL:
diff --git a/drivers/parport/parport_gsc.c b/drivers/parport/parport_gsc.c
index 626df53d6d9d..9c2493fa29ff 100644
--- a/drivers/parport/parport_gsc.c
+++ b/drivers/parport/parport_gsc.c
@@ -95,8 +95,7 @@ void parport_gsc_restore_state(struct parport *p, struct parport_state *s)
 	parport_writeb(s->u.pc.ctr, CONTROL(p));
 }
 
-struct parport_operations parport_gsc_ops = 
-{
+struct parport_operations parport_gsc_ops = {
 	.write_data	= parport_gsc_write_data,
 	.read_data	= parport_gsc_read_data,
 
diff --git a/drivers/parport/parport_sunbpp.c b/drivers/parport/parport_sunbpp.c
index c87bf4ac2006..6037008579f1 100644
--- a/drivers/parport/parport_sunbpp.c
+++ b/drivers/parport/parport_sunbpp.c
@@ -228,8 +228,7 @@ static void parport_sunbpp_restore_state(struct parport *p, struct parport_state
 	parport_sunbpp_write_control(p, s->u.pc.ctr);
 }
 
-static struct parport_operations parport_sunbpp_ops = 
-{
+static struct parport_operations parport_sunbpp_ops = {
 	.write_data	= parport_sunbpp_write_data,
 	.read_data	= parport_sunbpp_read_data,
 
-- 
2.11.0



From CARLOS.PALMINHA at synopsys.com  Mon Jul 17 09:37:00 2017
From: CARLOS.PALMINHA at synopsys.com (Carlos Palminha)
Date: Mon, 17 Jul 2017 17:37:00 +0100
Subject: [Linux-parport] [PATCH 3/5] parport: cleanup statics initialization
 to NULL or 0
In-Reply-To: <20170717163702.17427-1-palminha@synopsys.com>
References: <20170717163702.17427-1-palminha@synopsys.com>
Message-ID: <20170717163702.17427-4-palminha@synopsys.com>

based on checkpatch, cleanup the "do not initialise statics to" 0 or NULL.

Signed-off-by: Carlos Palminha <palminha at synopsys.com>
---
 drivers/parport/daisy.c         | 2 +-
 drivers/parport/parport_atari.c | 2 +-
 drivers/parport/parport_ip32.c  | 2 +-
 drivers/parport/parport_mfc3.c  | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/drivers/parport/daisy.c b/drivers/parport/daisy.c
index 209f3e61964e..568d3733ae4e 100644
--- a/drivers/parport/daisy.c
+++ b/drivers/parport/daisy.c
@@ -44,7 +44,7 @@ static struct daisydev {
 } *topology = NULL;
 static DEFINE_SPINLOCK(topology_lock);
 
-static int numdevs = 0;
+static int numdevs;
 
 /* Forward-declaration of lower-level functions. */
 static int mux_present(struct parport *port);
diff --git a/drivers/parport/parport_atari.c b/drivers/parport/parport_atari.c
index b8da1b5f550c..8303cc373ab0 100644
--- a/drivers/parport/parport_atari.c
+++ b/drivers/parport/parport_atari.c
@@ -18,7 +18,7 @@
 #include <asm/irq.h>
 #include <asm/atariints.h>
 
-static struct parport *this_port = NULL;
+static struct parport *this_port;
 
 static unsigned char
 parport_atari_read_data(struct parport *p)
diff --git a/drivers/parport/parport_ip32.c b/drivers/parport/parport_ip32.c
index dcbeeb220dda..0186db7680d4 100644
--- a/drivers/parport/parport_ip32.c
+++ b/drivers/parport/parport_ip32.c
@@ -138,7 +138,7 @@ static unsigned int features =	~0U;
 static bool verbose_probing =	DEFAULT_VERBOSE_PROBING;
 
 /* We do not support more than one port. */
-static struct parport *this_port = NULL;
+static struct parport *this_port;
 
 /* Timing constants for FIFO modes.  */
 #define FIFO_NFAULT_TIMEOUT	100	/* milliseconds */
diff --git a/drivers/parport/parport_mfc3.c b/drivers/parport/parport_mfc3.c
index d650b00ce38a..2467633504b6 100644
--- a/drivers/parport/parport_mfc3.c
+++ b/drivers/parport/parport_mfc3.c
@@ -174,7 +174,7 @@ DPRINTK(KERN_DEBUG "read_status %02x\n", status);
 	return status;
 }
 
-static int use_cnt = 0;
+static int use_cnt;
 
 static irqreturn_t mfc3_interrupt(int irq, void *dev_id)
 {
-- 
2.11.0



From CARLOS.PALMINHA at synopsys.com  Mon Jul 17 09:36:59 2017
From: CARLOS.PALMINHA at synopsys.com (Carlos Palminha)
Date: Mon, 17 Jul 2017 17:36:59 +0100
Subject: [Linux-parport] [PATCH 2/5] parport: cleanup prohibited space after
 functions name
In-Reply-To: <20170717163702.17427-1-palminha@synopsys.com>
References: <20170717163702.17427-1-palminha@synopsys.com>
Message-ID: <20170717163702.17427-3-palminha@synopsys.com>

based on checkpatch, remove prohibited space between function name and
open parenthesis '('.

Signed-off-by: Carlos Palminha <palminha at synopsys.com>
---
 drivers/parport/ieee1284.c       | 212 ++++++++++++------------
 drivers/parport/ieee1284_ops.c   | 338 +++++++++++++++++++--------------------
 drivers/parport/parport_atari.c  |   4 +-
 drivers/parport/parport_gsc.c    |  62 +++----
 drivers/parport/parport_mfc3.c   |   2 +-
 drivers/parport/parport_serial.c |  52 +++---
 drivers/parport/parport_sunbpp.c |   6 +-
 drivers/parport/probe.c          |  42 ++---
 drivers/parport/procfs.c         |  22 +--
 9 files changed, 370 insertions(+), 370 deletions(-)

diff --git a/drivers/parport/ieee1284.c b/drivers/parport/ieee1284.c
index b40ee76d519d..27673b838e74 100644
--- a/drivers/parport/ieee1284.c
+++ b/drivers/parport/ieee1284.c
@@ -32,22 +32,22 @@
 #endif
 
 #ifdef DEBUG
-#define DPRINTK(stuff...) printk (stuff)
+#define DPRINTK(stuff...) printk(stuff)
 #else
 #define DPRINTK(stuff...)
 #endif
 
 /* Make parport_wait_peripheral wake up.
  * It will be useful to call this from an interrupt handler. */
-static void parport_ieee1284_wakeup (struct parport *port)
+static void parport_ieee1284_wakeup(struct parport *port)
 {
-	up (&port->physport->ieee1284.irq);
+	up(&port->physport->ieee1284.irq);
 }
 
 static struct parport *port_from_cookie[PARPORT_MAX];
-static void timeout_waiting_on_port (unsigned long cookie)
+static void timeout_waiting_on_port(unsigned long cookie)
 {
-	parport_ieee1284_wakeup (port_from_cookie[cookie % PARPORT_MAX]);
+	parport_ieee1284_wakeup(port_from_cookie[cookie % PARPORT_MAX]);
 }
 
 /**
@@ -66,7 +66,7 @@ static void timeout_waiting_on_port (unsigned long cookie)
  *	what it's doing as soon as it can.
  */
 
-int parport_wait_event (struct parport *port, signed long timeout)
+int parport_wait_event(struct parport *port, signed long timeout)
 {
 	int ret;
 	struct timer_list timer;
@@ -82,8 +82,8 @@ int parport_wait_event (struct parport *port, signed long timeout)
 	port_from_cookie[port->number % PARPORT_MAX] = port;
 	timer.data = port->number;
 
-	add_timer (&timer);
-	ret = down_interruptible (&port->physport->ieee1284.irq);
+	add_timer(&timer);
+	ret = down_interruptible(&port->physport->ieee1284.irq);
 	if (!del_timer_sync(&timer) && !ret)
 		/* Timed out. */
 		ret = 1;
@@ -127,15 +127,15 @@ int parport_poll_peripheral(struct parport *port,
 	int i;
 	unsigned char status;
 	for (i = 0; i < count; i++) {
-		status = parport_read_status (port);
+		status = parport_read_status(port);
 		if ((status & mask) == result)
 			return 0;
-		if (signal_pending (current))
+		if (signal_pending(current))
 			return -EINTR;
 		if (need_resched())
 			break;
 		if (i >= 2)
-			udelay (5);
+			udelay(5);
 	}
 
 	return 1;
@@ -187,7 +187,7 @@ int parport_wait_peripheral(struct parport *port,
 	 * How about making a note (in the device structure) of how long
 	 * it takes, so we know for next time?
 	 */
-	ret = parport_poll_peripheral (port, mask, result, usec);
+	ret = parport_poll_peripheral(port, mask, result, usec);
 	if (ret != 1)
 		return ret;
 
@@ -198,16 +198,16 @@ int parport_wait_peripheral(struct parport *port,
 
 	/* 40ms of slow polling. */
 	deadline = jiffies + msecs_to_jiffies(40);
-	while (time_before (jiffies, deadline)) {
-		if (signal_pending (current))
+	while (time_before(jiffies, deadline)) {
+		if (signal_pending(current))
 			return -EINTR;
 
 		/* Wait for 10ms (or until an interrupt occurs if
 		 * the handler is set) */
-		if ((ret = parport_wait_event (port, msecs_to_jiffies(10))) < 0)
+		if ((ret = parport_wait_event(port, msecs_to_jiffies(10))) < 0)
 			return ret;
 
-		status = parport_read_status (port);
+		status = parport_read_status(port);
 		if ((status & mask) == result)
 			return 0;
 
@@ -224,7 +224,7 @@ int parport_wait_peripheral(struct parport *port,
 
 #ifdef CONFIG_PARPORT_1284
 /* Terminate a negotiated mode. */
-static void parport_ieee1284_terminate (struct parport *port)
+static void parport_ieee1284_terminate(struct parport *port)
 {
 	int r;
 	port = port->physport;
@@ -237,11 +237,11 @@ static void parport_ieee1284_terminate (struct parport *port)
 		/* Terminate from EPP mode. */
 
 		/* Event 68: Set nInit low */
-		parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
-		udelay (50);
+		parport_frob_control(port, PARPORT_CONTROL_INIT, 0);
+		udelay(50);
 
 		/* Event 69: Set nInit high, nSelectIn low */
-		parport_frob_control (port,
+		parport_frob_control(port,
 				      PARPORT_CONTROL_SELECT
 				      | PARPORT_CONTROL_INIT,
 				      PARPORT_CONTROL_SELECT
@@ -254,22 +254,22 @@ static void parport_ieee1284_terminate (struct parport *port)
 		/* In ECP we can only terminate from fwd idle phase. */
 		if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE) {
 			/* Event 47: Set nInit high */
-			parport_frob_control (port,
+			parport_frob_control(port,
 					      PARPORT_CONTROL_INIT
 					      | PARPORT_CONTROL_AUTOFD,
 					      PARPORT_CONTROL_INIT
 					      | PARPORT_CONTROL_AUTOFD);
 
 			/* Event 49: PError goes high */
-			r = parport_wait_peripheral (port,
+			r = parport_wait_peripheral(port,
 						     PARPORT_STATUS_PAPEROUT,
 						     PARPORT_STATUS_PAPEROUT);
 			if (r)
-				DPRINTK (KERN_INFO "%s: Timeout at event 49\n",
+				DPRINTK(KERN_INFO "%s: Timeout at event 49\n",
 					 port->name);
 
-			parport_data_forward (port);
-			DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n",
+			parport_data_forward(port);
+			DPRINTK(KERN_DEBUG "%s: ECP direction: forward\n",
 				 port->name);
 			port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
 		}
@@ -280,38 +280,38 @@ static void parport_ieee1284_terminate (struct parport *port)
 		/* Terminate from all other modes. */
 
 		/* Event 22: Set nSelectIn low, nAutoFd high */
-		parport_frob_control (port,
+		parport_frob_control(port,
 				      PARPORT_CONTROL_SELECT
 				      | PARPORT_CONTROL_AUTOFD,
 				      PARPORT_CONTROL_SELECT);
 
 		/* Event 24: nAck goes low */
-		r = parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0);
+		r = parport_wait_peripheral(port, PARPORT_STATUS_ACK, 0);
 		if (r)
-			DPRINTK (KERN_INFO "%s: Timeout at event 24\n",
+			DPRINTK(KERN_INFO "%s: Timeout at event 24\n",
 				 port->name);
 
 		/* Event 25: Set nAutoFd low */
-		parport_frob_control (port,
+		parport_frob_control(port,
 				      PARPORT_CONTROL_AUTOFD,
 				      PARPORT_CONTROL_AUTOFD);
 
 		/* Event 27: nAck goes high */
-		r = parport_wait_peripheral (port,
+		r = parport_wait_peripheral(port,
 					     PARPORT_STATUS_ACK, 
 					     PARPORT_STATUS_ACK);
 		if (r)
-			DPRINTK (KERN_INFO "%s: Timeout at event 27\n",
+			DPRINTK(KERN_INFO "%s: Timeout at event 27\n",
 				 port->name);
 
 		/* Event 29: Set nAutoFd high */
-		parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
+		parport_frob_control(port, PARPORT_CONTROL_AUTOFD, 0);
 	}
 
 	port->ieee1284.mode = IEEE1284_MODE_COMPAT;
 	port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
 
-	DPRINTK (KERN_DEBUG "%s: In compatibility (forward idle) mode\n",
+	DPRINTK(KERN_DEBUG "%s: In compatibility (forward idle) mode\n",
 		 port->name);
 }		
 #endif /* IEEE1284 support */
@@ -331,12 +331,12 @@ static void parport_ieee1284_terminate (struct parport *port)
  *	has rejected the negotiation.
  */
 
-int parport_negotiate (struct parport *port, int mode)
+int parport_negotiate(struct parport *port, int mode)
 {
 #ifndef CONFIG_PARPORT_1284
 	if (mode == IEEE1284_MODE_COMPAT)
 		return 0;
-	printk (KERN_ERR "parport: IEEE1284 not supported in this kernel\n");
+	printk(KERN_ERR "parport: IEEE1284 not supported in this kernel\n");
 	return -1;
 #else
 	int m = mode & ~IEEE1284_ADDR;
@@ -357,7 +357,7 @@ int parport_negotiate (struct parport *port, int mode)
 
 	/* Go to compatibility forward idle mode */
 	if (port->ieee1284.mode != IEEE1284_MODE_COMPAT)
-		parport_ieee1284_terminate (port);
+		parport_ieee1284_terminate(port);
 
 	if (mode == IEEE1284_MODE_COMPAT)
 		/* Compatibility mode: no negotiation. */
@@ -381,7 +381,7 @@ int parport_negotiate (struct parport *port, int mode)
 	port->ieee1284.phase = IEEE1284_PH_NEGOTIATION;
 
 	/* Start off with nStrobe and nAutoFd high, and nSelectIn low */
-	parport_frob_control (port,
+	parport_frob_control(port,
 			      PARPORT_CONTROL_STROBE
 			      | PARPORT_CONTROL_AUTOFD
 			      | PARPORT_CONTROL_SELECT,
@@ -389,18 +389,18 @@ int parport_negotiate (struct parport *port, int mode)
 	udelay(1);
 
 	/* Event 0: Set data */
-	parport_data_forward (port);
-	parport_write_data (port, m);
-	udelay (400); /* Shouldn't need to wait this long. */
+	parport_data_forward(port);
+	parport_write_data(port, m);
+	udelay(400); /* Shouldn't need to wait this long. */
 
 	/* Event 1: Set nSelectIn high, nAutoFd low */
-	parport_frob_control (port,
+	parport_frob_control(port,
 			      PARPORT_CONTROL_SELECT
 			      | PARPORT_CONTROL_AUTOFD,
 			      PARPORT_CONTROL_AUTOFD);
 
 	/* Event 2: PError, Select, nFault go high, nAck goes low */
-	if (parport_wait_peripheral (port,
+	if (parport_wait_peripheral(port,
 				     PARPORT_STATUS_ERROR
 				     | PARPORT_STATUS_SELECT
 				     | PARPORT_STATUS_PAPEROUT
@@ -409,102 +409,102 @@ int parport_negotiate (struct parport *port, int mode)
 				     | PARPORT_STATUS_SELECT
 				     | PARPORT_STATUS_PAPEROUT)) {
 		/* Timeout */
-		parport_frob_control (port,
+		parport_frob_control(port,
 				      PARPORT_CONTROL_SELECT
 				      | PARPORT_CONTROL_AUTOFD,
 				      PARPORT_CONTROL_SELECT);
-		DPRINTK (KERN_DEBUG
+		DPRINTK(KERN_DEBUG
 			 "%s: Peripheral not IEEE1284 compliant (0x%02X)\n",
-			 port->name, parport_read_status (port));
+			 port->name, parport_read_status(port));
 		port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
 		return -1; /* Not IEEE1284 compliant */
 	}
 
 	/* Event 3: Set nStrobe low */
-	parport_frob_control (port,
+	parport_frob_control(port,
 			      PARPORT_CONTROL_STROBE,
 			      PARPORT_CONTROL_STROBE);
 
 	/* Event 4: Set nStrobe and nAutoFd high */
-	udelay (5);
-	parport_frob_control (port,
+	udelay(5);
+	parport_frob_control(port,
 			      PARPORT_CONTROL_STROBE
 			      | PARPORT_CONTROL_AUTOFD,
 			      0);
 
 	/* Event 6: nAck goes high */
-	if (parport_wait_peripheral (port,
+	if (parport_wait_peripheral(port,
 				     PARPORT_STATUS_ACK,
 				     PARPORT_STATUS_ACK)) {
 		/* This shouldn't really happen with a compliant device. */
-		DPRINTK (KERN_DEBUG
+		DPRINTK(KERN_DEBUG
 			 "%s: Mode 0x%02x not supported? (0x%02x)\n",
-			 port->name, mode, port->ops->read_status (port));
-		parport_ieee1284_terminate (port);
+			 port->name, mode, port->ops->read_status(port));
+		parport_ieee1284_terminate(port);
 		return 1;
 	}
 
-	xflag = parport_read_status (port) & PARPORT_STATUS_SELECT;
+	xflag = parport_read_status(port) & PARPORT_STATUS_SELECT;
 
 	/* xflag should be high for all modes other than nibble (0). */
 	if (mode && !xflag) {
 		/* Mode not supported. */
-		DPRINTK (KERN_DEBUG "%s: Mode 0x%02x rejected by peripheral\n",
+		DPRINTK(KERN_DEBUG "%s: Mode 0x%02x rejected by peripheral\n",
 			 port->name, mode);
-		parport_ieee1284_terminate (port);
+		parport_ieee1284_terminate(port);
 		return 1;
 	}
 
 	/* More to do if we've requested extensibility link. */
 	if (mode & IEEE1284_EXT_LINK) {
 		m = mode & 0x7f;
-		udelay (1);
-		parport_write_data (port, m);
-		udelay (1);
+		udelay(1);
+		parport_write_data(port, m);
+		udelay(1);
 
 		/* Event 51: Set nStrobe low */
-		parport_frob_control (port,
+		parport_frob_control(port,
 				      PARPORT_CONTROL_STROBE,
 				      PARPORT_CONTROL_STROBE);
 
 		/* Event 52: nAck goes low */
-		if (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0)) {
+		if (parport_wait_peripheral(port, PARPORT_STATUS_ACK, 0)) {
 			/* This peripheral is _very_ slow. */
-			DPRINTK (KERN_DEBUG
+			DPRINTK(KERN_DEBUG
 				 "%s: Event 52 didn't happen\n",
 				 port->name);
-			parport_ieee1284_terminate (port);
+			parport_ieee1284_terminate(port);
 			return 1;
 		}
 
 		/* Event 53: Set nStrobe high */
-		parport_frob_control (port,
+		parport_frob_control(port,
 				      PARPORT_CONTROL_STROBE,
 				      0);
 
 		/* Event 55: nAck goes high */
-		if (parport_wait_peripheral (port,
+		if (parport_wait_peripheral(port,
 					     PARPORT_STATUS_ACK,
 					     PARPORT_STATUS_ACK)) {
 			/* This shouldn't really happen with a compliant
 			 * device. */
-			DPRINTK (KERN_DEBUG
+			DPRINTK(KERN_DEBUG
 				 "%s: Mode 0x%02x not supported? (0x%02x)\n",
 				 port->name, mode,
-				 port->ops->read_status (port));
-			parport_ieee1284_terminate (port);
+				 port->ops->read_status(port));
+			parport_ieee1284_terminate(port);
 			return 1;
 		}
 
 		/* Event 54: Peripheral sets XFlag to reflect support */
-		xflag = parport_read_status (port) & PARPORT_STATUS_SELECT;
+		xflag = parport_read_status(port) & PARPORT_STATUS_SELECT;
 
 		/* xflag should be high. */
 		if (!xflag) {
 			/* Extended mode not supported. */
-			DPRINTK (KERN_DEBUG "%s: Extended mode 0x%02x not "
+			DPRINTK(KERN_DEBUG "%s: Extended mode 0x%02x not "
 				 "supported\n", port->name, mode);
-			parport_ieee1284_terminate (port);
+			parport_ieee1284_terminate(port);
 			return 1;
 		}
 
@@ -512,7 +512,7 @@ int parport_negotiate (struct parport *port, int mode)
 	}
 
 	/* Mode is supported */
-	DPRINTK (KERN_DEBUG "%s: In mode 0x%02x\n", port->name, mode);
+	DPRINTK(KERN_DEBUG "%s: In mode 0x%02x\n", port->name, mode);
 	port->ieee1284.mode = mode;
 
 	/* But ECP is special */
@@ -520,21 +520,21 @@ int parport_negotiate (struct parport *port, int mode)
 		port->ieee1284.phase = IEEE1284_PH_ECP_SETUP;
 
 		/* Event 30: Set nAutoFd low */
-		parport_frob_control (port,
+		parport_frob_control(port,
 				      PARPORT_CONTROL_AUTOFD,
 				      PARPORT_CONTROL_AUTOFD);
 
 		/* Event 31: PError goes high. */
-		r = parport_wait_peripheral (port,
+		r = parport_wait_peripheral(port,
 					     PARPORT_STATUS_PAPEROUT,
 					     PARPORT_STATUS_PAPEROUT);
 		if (r) {
-			DPRINTK (KERN_INFO "%s: Timeout at event 31\n",
+			DPRINTK(KERN_INFO "%s: Timeout at event 31\n",
 				port->name);
 		}
 
 		port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
-		DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n",
+		DPRINTK(KERN_DEBUG "%s: ECP direction: forward\n",
 			 port->name);
 	} else {
 		switch (mode) {
@@ -558,31 +558,31 @@ int parport_negotiate (struct parport *port, int mode)
  * Returns zero if data was available.
  */
 #ifdef CONFIG_PARPORT_1284
-static int parport_ieee1284_ack_data_avail (struct parport *port)
+static int parport_ieee1284_ack_data_avail(struct parport *port)
 {
-	if (parport_read_status (port) & PARPORT_STATUS_ERROR)
+	if (parport_read_status(port) & PARPORT_STATUS_ERROR)
 		/* Event 18 didn't happen. */
 		return -1;
 
 	/* Event 20: nAutoFd goes high. */
-	port->ops->frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
+	port->ops->frob_control(port, PARPORT_CONTROL_AUTOFD, 0);
 	port->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;
 	return 0;
 }
 #endif /* IEEE1284 support */
 
 /* Handle an interrupt. */
-void parport_ieee1284_interrupt (void *handle)
+void parport_ieee1284_interrupt(void *handle)
 {
 	struct parport *port = handle;
-	parport_ieee1284_wakeup (port);
+	parport_ieee1284_wakeup(port);
 
 #ifdef CONFIG_PARPORT_1284
 	if (port->ieee1284.phase == IEEE1284_PH_REV_IDLE) {
 		/* An interrupt in this phase means that data
 		 * is now available. */
-		DPRINTK (KERN_DEBUG "%s: Data available\n", port->name);
-		parport_ieee1284_ack_data_avail (port);
+		DPRINTK(KERN_DEBUG "%s: Data available\n", port->name);
+		parport_ieee1284_ack_data_avail(port);
 	}
 #endif /* IEEE1284 support */
 }
@@ -605,10 +605,10 @@ void parport_ieee1284_interrupt (void *handle)
  *	or positive), or else an error code.
  */
 
-ssize_t parport_write (struct parport *port, const void *buffer, size_t len)
+ssize_t parport_write(struct parport *port, const void *buffer, size_t len)
 {
 #ifndef CONFIG_PARPORT_1284
-	return port->ops->compat_write_data (port, buffer, len, 0);
+	return port->ops->compat_write_data(port, buffer, len, 0);
 #else
 	ssize_t retval;
 	int mode = port->ieee1284.mode;
@@ -622,15 +622,15 @@ ssize_t parport_write (struct parport *port, const void *buffer, size_t len)
 	switch (mode) {
 	case IEEE1284_MODE_NIBBLE:
 	case IEEE1284_MODE_BYTE:
-		parport_negotiate (port, IEEE1284_MODE_COMPAT);
+		parport_negotiate(port, IEEE1284_MODE_COMPAT);
 	case IEEE1284_MODE_COMPAT:
-		DPRINTK (KERN_DEBUG "%s: Using compatibility mode\n",
+		DPRINTK(KERN_DEBUG "%s: Using compatibility mode\n",
 			 port->name);
 		fn = port->ops->compat_write_data;
 		break;
 
 	case IEEE1284_MODE_EPP:
-		DPRINTK (KERN_DEBUG "%s: Using EPP mode\n", port->name);
+		DPRINTK(KERN_DEBUG "%s: Using EPP mode\n", port->name);
 		if (addr) {
 			fn = port->ops->epp_write_addr;
 		} else {
@@ -638,7 +638,7 @@ ssize_t parport_write (struct parport *port, const void *buffer, size_t len)
 		}
 		break;
 	case IEEE1284_MODE_EPPSWE:
-		DPRINTK (KERN_DEBUG "%s: Using software-emulated EPP mode\n",
+		DPRINTK(KERN_DEBUG "%s: Using software-emulated EPP mode\n",
 			port->name);
 		if (addr) {
 			fn = parport_ieee1284_epp_write_addr;
@@ -648,7 +648,7 @@ ssize_t parport_write (struct parport *port, const void *buffer, size_t len)
 		break;
 	case IEEE1284_MODE_ECP:
 	case IEEE1284_MODE_ECPRLE:
-		DPRINTK (KERN_DEBUG "%s: Using ECP mode\n", port->name);
+		DPRINTK(KERN_DEBUG "%s: Using ECP mode\n", port->name);
 		if (addr) {
 			fn = port->ops->ecp_write_addr;
 		} else {
@@ -657,7 +657,7 @@ ssize_t parport_write (struct parport *port, const void *buffer, size_t len)
 		break;
 
 	case IEEE1284_MODE_ECPSWE:
-		DPRINTK (KERN_DEBUG "%s: Using software-emulated ECP mode\n",
+		DPRINTK(KERN_DEBUG "%s: Using software-emulated ECP mode\n",
 			 port->name);
 		/* The caller has specified that it must be emulated,
 		 * even if we have ECP hardware! */
@@ -669,13 +669,13 @@ ssize_t parport_write (struct parport *port, const void *buffer, size_t len)
 		break;
 
 	default:
-		DPRINTK (KERN_DEBUG "%s: Unknown mode 0x%02x\n", port->name,
+		DPRINTK(KERN_DEBUG "%s: Unknown mode 0x%02x\n", port->name,
 			port->ieee1284.mode);
 		return -ENOSYS;
 	}
 
 	retval = (*fn) (port, buffer, len, 0);
-	DPRINTK (KERN_DEBUG "%s: wrote %d/%d bytes\n", port->name, retval, len);
+	DPRINTK(KERN_DEBUG "%s: wrote %d/%d bytes\n", port->name, retval, len);
 	return retval;
 #endif /* IEEE1284 support */
 }
@@ -698,10 +698,10 @@ ssize_t parport_write (struct parport *port, const void *buffer, size_t len)
  *	or positive), or else an error code.
  */
 
-ssize_t parport_read (struct parport *port, void *buffer, size_t len)
+ssize_t parport_read(struct parport *port, void *buffer, size_t len)
 {
 #ifndef CONFIG_PARPORT_1284
-	printk (KERN_ERR "parport: IEEE1284 not supported in this kernel\n");
+	printk(KERN_ERR "parport: IEEE1284 not supported in this kernel\n");
 	return -ENODEV;
 #else
 	int mode = port->physport->ieee1284.mode;
@@ -720,28 +720,28 @@ ssize_t parport_read (struct parport *port, void *buffer, size_t len)
 		 * end up needlessly calling negotiate(BYTE) repeately..  (fb)
 		 */
 		if ((port->physport->modes & PARPORT_MODE_TRISTATE) &&
-		    !parport_negotiate (port, IEEE1284_MODE_BYTE)) {
+		    !parport_negotiate(port, IEEE1284_MODE_BYTE)) {
 			/* got into BYTE mode OK */
-			DPRINTK (KERN_DEBUG "%s: Using byte mode\n", port->name);
+			DPRINTK(KERN_DEBUG "%s: Using byte mode\n", port->name);
 			fn = port->ops->byte_read_data;
 			break;
 		}
-		if (parport_negotiate (port, IEEE1284_MODE_NIBBLE)) {
+		if (parport_negotiate(port, IEEE1284_MODE_NIBBLE)) {
 			return -EIO;
 		}
 		/* fall through to NIBBLE */
 	case IEEE1284_MODE_NIBBLE:
-		DPRINTK (KERN_DEBUG "%s: Using nibble mode\n", port->name);
+		DPRINTK(KERN_DEBUG "%s: Using nibble mode\n", port->name);
 		fn = port->ops->nibble_read_data;
 		break;
 
 	case IEEE1284_MODE_BYTE:
-		DPRINTK (KERN_DEBUG "%s: Using byte mode\n", port->name);
+		DPRINTK(KERN_DEBUG "%s: Using byte mode\n", port->name);
 		fn = port->ops->byte_read_data;
 		break;
 
 	case IEEE1284_MODE_EPP:
-		DPRINTK (KERN_DEBUG "%s: Using EPP mode\n", port->name);
+		DPRINTK(KERN_DEBUG "%s: Using EPP mode\n", port->name);
 		if (addr) {
 			fn = port->ops->epp_read_addr;
 		} else {
@@ -749,7 +749,7 @@ ssize_t parport_read (struct parport *port, void *buffer, size_t len)
 		}
 		break;
 	case IEEE1284_MODE_EPPSWE:
-		DPRINTK (KERN_DEBUG "%s: Using software-emulated EPP mode\n",
+		DPRINTK(KERN_DEBUG "%s: Using software-emulated EPP mode\n",
 			port->name);
 		if (addr) {
 			fn = parport_ieee1284_epp_read_addr;
@@ -759,18 +759,18 @@ ssize_t parport_read (struct parport *port, void *buffer, size_t len)
 		break;
 	case IEEE1284_MODE_ECP:
 	case IEEE1284_MODE_ECPRLE:
-		DPRINTK (KERN_DEBUG "%s: Using ECP mode\n", port->name);
+		DPRINTK(KERN_DEBUG "%s: Using ECP mode\n", port->name);
 		fn = port->ops->ecp_read_data;
 		break;
 
 	case IEEE1284_MODE_ECPSWE:
-		DPRINTK (KERN_DEBUG "%s: Using software-emulated ECP mode\n",
+		DPRINTK(KERN_DEBUG "%s: Using software-emulated ECP mode\n",
 			 port->name);
 		fn = parport_ieee1284_ecp_read_data;
 		break;
 
 	default:
-		DPRINTK (KERN_DEBUG "%s: Unknown mode 0x%02x\n", port->name,
+		DPRINTK(KERN_DEBUG "%s: Unknown mode 0x%02x\n", port->name,
 			 port->physport->ieee1284.mode);
 		return -ENOSYS;
 	}
@@ -795,14 +795,14 @@ ssize_t parport_read (struct parport *port, void *buffer, size_t len)
  *	up.
  */
 
-long parport_set_timeout (struct pardevice *dev, long inactivity)
+long parport_set_timeout(struct pardevice *dev, long inactivity)
 {
 	long int old = dev->timeout;
 
 	dev->timeout = inactivity;
 
 	if (dev->port->physport->cad == dev)
-		parport_ieee1284_wakeup (dev->port);
+		parport_ieee1284_wakeup(dev->port);
 
 	return old;
 }
diff --git a/drivers/parport/ieee1284_ops.c b/drivers/parport/ieee1284_ops.c
index bfc9cde9a21d..b431ab6349fe 100644
--- a/drivers/parport/ieee1284_ops.c
+++ b/drivers/parport/ieee1284_ops.c
@@ -27,7 +27,7 @@
 #endif
 
 #ifdef DEBUG
-#define DPRINTK(stuff...) printk (stuff)
+#define DPRINTK(stuff...) printk(stuff)
 #else
 #define DPRINTK(stuff...)
 #endif
@@ -37,7 +37,7 @@
  *                                ***/
 
 /* Compatibility mode. */
-size_t parport_ieee1284_write_compat (struct parport *port,
+size_t parport_ieee1284_write_compat(struct parport *port,
 				      const void *buffer, size_t len,
 				      int flags)
 {
@@ -50,13 +50,13 @@ size_t parport_ieee1284_write_compat (struct parport *port,
 			     | PARPORT_CONTROL_INIT);
 
 	if (port->irq != PARPORT_IRQ_NONE) {
-		parport_enable_irq (port);
+		parport_enable_irq(port);
 		no_irq = 0;
 	}
 
 	port->physport->ieee1284.phase = IEEE1284_PH_FWD_DATA;
-	parport_write_control (port, ctl);
-	parport_data_forward (port);
+	parport_write_control(port, ctl);
+	parport_data_forward(port);
 	while (count < len) {
 		unsigned long expire = jiffies + dev->timeout;
 		long wait = msecs_to_jiffies(10);
@@ -68,12 +68,12 @@ size_t parport_ieee1284_write_compat (struct parport *port,
 		/* Wait until the peripheral's ready */
 		do {
 			/* Is the peripheral ready yet? */
-			if (!parport_wait_peripheral (port, mask, val))
+			if (!parport_wait_peripheral(port, mask, val))
 				/* Skip the loop */
 				goto ready;
 
 			/* Is the peripheral upset? */
-			if ((parport_read_status (port) &
+			if ((parport_read_status(port) &
 			     (PARPORT_STATUS_PAPEROUT |
 			      PARPORT_STATUS_SELECT |
 			      PARPORT_STATUS_ERROR))
@@ -87,7 +87,7 @@ size_t parport_ieee1284_write_compat (struct parport *port,
 				goto stop;
 
 			/* Have we run out of time? */
-			if (!time_before (jiffies, expire))
+			if (!time_before(jiffies, expire))
 				break;
 
 			/* Yield the port for a while.  If this is the
@@ -95,49 +95,49 @@ size_t parport_ieee1284_write_compat (struct parport *port,
                            the port.  This way, we find out if we have
                            our interrupt handler called. */
 			if (count && no_irq) {
-				parport_release (dev);
+				parport_release(dev);
 				schedule_timeout_interruptible(wait);
-				parport_claim_or_block (dev);
+				parport_claim_or_block(dev);
 			}
 			else
 				/* We must have the device claimed here */
-				parport_wait_event (port, wait);
+				parport_wait_event(port, wait);
 
 			/* Is there a signal pending? */
-			if (signal_pending (current))
+			if (signal_pending(current))
 				break;
 
 			/* Wait longer next time. */
 			wait *= 2;
-		} while (time_before (jiffies, expire));
+		} while (time_before(jiffies, expire));
 
-		if (signal_pending (current))
+		if (signal_pending(current))
 			break;
 
-		DPRINTK (KERN_DEBUG "%s: Timed out\n", port->name);
+		DPRINTK(KERN_DEBUG "%s: Timed out\n", port->name);
 		break;
 
 	ready:
 		/* Write the character to the data lines. */
 		byte = *addr++;
-		parport_write_data (port, byte);
-		udelay (1);
+		parport_write_data(port, byte);
+		udelay(1);
 
 		/* Pulse strobe. */
-		parport_write_control (port, ctl | PARPORT_CONTROL_STROBE);
-		udelay (1); /* strobe */
+		parport_write_control(port, ctl | PARPORT_CONTROL_STROBE);
+		udelay(1); /* strobe */
 
-		parport_write_control (port, ctl);
-		udelay (1); /* hold */
+		parport_write_control(port, ctl);
+		udelay(1); /* hold */
 
 		/* Assume the peripheral received it. */
 		count++;
 
                 /* Let another process run if it needs to. */
-		if (time_before (jiffies, expire))
-			if (!parport_yield_blocking (dev)
+		if (time_before(jiffies, expire))
+			if (!parport_yield_blocking(dev)
 			    && need_resched())
-				schedule ();
+				schedule();
 	}
  stop:
 	port->physport->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
@@ -146,7 +146,7 @@ size_t parport_ieee1284_write_compat (struct parport *port,
 }
 
 /* Nibble mode. */
-size_t parport_ieee1284_read_nibble (struct parport *port, 
+size_t parport_ieee1284_read_nibble(struct parport *port,
 				     void *buffer, size_t len,
 				     int flags)
 {
@@ -168,39 +168,39 @@ size_t parport_ieee1284_read_nibble (struct parport *port,
 		}
 
 		/* Event 7: Set nAutoFd low. */
-		parport_frob_control (port,
+		parport_frob_control(port,
 				      PARPORT_CONTROL_AUTOFD,
 				      PARPORT_CONTROL_AUTOFD);
 
 		/* Event 9: nAck goes low. */
 		port->ieee1284.phase = IEEE1284_PH_REV_DATA;
-		if (parport_wait_peripheral (port,
+		if (parport_wait_peripheral(port,
 					     PARPORT_STATUS_ACK, 0)) {
 			/* Timeout -- no more data? */
-			DPRINTK (KERN_DEBUG
+			DPRINTK(KERN_DEBUG
 				 "%s: Nibble timeout at event 9 (%d bytes)\n",
 				 port->name, i/2);
-			parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
+			parport_frob_control(port, PARPORT_CONTROL_AUTOFD, 0);
 			break;
 		}
 
 
 		/* Read a nibble. */
-		nibble = parport_read_status (port) >> 3;
+		nibble = parport_read_status(port) >> 3;
 		nibble &= ~8;
 		if ((nibble & 0x10) == 0)
 			nibble |= 8;
 		nibble &= 0xf;
 
 		/* Event 10: Set nAutoFd high. */
-		parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
+		parport_frob_control(port, PARPORT_CONTROL_AUTOFD, 0);
 
 		/* Event 11: nAck goes high. */
-		if (parport_wait_peripheral (port,
+		if (parport_wait_peripheral(port,
 					     PARPORT_STATUS_ACK,
 					     PARPORT_STATUS_ACK)) {
 			/* Timeout -- no more data? */
-			DPRINTK (KERN_DEBUG
+			DPRINTK(KERN_DEBUG
 				 "%s: Nibble timeout at event 11\n",
 				 port->name);
 			break;
@@ -216,14 +216,14 @@ size_t parport_ieee1284_read_nibble (struct parport *port,
 
 	if (i == len) {
 		/* Read the last nibble without checking data avail. */
-		if (parport_read_status (port) & PARPORT_STATUS_ERROR) {
+		if (parport_read_status(port) & PARPORT_STATUS_ERROR) {
 		end_of_data:
-			DPRINTK (KERN_DEBUG
+			DPRINTK(KERN_DEBUG
 				"%s: No more nibble data (%d bytes)\n",
 				port->name, i/2);
 
 			/* Go to reverse idle phase. */
-			parport_frob_control (port,
+			parport_frob_control(port,
 					      PARPORT_CONTROL_AUTOFD,
 					      PARPORT_CONTROL_AUTOFD);
 			port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE;
@@ -237,7 +237,7 @@ size_t parport_ieee1284_read_nibble (struct parport *port,
 }
 
 /* Byte mode. */
-size_t parport_ieee1284_read_byte (struct parport *port,
+size_t parport_ieee1284_read_byte(struct parport *port,
 				   void *buffer, size_t len,
 				   int flags)
 {
@@ -251,67 +251,67 @@ size_t parport_ieee1284_read_byte (struct parport *port,
 		unsigned char byte;
 
 		/* Data available? */
-		if (parport_read_status (port) & PARPORT_STATUS_ERROR) {
+		if (parport_read_status(port) & PARPORT_STATUS_ERROR) {
 			goto end_of_data;
 		}
 
 		/* Event 14: Place data bus in high impedance state. */
-		parport_data_reverse (port);
+		parport_data_reverse(port);
 
 		/* Event 7: Set nAutoFd low. */
-		parport_frob_control (port,
+		parport_frob_control(port,
 				      PARPORT_CONTROL_AUTOFD,
 				      PARPORT_CONTROL_AUTOFD);
 
 		/* Event 9: nAck goes low. */
 		port->physport->ieee1284.phase = IEEE1284_PH_REV_DATA;
-		if (parport_wait_peripheral (port,
+		if (parport_wait_peripheral(port,
 					     PARPORT_STATUS_ACK,
 					     0)) {
 			/* Timeout -- no more data? */
-			parport_frob_control (port, PARPORT_CONTROL_AUTOFD,
+			parport_frob_control(port, PARPORT_CONTROL_AUTOFD,
 						 0);
-			DPRINTK (KERN_DEBUG "%s: Byte timeout at event 9\n",
+			DPRINTK(KERN_DEBUG "%s: Byte timeout at event 9\n",
 				 port->name);
 			break;
 		}
 
-		byte = parport_read_data (port);
+		byte = parport_read_data(port);
 		*buf++ = byte;
 
 		/* Event 10: Set nAutoFd high */
-		parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
+		parport_frob_control(port, PARPORT_CONTROL_AUTOFD, 0);
 
 		/* Event 11: nAck goes high. */
-		if (parport_wait_peripheral (port,
+		if (parport_wait_peripheral(port,
 					     PARPORT_STATUS_ACK,
 					     PARPORT_STATUS_ACK)) {
 			/* Timeout -- no more data? */
-			DPRINTK (KERN_DEBUG "%s: Byte timeout at event 11\n",
+			DPRINTK(KERN_DEBUG "%s: Byte timeout at event 11\n",
 				 port->name);
 			break;
 		}
 
 		/* Event 16: Set nStrobe low. */
-		parport_frob_control (port,
+		parport_frob_control(port,
 				      PARPORT_CONTROL_STROBE,
 				      PARPORT_CONTROL_STROBE);
-		udelay (5);
+		udelay(5);
 
 		/* Event 17: Set nStrobe high. */
-		parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
+		parport_frob_control(port, PARPORT_CONTROL_STROBE, 0);
 	}
 
 	if (count == len) {
 		/* Read the last byte without checking data avail. */
-		if (parport_read_status (port) & PARPORT_STATUS_ERROR) {
+		if (parport_read_status(port) & PARPORT_STATUS_ERROR) {
 		end_of_data:
-			DPRINTK (KERN_DEBUG
+			DPRINTK(KERN_DEBUG
 				 "%s: No more byte data (%zd bytes)\n",
 				 port->name, count);
 
 			/* Go to reverse idle phase. */
-			parport_frob_control (port,
+			parport_frob_control(port,
 					      PARPORT_CONTROL_AUTOFD,
 					      PARPORT_CONTROL_AUTOFD);
 			port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE;
@@ -331,32 +331,32 @@ size_t parport_ieee1284_read_byte (struct parport *port,
 #ifdef CONFIG_PARPORT_1284
 
 static inline
-int ecp_forward_to_reverse (struct parport *port)
+int ecp_forward_to_reverse(struct parport *port)
 {
 	int retval;
 
 	/* Event 38: Set nAutoFd low */
-	parport_frob_control (port,
+	parport_frob_control(port,
 			      PARPORT_CONTROL_AUTOFD,
 			      PARPORT_CONTROL_AUTOFD);
-	parport_data_reverse (port);
-	udelay (5);
+	parport_data_reverse(port);
+	udelay(5);
 
 	/* Event 39: Set nInit low to initiate bus reversal */
-	parport_frob_control (port,
+	parport_frob_control(port,
 			      PARPORT_CONTROL_INIT,
 			      0);
 
 	/* Event 40: PError goes low */
-	retval = parport_wait_peripheral (port,
+	retval = parport_wait_peripheral(port,
 					  PARPORT_STATUS_PAPEROUT, 0);
 
 	if (!retval) {
-		DPRINTK (KERN_DEBUG "%s: ECP direction: reverse\n",
+		DPRINTK(KERN_DEBUG "%s: ECP direction: reverse\n",
 			 port->name);
 		port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
 	} else {
-		DPRINTK (KERN_DEBUG "%s: ECP direction: failed to reverse\n",
+		DPRINTK(KERN_DEBUG "%s: ECP direction: failed to reverse\n",
 			 port->name);
 		port->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN;
 	}
@@ -365,29 +365,29 @@ int ecp_forward_to_reverse (struct parport *port)
 }
 
 static inline
-int ecp_reverse_to_forward (struct parport *port)
+int ecp_reverse_to_forward(struct parport *port)
 {
 	int retval;
 
 	/* Event 47: Set nInit high */
-	parport_frob_control (port,
+	parport_frob_control(port,
 			      PARPORT_CONTROL_INIT
 			      | PARPORT_CONTROL_AUTOFD,
 			      PARPORT_CONTROL_INIT
 			      | PARPORT_CONTROL_AUTOFD);
 
 	/* Event 49: PError goes high */
-	retval = parport_wait_peripheral (port,
+	retval = parport_wait_peripheral(port,
 					  PARPORT_STATUS_PAPEROUT,
 					  PARPORT_STATUS_PAPEROUT);
 
 	if (!retval) {
-		parport_data_forward (port);
-		DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n",
+		parport_data_forward(port);
+		DPRINTK(KERN_DEBUG "%s: ECP direction: forward\n",
 			 port->name);
 		port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
 	} else {
-		DPRINTK (KERN_DEBUG
+		DPRINTK(KERN_DEBUG
 			 "%s: ECP direction: failed to switch forward\n",
 			 port->name);
 		port->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN;
@@ -400,7 +400,7 @@ int ecp_reverse_to_forward (struct parport *port)
 #endif /* IEEE1284 support */
 
 /* ECP mode, forward channel, data. */
-size_t parport_ieee1284_ecp_write_data (struct parport *port,
+size_t parport_ieee1284_ecp_write_data(struct parport *port,
 					const void *buffer, size_t len,
 					int flags)
 {
@@ -414,13 +414,13 @@ size_t parport_ieee1284_ecp_write_data (struct parport *port,
 	port = port->physport;
 
 	if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE)
-		if (ecp_reverse_to_forward (port))
+		if (ecp_reverse_to_forward(port))
 			return 0;
 
 	port->ieee1284.phase = IEEE1284_PH_FWD_DATA;
 
 	/* HostAck high (data, not command) */
-	parport_frob_control (port,
+	parport_frob_control(port,
 			      PARPORT_CONTROL_AUTOFD
 			      | PARPORT_CONTROL_STROBE
 			      | PARPORT_CONTROL_INIT,
@@ -431,17 +431,17 @@ size_t parport_ieee1284_ecp_write_data (struct parport *port,
 
 		byte = *buf;
 	try_again:
-		parport_write_data (port, byte);
-		parport_frob_control (port, PARPORT_CONTROL_STROBE,
+		parport_write_data(port, byte);
+		parport_frob_control(port, PARPORT_CONTROL_STROBE,
 				      PARPORT_CONTROL_STROBE);
-		udelay (5);
+		udelay(5);
 		for (retry = 0; retry < 100; retry++) {
-			if (!parport_wait_peripheral (port,
+			if (!parport_wait_peripheral(port,
 						      PARPORT_STATUS_BUSY, 0))
 				goto success;
 
-			if (signal_pending (current)) {
-				parport_frob_control (port,
+			if (signal_pending(current)) {
+				parport_frob_control(port,
 						      PARPORT_CONTROL_STROBE,
 						      0);
 				break;
@@ -449,33 +449,33 @@ size_t parport_ieee1284_ecp_write_data (struct parport *port,
 		}
 
 		/* Time for Host Transfer Recovery (page 41 of IEEE1284) */
-		DPRINTK (KERN_DEBUG "%s: ECP transfer stalled!\n", port->name);
+		DPRINTK(KERN_DEBUG "%s: ECP transfer stalled!\n", port->name);
 
-		parport_frob_control (port, PARPORT_CONTROL_INIT,
+		parport_frob_control(port, PARPORT_CONTROL_INIT,
 				      PARPORT_CONTROL_INIT);
-		udelay (50);
-		if (parport_read_status (port) & PARPORT_STATUS_PAPEROUT) {
+		udelay(50);
+		if (parport_read_status(port) & PARPORT_STATUS_PAPEROUT) {
 			/* It's buggered. */
-			parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
+			parport_frob_control(port, PARPORT_CONTROL_INIT, 0);
 			break;
 		}
 
-		parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
-		udelay (50);
-		if (!(parport_read_status (port) & PARPORT_STATUS_PAPEROUT))
+		parport_frob_control(port, PARPORT_CONTROL_INIT, 0);
+		udelay(50);
+		if (!(parport_read_status(port) & PARPORT_STATUS_PAPEROUT))
 			break;
 
-		DPRINTK (KERN_DEBUG "%s: Host transfer recovered\n",
+		DPRINTK(KERN_DEBUG "%s: Host transfer recovered\n",
 			 port->name);
 
-		if (time_after_eq (jiffies, expire))
+		if (time_after_eq(jiffies, expire))
 			break;
 
 		goto try_again;
 	success:
-		parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
-		udelay (5);
-		if (parport_wait_peripheral (port,
+		parport_frob_control(port, PARPORT_CONTROL_STROBE, 0);
+		udelay(5);
+		if (parport_wait_peripheral(port,
 					     PARPORT_STATUS_BUSY,
 					     PARPORT_STATUS_BUSY))
 			/* Peripheral hasn't accepted the data. */
@@ -489,7 +489,7 @@ size_t parport_ieee1284_ecp_write_data (struct parport *port,
 }
 
 /* ECP mode, reverse channel, data. */
-size_t parport_ieee1284_ecp_read_data (struct parport *port,
+size_t parport_ieee1284_ecp_read_data(struct parport *port,
 				       void *buffer, size_t len, int flags)
 {
 #ifndef CONFIG_PARPORT_1284
@@ -505,16 +505,16 @@ size_t parport_ieee1284_ecp_read_data (struct parport *port,
 	port = port->physport;
 
 	if (port->ieee1284.phase != IEEE1284_PH_REV_IDLE)
-		if (ecp_forward_to_reverse (port))
+		if (ecp_forward_to_reverse(port))
 			return 0;
 
 	port->ieee1284.phase = IEEE1284_PH_REV_DATA;
 
 	/* Set HostAck low to start accepting data. */
-	ctl = parport_read_control (port);
+	ctl = parport_read_control(port);
 	ctl &= ~(PARPORT_CONTROL_STROBE | PARPORT_CONTROL_INIT |
 		 PARPORT_CONTROL_AUTOFD);
-	parport_write_control (port,
+	parport_write_control(port,
 			       ctl | PARPORT_CONTROL_AUTOFD);
 	while (count < len) {
 		unsigned long expire = jiffies + dev->timeout;
@@ -523,7 +523,7 @@ size_t parport_ieee1284_ecp_read_data (struct parport *port,
 
 		/* Event 43: Peripheral sets nAck low. It can take as
                    long as it wants. */
-		while (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0)) {
+		while (parport_wait_peripheral(port, PARPORT_STATUS_ACK, 0)) {
 			/* The peripheral hasn't given us data in
 			   35ms.  If we have data to give back to the
 			   caller, do it now. */
@@ -532,21 +532,21 @@ size_t parport_ieee1284_ecp_read_data (struct parport *port,
 
 			/* If we've used up all the time we were allowed,
 			   give up altogether. */
-			if (!time_before (jiffies, expire))
+			if (!time_before(jiffies, expire))
 				goto out;
 
 			/* Yield the port for a while. */
 			if (count && dev->port->irq != PARPORT_IRQ_NONE) {
-				parport_release (dev);
+				parport_release(dev);
 				schedule_timeout_interruptible(msecs_to_jiffies(40));
-				parport_claim_or_block (dev);
+				parport_claim_or_block(dev);
 			}
 			else
 				/* We must have the device claimed here. */
-				parport_wait_event (port, msecs_to_jiffies(40));
+				parport_wait_event(port, msecs_to_jiffies(40));
 
 			/* Is there a signal pending? */
-			if (signal_pending (current))
+			if (signal_pending(current))
 				goto out;
 		}
 
@@ -556,23 +556,23 @@ size_t parport_ieee1284_ecp_read_data (struct parport *port,
                            this can't be as well. */
 			command = 0;
 		else
-			command = (parport_read_status (port) &
+			command = (parport_read_status(port) &
 				   PARPORT_STATUS_BUSY) ? 1 : 0;
 
 		/* Read the data. */
-		byte = parport_read_data (port);
+		byte = parport_read_data(port);
 
 		/* If this is a channel command, rather than an RLE
                    command or a normal data byte, don't accept it. */
 		if (command) {
 			if (byte & 0x80) {
-				DPRINTK (KERN_DEBUG "%s: stopping short at "
+				DPRINTK(KERN_DEBUG "%s: stopping short at "
 					 "channel command (%02x)\n",
 					 port->name, byte);
 				goto out;
 			}
 			else if (port->ieee1284.mode != IEEE1284_MODE_ECPRLE)
-				DPRINTK (KERN_DEBUG "%s: device illegally "
+				DPRINTK(KERN_DEBUG "%s: device illegally "
 					 "using RLE; accepting anyway\n",
 					 port->name);
 
@@ -580,7 +580,7 @@ size_t parport_ieee1284_ecp_read_data (struct parport *port,
 
 			/* Are we allowed to read that many bytes? */
 			if (rle_count > (len - count)) {
-				DPRINTK (KERN_DEBUG "%s: leaving %d RLE bytes "
+				DPRINTK(KERN_DEBUG "%s: leaving %d RLE bytes "
 					 "for next time\n", port->name,
 					 rle_count);
 				break;
@@ -590,17 +590,17 @@ size_t parport_ieee1284_ecp_read_data (struct parport *port,
 		}
 
 		/* Event 44: Set HostAck high, acknowledging handshake. */
-		parport_write_control (port, ctl);
+		parport_write_control(port, ctl);
 
 		/* Event 45: The peripheral has 35ms to set nAck high. */
-		if (parport_wait_peripheral (port, PARPORT_STATUS_ACK,
+		if (parport_wait_peripheral(port, PARPORT_STATUS_ACK,
 					     PARPORT_STATUS_ACK)) {
 			/* It's gone wrong.  Return what data we have
                            to the caller. */
-			DPRINTK (KERN_DEBUG "ECP read timed out at 45\n");
+			DPRINTK(KERN_DEBUG "ECP read timed out at 45\n");
 
 			if (command)
-				printk (KERN_WARNING
+				printk(KERN_WARNING
 					"%s: command ignored (%02x)\n",
 					port->name, byte);
 
@@ -608,7 +608,7 @@ size_t parport_ieee1284_ecp_read_data (struct parport *port,
 		}
 
 		/* Event 46: Set HostAck low and accept the data. */
-		parport_write_control (port,
+		parport_write_control(port,
 				       ctl | PARPORT_CONTROL_AUTOFD);
 
 		/* If we just read a run-length count, fetch the data. */
@@ -618,10 +618,10 @@ size_t parport_ieee1284_ecp_read_data (struct parport *port,
 		/* If this is the byte after a run-length count, decompress. */
 		if (rle) {
 			rle = 0;
-			memset (buf, byte, rle_count);
+			memset(buf, byte, rle_count);
 			buf += rle_count;
 			count += rle_count;
-			DPRINTK (KERN_DEBUG "%s: decompressed to %d bytes\n",
+			DPRINTK(KERN_DEBUG "%s: decompressed to %d bytes\n",
 				 port->name, rle_count);
 		} else {
 			/* Normal data byte. */
@@ -637,7 +637,7 @@ size_t parport_ieee1284_ecp_read_data (struct parport *port,
 }
 
 /* ECP mode, forward channel, commands. */
-size_t parport_ieee1284_ecp_write_addr (struct parport *port,
+size_t parport_ieee1284_ecp_write_addr(struct parport *port,
 					const void *buffer, size_t len,
 					int flags)
 {
@@ -651,13 +651,13 @@ size_t parport_ieee1284_ecp_write_addr (struct parport *port,
 	port = port->physport;
 
 	if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE)
-		if (ecp_reverse_to_forward (port))
+		if (ecp_reverse_to_forward(port))
 			return 0;
 
 	port->ieee1284.phase = IEEE1284_PH_FWD_DATA;
 
 	/* HostAck low (command, not data) */
-	parport_frob_control (port,
+	parport_frob_control(port,
 			      PARPORT_CONTROL_AUTOFD
 			      | PARPORT_CONTROL_STROBE
 			      | PARPORT_CONTROL_INIT,
@@ -669,17 +669,17 @@ size_t parport_ieee1284_ecp_write_addr (struct parport *port,
 
 		byte = *buf;
 	try_again:
-		parport_write_data (port, byte);
-		parport_frob_control (port, PARPORT_CONTROL_STROBE,
+		parport_write_data(port, byte);
+		parport_frob_control(port, PARPORT_CONTROL_STROBE,
 				      PARPORT_CONTROL_STROBE);
-		udelay (5);
+		udelay(5);
 		for (retry = 0; retry < 100; retry++) {
-			if (!parport_wait_peripheral (port,
+			if (!parport_wait_peripheral(port,
 						      PARPORT_STATUS_BUSY, 0))
 				goto success;
 
-			if (signal_pending (current)) {
-				parport_frob_control (port,
+			if (signal_pending(current)) {
+				parport_frob_control(port,
 						      PARPORT_CONTROL_STROBE,
 						      0);
 				break;
@@ -687,33 +687,33 @@ size_t parport_ieee1284_ecp_write_addr (struct parport *port,
 		}
 
 		/* Time for Host Transfer Recovery (page 41 of IEEE1284) */
-		DPRINTK (KERN_DEBUG "%s: ECP transfer stalled!\n", port->name);
+		DPRINTK(KERN_DEBUG "%s: ECP transfer stalled!\n", port->name);
 
-		parport_frob_control (port, PARPORT_CONTROL_INIT,
+		parport_frob_control(port, PARPORT_CONTROL_INIT,
 				      PARPORT_CONTROL_INIT);
-		udelay (50);
-		if (parport_read_status (port) & PARPORT_STATUS_PAPEROUT) {
+		udelay(50);
+		if (parport_read_status(port) & PARPORT_STATUS_PAPEROUT) {
 			/* It's buggered. */
-			parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
+			parport_frob_control(port, PARPORT_CONTROL_INIT, 0);
 			break;
 		}
 
-		parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
-		udelay (50);
-		if (!(parport_read_status (port) & PARPORT_STATUS_PAPEROUT))
+		parport_frob_control(port, PARPORT_CONTROL_INIT, 0);
+		udelay(50);
+		if (!(parport_read_status(port) & PARPORT_STATUS_PAPEROUT))
 			break;
 
-		DPRINTK (KERN_DEBUG "%s: Host transfer recovered\n",
+		DPRINTK(KERN_DEBUG "%s: Host transfer recovered\n",
 			 port->name);
 
-		if (time_after_eq (jiffies, expire))
+		if (time_after_eq(jiffies, expire))
 			break;
 
 		goto try_again;
 	success:
-		parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
-		udelay (5);
-		if (parport_wait_peripheral (port,
+		parport_frob_control(port, PARPORT_CONTROL_STROBE, 0);
+		udelay(5);
+		if (parport_wait_peripheral(port,
 					     PARPORT_STATUS_BUSY,
 					     PARPORT_STATUS_BUSY))
 			/* Peripheral hasn't accepted the data. */
@@ -731,7 +731,7 @@ size_t parport_ieee1284_ecp_write_addr (struct parport *port,
  *              ***/
 
 /* EPP mode, forward channel, data. */
-size_t parport_ieee1284_epp_write_data (struct parport *port,
+size_t parport_ieee1284_epp_write_data(struct parport *port,
 					const void *buffer, size_t len,
 					int flags)
 {
@@ -739,29 +739,29 @@ size_t parport_ieee1284_epp_write_data (struct parport *port,
 	size_t ret = 0;
 
 	/* set EPP idle state (just to make sure) with strobe low */
-	parport_frob_control (port,
+	parport_frob_control(port,
 			      PARPORT_CONTROL_STROBE |
 			      PARPORT_CONTROL_AUTOFD |
 			      PARPORT_CONTROL_SELECT |
 			      PARPORT_CONTROL_INIT,
 			      PARPORT_CONTROL_STROBE |
 			      PARPORT_CONTROL_INIT);
-	port->ops->data_forward (port);
+	port->ops->data_forward(port);
 	for (; len > 0; len--, bp++) {
 		/* Event 62: Write data and set autofd low */
-		parport_write_data (port, *bp);
-		parport_frob_control (port, PARPORT_CONTROL_AUTOFD,
+		parport_write_data(port, *bp);
+		parport_frob_control(port, PARPORT_CONTROL_AUTOFD,
 				      PARPORT_CONTROL_AUTOFD);
 
 		/* Event 58: wait for busy (nWait) to go high */
-		if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 0, 10))
+		if (parport_poll_peripheral(port, PARPORT_STATUS_BUSY, 0, 10))
 			break;
 
 		/* Event 63: set nAutoFd (nDStrb) high */
-		parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
+		parport_frob_control(port, PARPORT_CONTROL_AUTOFD, 0);
 
 		/* Event 60: wait for busy (nWait) to go low */
-		if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
+		if (parport_poll_peripheral(port, PARPORT_STATUS_BUSY,
 					     PARPORT_STATUS_BUSY, 5))
 			break;
 
@@ -769,13 +769,13 @@ size_t parport_ieee1284_epp_write_data (struct parport *port,
 	}
 
 	/* Event 61: set strobe (nWrite) high */
-	parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
+	parport_frob_control(port, PARPORT_CONTROL_STROBE, 0);
 
 	return ret;
 }
 
 /* EPP mode, reverse channel, data. */
-size_t parport_ieee1284_epp_read_data (struct parport *port,
+size_t parport_ieee1284_epp_read_data(struct parport *port,
 				       void *buffer, size_t len,
 				       int flags)
 {
@@ -783,43 +783,43 @@ size_t parport_ieee1284_epp_read_data (struct parport *port,
 	unsigned ret = 0;
 
 	/* set EPP idle state (just to make sure) with strobe high */
-	parport_frob_control (port,
+	parport_frob_control(port,
 			      PARPORT_CONTROL_STROBE |
 			      PARPORT_CONTROL_AUTOFD |
 			      PARPORT_CONTROL_SELECT |
 			      PARPORT_CONTROL_INIT,
 			      PARPORT_CONTROL_INIT);
-	port->ops->data_reverse (port);
+	port->ops->data_reverse(port);
 	for (; len > 0; len--, bp++) {
 		/* Event 67: set nAutoFd (nDStrb) low */
-		parport_frob_control (port,
+		parport_frob_control(port,
 				      PARPORT_CONTROL_AUTOFD,
 				      PARPORT_CONTROL_AUTOFD);
 		/* Event 58: wait for Busy to go high */
-		if (parport_wait_peripheral (port, PARPORT_STATUS_BUSY, 0)) {
+		if (parport_wait_peripheral(port, PARPORT_STATUS_BUSY, 0)) {
 			break;
 		}
 
-		*bp = parport_read_data (port);
+		*bp = parport_read_data(port);
 
 		/* Event 63: set nAutoFd (nDStrb) high */
-		parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
+		parport_frob_control(port, PARPORT_CONTROL_AUTOFD, 0);
 
 		/* Event 60: wait for Busy to go low */
-		if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
+		if (parport_poll_peripheral(port, PARPORT_STATUS_BUSY,
 					     PARPORT_STATUS_BUSY, 5)) {
 			break;
 		}
 
 		ret++;
 	}
-	port->ops->data_forward (port);
+	port->ops->data_forward(port);
 
 	return ret;
 }
 
 /* EPP mode, forward channel, addresses. */
-size_t parport_ieee1284_epp_write_addr (struct parport *port,
+size_t parport_ieee1284_epp_write_addr(struct parport *port,
 					const void *buffer, size_t len,
 					int flags)
 {
@@ -827,29 +827,29 @@ size_t parport_ieee1284_epp_write_addr (struct parport *port,
 	size_t ret = 0;
 
 	/* set EPP idle state (just to make sure) with strobe low */
-	parport_frob_control (port,
+	parport_frob_control(port,
 			      PARPORT_CONTROL_STROBE |
 			      PARPORT_CONTROL_AUTOFD |
 			      PARPORT_CONTROL_SELECT |
 			      PARPORT_CONTROL_INIT,
 			      PARPORT_CONTROL_STROBE |
 			      PARPORT_CONTROL_INIT);
-	port->ops->data_forward (port);
+	port->ops->data_forward(port);
 	for (; len > 0; len--, bp++) {
 		/* Event 56: Write data and set nAStrb low. */
-		parport_write_data (port, *bp);
-		parport_frob_control (port, PARPORT_CONTROL_SELECT,
+		parport_write_data(port, *bp);
+		parport_frob_control(port, PARPORT_CONTROL_SELECT,
 				      PARPORT_CONTROL_SELECT);
 
 		/* Event 58: wait for busy (nWait) to go high */
-		if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 0, 10))
+		if (parport_poll_peripheral(port, PARPORT_STATUS_BUSY, 0, 10))
 			break;
 
 		/* Event 59: set nAStrb high */
-		parport_frob_control (port, PARPORT_CONTROL_SELECT, 0);
+		parport_frob_control(port, PARPORT_CONTROL_SELECT, 0);
 
 		/* Event 60: wait for busy (nWait) to go low */
-		if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
+		if (parport_poll_peripheral(port, PARPORT_STATUS_BUSY,
 					     PARPORT_STATUS_BUSY, 5))
 			break;
 
@@ -857,13 +857,13 @@ size_t parport_ieee1284_epp_write_addr (struct parport *port,
 	}
 
 	/* Event 61: set strobe (nWrite) high */
-	parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
+	parport_frob_control(port, PARPORT_CONTROL_STROBE, 0);
 
 	return ret;
 }
 
 /* EPP mode, reverse channel, addresses. */
-size_t parport_ieee1284_epp_read_addr (struct parport *port,
+size_t parport_ieee1284_epp_read_addr(struct parport *port,
 				       void *buffer, size_t len,
 				       int flags)
 {
@@ -871,37 +871,37 @@ size_t parport_ieee1284_epp_read_addr (struct parport *port,
 	unsigned ret = 0;
 
 	/* Set EPP idle state (just to make sure) with strobe high */
-	parport_frob_control (port,
+	parport_frob_control(port,
 			      PARPORT_CONTROL_STROBE |
 			      PARPORT_CONTROL_AUTOFD |
 			      PARPORT_CONTROL_SELECT |
 			      PARPORT_CONTROL_INIT,
 			      PARPORT_CONTROL_INIT);
-	port->ops->data_reverse (port);
+	port->ops->data_reverse(port);
 	for (; len > 0; len--, bp++) {
 		/* Event 64: set nSelectIn (nAStrb) low */
-		parport_frob_control (port, PARPORT_CONTROL_SELECT,
+		parport_frob_control(port, PARPORT_CONTROL_SELECT,
 				      PARPORT_CONTROL_SELECT);
 
 		/* Event 58: wait for Busy to go high */
-		if (parport_wait_peripheral (port, PARPORT_STATUS_BUSY, 0)) {
+		if (parport_wait_peripheral(port, PARPORT_STATUS_BUSY, 0)) {
 			break;
 		}
 
-		*bp = parport_read_data (port);
+		*bp = parport_read_data(port);
 
 		/* Event 59: set nSelectIn (nAStrb) high */
-		parport_frob_control (port, PARPORT_CONTROL_SELECT,
+		parport_frob_control(port, PARPORT_CONTROL_SELECT,
 				      0);
 
 		/* Event 60: wait for Busy to go low */
-		if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 
+		if (parport_poll_peripheral(port, PARPORT_STATUS_BUSY,
 					     PARPORT_STATUS_BUSY, 5))
 			break;
 
 		ret++;
 	}
-	port->ops->data_forward (port);
+	port->ops->data_forward(port);
 
 	return ret;
 }
diff --git a/drivers/parport/parport_atari.c b/drivers/parport/parport_atari.c
index a81cd2a2747f..b8da1b5f550c 100644
--- a/drivers/parport/parport_atari.c
+++ b/drivers/parport/parport_atari.c
@@ -194,13 +194,13 @@ static int __init parport_atari_init(void)
 			return -ENODEV;
 		if (request_irq(IRQ_MFP_BUSY, parport_irq_handler, 0, p->name,
 				p)) {
-			parport_put_port (p);
+			parport_put_port(p);
 			return -ENODEV;
 		}
 
 		this_port = p;
 		printk(KERN_INFO "%s: Atari built-in port using irq\n", p->name);
-		parport_announce_port (p);
+		parport_announce_port(p);
 
 		return 0;
 	}
diff --git a/drivers/parport/parport_gsc.c b/drivers/parport/parport_gsc.c
index fc1c4192121b..626df53d6d9d 100644
--- a/drivers/parport/parport_gsc.c
+++ b/drivers/parport/parport_gsc.c
@@ -65,8 +65,8 @@ static int clear_epp_timeout(struct parport *pb)
 	/* To clear timeout some chips require double read */
 	parport_gsc_read_status(pb);
 	r = parport_gsc_read_status(pb);
-	parport_writeb (r | 0x01, STATUS (pb)); /* Some reset by writing 1 */
-	parport_writeb (r & 0xfe, STATUS (pb)); /* Others by writing 0 */
+	parport_writeb(r | 0x01, STATUS(pb)); /* Some reset by writing 1 */
+	parport_writeb(r & 0xfe, STATUS(pb)); /* Others by writing 0 */
 	r = parport_gsc_read_status(pb);
 
 	return !(r & 0x01);
@@ -87,12 +87,12 @@ void parport_gsc_init_state(struct pardevice *dev, struct parport_state *s)
 
 void parport_gsc_save_state(struct parport *p, struct parport_state *s)
 {
-	s->u.pc.ctr = parport_readb (CONTROL (p));
+	s->u.pc.ctr = parport_readb(CONTROL(p));
 }
 
 void parport_gsc_restore_state(struct parport *p, struct parport_state *s)
 {
-	parport_writeb (s->u.pc.ctr, CONTROL (p));
+	parport_writeb(s->u.pc.ctr, CONTROL(p));
 }
 
 struct parport_operations parport_gsc_ops = 
@@ -151,19 +151,19 @@ static int parport_SPP_supported(struct parport *pb)
 
 	/* Do a simple read-write test to make sure the port exists. */
 	w = 0xc;
-	parport_writeb (w, CONTROL (pb));
+	parport_writeb(w, CONTROL(pb));
 
 	/* Is there a control register that we can read from?  Some
 	 * ports don't allow reads, so read_control just returns a
 	 * software copy. Some ports _do_ allow reads, so bypass the
 	 * software copy here.  In addition, some bits aren't
 	 * writable. */
-	r = parport_readb (CONTROL (pb));
+	r = parport_readb(CONTROL(pb));
 	if ((r & 0xf) == w) {
 		w = 0xe;
-		parport_writeb (w, CONTROL (pb));
-		r = parport_readb (CONTROL (pb));
-		parport_writeb (0xc, CONTROL (pb));
+		parport_writeb(w, CONTROL(pb));
+		r = parport_readb(CONTROL(pb));
+		parport_writeb(0xc, CONTROL(pb));
 		if ((r & 0xf) == w)
 			return PARPORT_MODE_PCSPP;
 	}
@@ -171,12 +171,12 @@ static int parport_SPP_supported(struct parport *pb)
 	/* Try the data register.  The data lines aren't tri-stated at
 	 * this stage, so we expect back what we wrote. */
 	w = 0xaa;
-	parport_gsc_write_data (pb, w);
-	r = parport_gsc_read_data (pb);
+	parport_gsc_write_data(pb, w);
+	r = parport_gsc_read_data(pb);
 	if (r == w) {
 		w = 0x55;
-		parport_gsc_write_data (pb, w);
-		r = parport_gsc_read_data (pb);
+		parport_gsc_write_data(pb, w);
+		r = parport_gsc_read_data(pb);
 		if (r == w)
 			return PARPORT_MODE_PCSPP;
 	}
@@ -208,7 +208,7 @@ static int parport_PS2_supported(struct parport *pb)
 	clear_epp_timeout(pb);
 
 	/* try to tri-state the buffer */
-	parport_gsc_data_reverse (pb);
+	parport_gsc_data_reverse(pb);
 	
 	parport_gsc_write_data(pb, 0x55);
 	if (parport_gsc_read_data(pb) != 0x55)
@@ -219,7 +219,7 @@ static int parport_PS2_supported(struct parport *pb)
 		ok++;
 
 	/* cancel input mode */
-	parport_gsc_data_forward (pb);
+	parport_gsc_data_forward(pb);
 
 	if (ok) {
 		pb->modes |= PARPORT_MODE_TRISTATE;
@@ -243,17 +243,17 @@ struct parport *parport_gsc_probe_port(unsigned long base,
 	struct parport tmp;
 	struct parport *p = &tmp;
 
-	priv = kzalloc (sizeof (struct parport_gsc_private), GFP_KERNEL);
+	priv = kzalloc(sizeof(struct parport_gsc_private), GFP_KERNEL);
 	if (!priv) {
-		printk (KERN_DEBUG "parport (0x%lx): no memory!\n", base);
+		printk(KERN_DEBUG "parport (0x%lx): no memory!\n", base);
 		return NULL;
 	}
 	ops = kmemdup(&parport_gsc_ops, sizeof(struct parport_operations),
 		      GFP_KERNEL);
 	if (!ops) {
-		printk (KERN_DEBUG "parport (0x%lx): no memory for ops!\n",
+		printk(KERN_DEBUG "parport (0x%lx): no memory for ops!\n",
 			base);
-		kfree (priv);
+		kfree(priv);
 		return NULL;
 	}
 	priv->ctr = 0xc;
@@ -268,18 +268,18 @@ struct parport *parport_gsc_probe_port(unsigned long base,
 	p->ops = ops;
 	p->private_data = priv;
 	p->physport = p;
-	if (!parport_SPP_supported (p)) {
+	if (!parport_SPP_supported(p)) {
 		/* No port. */
-		kfree (priv);
+		kfree(priv);
 		kfree(ops);
 		return NULL;
 	}
-	parport_PS2_supported (p);
+	parport_PS2_supported(p);
 
 	if (!(p = parport_register_port(base, PARPORT_IRQ_NONE,
 					PARPORT_DMA_NONE, ops))) {
-		kfree (priv);
-		kfree (ops);
+		kfree(priv);
+		kfree(ops);
 		return NULL;
 	}
 
@@ -320,9 +320,9 @@ struct parport *parport_gsc_probe_port(unsigned long base,
 	pr_cont("]\n");
 
 	if (p->irq != PARPORT_IRQ_NONE) {
-		if (request_irq (p->irq, parport_irq_handler,
+		if (request_irq(p->irq, parport_irq_handler,
 				 0, p->name, p)) {
-			printk (KERN_WARNING "%s: irq %d in use, "
+			printk(KERN_WARNING "%s: irq %d in use, "
 				"resorting to polled operation\n",
 				p->name, p->irq);
 			p->irq = PARPORT_IRQ_NONE;
@@ -333,12 +333,12 @@ struct parport *parport_gsc_probe_port(unsigned long base,
 	/* Done probing.  Now put the port into a sensible start-up state. */
 
 	parport_gsc_write_data(p, 0);
-	parport_gsc_data_forward (p);
+	parport_gsc_data_forward(p);
 
 	/* Now that we've told the sharing engine about the port, and
 	   found out its characteristics, let the high-level drivers
 	   know about it. */
-	parport_announce_port (p);
+	parport_announce_port(p);
 
 	return p;
 }
@@ -368,7 +368,7 @@ static int parport_init_chip(struct parisc_device *dev)
 
 		/* Initialize bidirectional-mode (0x10) & data-tranfer-mode #1 (0x20) */
 		printk("%s: initialize bidirectional-mode.\n", __func__);
-		parport_writeb ( (0x10 + 0x20), port + 4);
+		parport_writeb((0x10 + 0x20), port + 4);
 
 	} else {
 		printk("%s: enhanced parport-modes not supported.\n", __func__);
@@ -398,9 +398,9 @@ static int parport_remove_chip(struct parisc_device *dev)
 			pci_free_consistent(priv->dev, PAGE_SIZE,
 					    priv->dma_buf,
 					    priv->dma_handle);
-		kfree (p->private_data);
+		kfree(p->private_data);
 		parport_put_port(p);
-		kfree (ops); /* hope no-one cached it */
+		kfree(ops); /* hope no-one cached it */
 	}
 	return 0;
 }
diff --git a/drivers/parport/parport_mfc3.c b/drivers/parport/parport_mfc3.c
index 2f650f68af14..d650b00ce38a 100644
--- a/drivers/parport/parport_mfc3.c
+++ b/drivers/parport/parport_mfc3.c
@@ -328,7 +328,7 @@ static int __init parport_mfc3_init(void)
 		/* XXX: set operating mode */
 
 		p->private_data = (void *)piabase;
-		parport_announce_port (p);
+		parport_announce_port(p);
 
 		if (pias >= MAX_MFC)
 			break;
diff --git a/drivers/parport/parport_serial.c b/drivers/parport/parport_serial.c
index e15b4845f7c6..1d955f5e8da3 100644
--- a/drivers/parport/parport_serial.c
+++ b/drivers/parport/parport_serial.c
@@ -522,7 +522,7 @@ struct parport_serial_private {
 /* Register the serial port(s) of a PCI card. */
 static int serial_register(struct pci_dev *dev, const struct pci_device_id *id)
 {
-	struct parport_serial_private *priv = pci_get_drvdata (dev);
+	struct parport_serial_private *priv = pci_get_drvdata(dev);
 	struct pciserial_board *board;
 	struct serial_private *serial;
 
@@ -544,13 +544,13 @@ static int serial_register(struct pci_dev *dev, const struct pci_device_id *id)
 static int parport_register(struct pci_dev *dev, const struct pci_device_id *id)
 {
 	struct parport_pc_pci *card;
-	struct parport_serial_private *priv = pci_get_drvdata (dev);
+	struct parport_serial_private *priv = pci_get_drvdata(dev);
 	int n, success = 0;
 
 	priv->par = cards[id->driver_data];
 	card = &priv->par;
 	if (card->preinit_hook &&
-	    card->preinit_hook (dev, card, PARPORT_IRQ_NONE, PARPORT_DMA_NONE))
+	    card->preinit_hook(dev, card, PARPORT_IRQ_NONE, PARPORT_DMA_NONE))
 		return -ENODEV;
 
 	for (n = 0; n < card->numports; n++) {
@@ -560,18 +560,18 @@ static int parport_register(struct pci_dev *dev, const struct pci_device_id *id)
 		unsigned long io_lo, io_hi;
 		int irq;
 
-		if (priv->num_par == ARRAY_SIZE (priv->port)) {
-			printk (KERN_WARNING
+		if (priv->num_par == ARRAY_SIZE(priv->port)) {
+			printk(KERN_WARNING
 				"parport_serial: %s: only %zu parallel ports "
-				"supported (%d reported)\n", pci_name (dev),
+				"supported (%d reported)\n", pci_name(dev),
 				ARRAY_SIZE(priv->port), card->numports);
 			break;
 		}
 
-		io_lo = pci_resource_start (dev, lo);
+		io_lo = pci_resource_start(dev, lo);
 		io_hi = 0;
 		if ((hi >= 0) && (hi <= 6))
-			io_hi = pci_resource_start (dev, hi);
+			io_hi = pci_resource_start(dev, hi);
 		else if (hi > 6)
 			io_lo += hi; /* Reinterpret the meaning of
                                         "hi" as an offset (see SYBA
@@ -588,7 +588,7 @@ static int parport_register(struct pci_dev *dev, const struct pci_device_id *id)
 		"PCI parallel port detected: I/O at %#lx(%#lx), IRQ %d\n",
 				io_lo, io_hi, irq);
 		}
-		port = parport_pc_probe_port (io_lo, io_hi, irq,
+		port = parport_pc_probe_port(io_lo, io_hi, irq,
 			      PARPORT_DMA_NONE, &dev->dev, IRQF_SHARED);
 		if (port) {
 			priv->port[priv->num_par++] = port;
@@ -597,7 +597,7 @@ static int parport_register(struct pci_dev *dev, const struct pci_device_id *id)
 	}
 
 	if (card->postinit_hook)
-		card->postinit_hook (dev, card, !success);
+		card->postinit_hook(dev, card, !success);
 
 	return 0;
 }
@@ -608,27 +608,27 @@ static int parport_serial_pci_probe(struct pci_dev *dev,
 	struct parport_serial_private *priv;
 	int err;
 
-	priv = kzalloc (sizeof *priv, GFP_KERNEL);
+	priv = kzalloc(sizeof *priv, GFP_KERNEL);
 	if (!priv)
 		return -ENOMEM;
-	pci_set_drvdata (dev, priv);
+	pci_set_drvdata(dev, priv);
 
-	err = pci_enable_device (dev);
+	err = pci_enable_device(dev);
 	if (err) {
-		kfree (priv);
+		kfree(priv);
 		return err;
 	}
 
-	if (parport_register (dev, id)) {
-		kfree (priv);
+	if (parport_register(dev, id)) {
+		kfree(priv);
 		return -ENODEV;
 	}
 
-	if (serial_register (dev, id)) {
+	if (serial_register(dev, id)) {
 		int i;
 		for (i = 0; i < priv->num_par; i++)
-			parport_pc_unregister_port (priv->port[i]);
-		kfree (priv);
+			parport_pc_unregister_port(priv->port[i]);
+		kfree(priv);
 		return -ENODEV;
 	}
 
@@ -637,7 +637,7 @@ static int parport_serial_pci_probe(struct pci_dev *dev,
 
 static void parport_serial_pci_remove(struct pci_dev *dev)
 {
-	struct parport_serial_private *priv = pci_get_drvdata (dev);
+	struct parport_serial_private *priv = pci_get_drvdata(dev);
 	int i;
 
 	// Serial ports
@@ -646,9 +646,9 @@ static void parport_serial_pci_remove(struct pci_dev *dev)
 
 	// Parallel ports
 	for (i = 0; i < priv->num_par; i++)
-		parport_pc_unregister_port (priv->port[i]);
+		parport_pc_unregister_port(priv->port[i]);
 
-	kfree (priv);
+	kfree(priv);
 	return;
 }
 
@@ -706,14 +706,14 @@ static struct pci_driver parport_serial_pci_driver = {
 };
 
 
-static int __init parport_serial_init (void)
+static int __init parport_serial_init(void)
 {
-	return pci_register_driver (&parport_serial_pci_driver);
+	return pci_register_driver(&parport_serial_pci_driver);
 }
 
-static void __exit parport_serial_exit (void)
+static void __exit parport_serial_exit(void)
 {
-	pci_unregister_driver (&parport_serial_pci_driver);
+	pci_unregister_driver(&parport_serial_pci_driver);
 	return;
 }
 
diff --git a/drivers/parport/parport_sunbpp.c b/drivers/parport/parport_sunbpp.c
index 01cf1c1a841a..c87bf4ac2006 100644
--- a/drivers/parport/parport_sunbpp.c
+++ b/drivers/parport/parport_sunbpp.c
@@ -184,7 +184,7 @@ static void parport_sunbpp_write_control(struct parport *p, unsigned char d)
 				  PARPORT_CONTROL_INIT |
 				  PARPORT_CONTROL_SELECT);
 
-	parport_sunbpp_frob_control (p, wm, d & wm);
+	parport_sunbpp_frob_control(p, wm, d & wm);
 }
 
 static unsigned char parport_sunbpp_read_status(struct parport *p)
@@ -192,7 +192,7 @@ static unsigned char parport_sunbpp_read_status(struct parport *p)
 	return status_sunbpp_to_pc(p);
 }
 
-static void parport_sunbpp_data_forward (struct parport *p)
+static void parport_sunbpp_data_forward(struct parport *p)
 {
 	struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
 	unsigned char value_tcr = sbus_readb(&regs->p_tcr);
@@ -202,7 +202,7 @@ static void parport_sunbpp_data_forward (struct parport *p)
 	sbus_writeb(value_tcr, &regs->p_tcr);
 }
 
-static void parport_sunbpp_data_reverse (struct parport *p)
+static void parport_sunbpp_data_reverse(struct parport *p)
 {
 	struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
 	u8 val = sbus_readb(&regs->p_tcr);
diff --git a/drivers/parport/probe.c b/drivers/parport/probe.c
index f2618cc1c793..8a6b8a36fe36 100644
--- a/drivers/parport/probe.c
+++ b/drivers/parport/probe.c
@@ -40,9 +40,9 @@ static void pretty_print(struct parport *port, int device)
 	printk(KERN_INFO "%s", port->name);
 
 	if (device >= 0)
-		printk (" (addr %d)", device);
+		printk(" (addr %d)", device);
 
-	printk (": %s", classes[info->class].descr);
+	printk(": %s", classes[info->class].descr);
 	if (info->class)
 		printk(", %s %s", info->mfr, info->model);
 
@@ -72,7 +72,7 @@ static void parse_data(struct parport *port, int device, char *str)
 			char *u;
 			*(sep++) = 0;
 			/* Get rid of trailing blanks */
-			u = sep + strlen (sep) - 1;
+			u = sep + strlen(sep) - 1;
 			while (u >= p && *u == ' ')
 				*u-- = '\0';
 			u = p;
@@ -134,7 +134,7 @@ static void parse_data(struct parport *port, int device, char *str)
 /* Read up to count-1 bytes of device id. Terminate buffer with
  * '\0'. Buffer begins with two Device ID length bytes as given by
  * device. */
-static ssize_t parport_read_device_id (struct parport *port, char *buffer,
+static ssize_t parport_read_device_id(struct parport *port, char *buffer,
 				       size_t count)
 {
 	unsigned char length[2];
@@ -146,7 +146,7 @@ static ssize_t parport_read_device_id (struct parport *port, char *buffer,
 	size_t len;
 
 	/* First two bytes are MSB,LSB of inclusive length. */
-	retval = parport_read (port, length, 2);
+	retval = parport_read(port, length, 2);
 
 	if (retval < 0)
 		return retval;
@@ -178,7 +178,7 @@ static ssize_t parport_read_device_id (struct parport *port, char *buffer,
 		 * just return constant nibble forever. This catches
 		 * also those cases. */
 		if (idlens[0] == 0 || idlens[0] > 0xFFF) {
-			printk (KERN_DEBUG "%s: reported broken Device ID"
+			printk(KERN_DEBUG "%s: reported broken Device ID"
 				" length of %#zX bytes\n",
 				port->name, idlens[0]);
 			return -EIO;
@@ -194,7 +194,7 @@ static ssize_t parport_read_device_id (struct parport *port, char *buffer,
 		if (idlen+1 >= count)
 			break;
 
-		retval = parport_read (port, buffer+len, idlen-len);
+		retval = parport_read(port, buffer+len, idlen-len);
 
 		if (retval < 0)
 			return retval;
@@ -202,7 +202,7 @@ static ssize_t parport_read_device_id (struct parport *port, char *buffer,
 
 		if (port->physport->ieee1284.phase != IEEE1284_PH_HBUSY_DAVAIL) {
 			if (belen != len) {
-				printk (KERN_DEBUG "%s: Device ID was %zd bytes"
+				printk(KERN_DEBUG "%s: Device ID was %zd bytes"
 					" while device told it would be %d"
 					" bytes\n",
 					port->name, len, belen);
@@ -215,7 +215,7 @@ static ssize_t parport_read_device_id (struct parport *port, char *buffer,
 		 * the first 256 bytes or so that we must have read so
 		 * far. */
 		if (buffer[len-1] == ';') {
- 			printk (KERN_DEBUG "%s: Device ID reading stopped"
+			printk(KERN_DEBUG "%s: Device ID reading stopped"
 				" before device told data not available. "
 				"Current idlen %u of %u, len bytes %02X %02X\n",
 				port->name, current_idlen, numidlens,
@@ -227,7 +227,7 @@ static ssize_t parport_read_device_id (struct parport *port, char *buffer,
 		/* Buffer not large enough, read to end of buffer. */
 		size_t idlen, len2;
 		if (len+1 < count) {
-			retval = parport_read (port, buffer+len, count-len-1);
+			retval = parport_read(port, buffer+len, count-len-1);
 			if (retval < 0)
 				return retval;
 			len += retval;
@@ -239,7 +239,7 @@ static ssize_t parport_read_device_id (struct parport *port, char *buffer,
 		len2 = len;
 		while(len2 < idlen && retval > 0) {
 			char tmp[4];
-			retval = parport_read (port, tmp,
+			retval = parport_read(port, tmp,
 					       min(sizeof tmp, idlen-len2));
 			if (retval < 0)
 				return retval;
@@ -255,30 +255,30 @@ static ssize_t parport_read_device_id (struct parport *port, char *buffer,
 }
 
 /* Get Std 1284 Device ID. */
-ssize_t parport_device_id (int devnum, char *buffer, size_t count)
+ssize_t parport_device_id(int devnum, char *buffer, size_t count)
 {
 	ssize_t retval = -ENXIO;
-	struct pardevice *dev = parport_open (devnum, "Device ID probe");
+	struct pardevice *dev = parport_open(devnum, "Device ID probe");
 	if (!dev)
 		return -ENXIO;
 
-	parport_claim_or_block (dev);
+	parport_claim_or_block(dev);
 
 	/* Negotiate to compatibility mode, and then to device ID
 	 * mode. (This so that we start form beginning of device ID if
 	 * already in device ID mode.) */
-	parport_negotiate (dev->port, IEEE1284_MODE_COMPAT);
-	retval = parport_negotiate (dev->port,
+	parport_negotiate(dev->port, IEEE1284_MODE_COMPAT);
+	retval = parport_negotiate(dev->port,
 				    IEEE1284_MODE_NIBBLE | IEEE1284_DEVICEID);
 
 	if (!retval) {
-		retval = parport_read_device_id (dev->port, buffer, count);
-		parport_negotiate (dev->port, IEEE1284_MODE_COMPAT);
+		retval = parport_read_device_id(dev->port, buffer, count);
+		parport_negotiate(dev->port, IEEE1284_MODE_COMPAT);
 		if (retval > 2)
-			parse_data (dev->port, dev->daisy, buffer+2);
+			parse_data(dev->port, dev->daisy, buffer+2);
 	}
 
-	parport_release (dev);
-	parport_close (dev);
+	parport_release(dev);
+	parport_close(dev);
 	return retval;
 }
diff --git a/drivers/parport/procfs.c b/drivers/parport/procfs.c
index 8ee44a104ac4..6ee97b5849c5 100644
--- a/drivers/parport/procfs.c
+++ b/drivers/parport/procfs.c
@@ -86,19 +86,19 @@ static int do_autoprobe(struct ctl_table *table, int write,
 	}
 	
 	if ((str = info->class_name) != NULL)
-		len += sprintf (buffer + len, "CLASS:%s;\n", str);
+		len += sprintf(buffer + len, "CLASS:%s;\n", str);
 
 	if ((str = info->model) != NULL)
-		len += sprintf (buffer + len, "MODEL:%s;\n", str);
+		len += sprintf(buffer + len, "MODEL:%s;\n", str);
 
 	if ((str = info->mfr) != NULL)
-		len += sprintf (buffer + len, "MANUFACTURER:%s;\n", str);
+		len += sprintf(buffer + len, "MANUFACTURER:%s;\n", str);
 
 	if ((str = info->description) != NULL)
-		len += sprintf (buffer + len, "DESCRIPTION:%s;\n", str);
+		len += sprintf(buffer + len, "DESCRIPTION:%s;\n", str);
 
 	if ((str = info->cmdset) != NULL)
-		len += sprintf (buffer + len, "COMMAND SET:%s;\n", str);
+		len += sprintf(buffer + len, "COMMAND SET:%s;\n", str);
 
 	if (len > *lenp)
 		len = *lenp;
@@ -107,7 +107,7 @@ static int do_autoprobe(struct ctl_table *table, int write,
 
 	*ppos += len;
 
-	return copy_to_user (result, buffer, len) ? -EFAULT : 0;
+	return copy_to_user(result, buffer, len) ? -EFAULT : 0;
 }
 #endif /* IEEE1284.3 support. */
 
@@ -127,7 +127,7 @@ static int do_hardware_base_addr(struct ctl_table *table, int write,
 	if (write) /* permissions prevent this anyway */
 		return -EACCES;
 
-	len += sprintf (buffer, "%lu\t%lu\n", port->base, port->base_hi);
+	len += sprintf(buffer, "%lu\t%lu\n", port->base, port->base_hi);
 
 	if (len > *lenp)
 		len = *lenp;
@@ -155,7 +155,7 @@ static int do_hardware_irq(struct ctl_table *table, int write,
 	if (write) /* permissions prevent this anyway */
 		return -EACCES;
 
-	len += sprintf (buffer, "%d\n", port->irq);
+	len += sprintf(buffer, "%d\n", port->irq);
 
 	if (len > *lenp)
 		len = *lenp;
@@ -183,7 +183,7 @@ static int do_hardware_dma(struct ctl_table *table, int write,
 	if (write) /* permissions prevent this anyway */
 		return -EACCES;
 
-	len += sprintf (buffer, "%d\n", port->dma);
+	len += sprintf(buffer, "%d\n", port->dma);
 
 	if (len > *lenp)
 		len = *lenp;
@@ -606,12 +606,12 @@ int parport_device_proc_unregister(struct pardevice *device)
 	return 0;
 }
 
-static int __init parport_default_proc_register (void)
+static int __init parport_default_proc_register(void)
 {
 	return parport_bus_init();
 }
 
-static void __exit parport_default_proc_unregister (void)
+static void __exit parport_default_proc_unregister(void)
 {
 	parport_bus_exit();
 }
-- 
2.11.0



From CARLOS.PALMINHA at synopsys.com  Mon Jul 17 09:40:18 2017
From: CARLOS.PALMINHA at synopsys.com (Carlos Palminha)
Date: Mon, 17 Jul 2017 17:40:18 +0100
Subject: [Linux-parport] [PATCH 5/5] parport: remove unnecessary braces
In-Reply-To: <20170717163702.17427-1-palminha@synopsys.com>
References: <20170717163702.17427-1-palminha@synopsys.com>
Message-ID: <20170717164018.17494-1-palminha@synopsys.com>

based on checkpatch, remove braces not necessary for statements.

Signed-off-by: Carlos Palminha <palminha at synopsys.com>
---
 drivers/parport/ieee1284.c       | 40 ++++++++++++++++++++--------------------
 drivers/parport/ieee1284_ops.c   |  9 +++------
 drivers/parport/parport_gsc.c    |  7 +++----
 drivers/parport/parport_pc.c     |  3 +--
 drivers/parport/parport_sunbpp.c | 20 ++++++++------------
 drivers/parport/procfs.c         |  6 ++----
 6 files changed, 37 insertions(+), 48 deletions(-)

diff --git a/drivers/parport/ieee1284.c b/drivers/parport/ieee1284.c
index 27673b838e74..51b2d9f2c142 100644
--- a/drivers/parport/ieee1284.c
+++ b/drivers/parport/ieee1284.c
@@ -631,29 +631,29 @@ ssize_t parport_write(struct parport *port, const void *buffer, size_t len)
 
 	case IEEE1284_MODE_EPP:
 		DPRINTK(KERN_DEBUG "%s: Using EPP mode\n", port->name);
-		if (addr) {
+		if (addr)
 			fn = port->ops->epp_write_addr;
-		} else {
+		else
 			fn = port->ops->epp_write_data;
-		}
+
 		break;
 	case IEEE1284_MODE_EPPSWE:
 		DPRINTK(KERN_DEBUG "%s: Using software-emulated EPP mode\n",
 			port->name);
-		if (addr) {
+		if (addr)
 			fn = parport_ieee1284_epp_write_addr;
-		} else {
+		else
 			fn = parport_ieee1284_epp_write_data;
-		}
+
 		break;
 	case IEEE1284_MODE_ECP:
 	case IEEE1284_MODE_ECPRLE:
 		DPRINTK(KERN_DEBUG "%s: Using ECP mode\n", port->name);
-		if (addr) {
+		if (addr)
 			fn = port->ops->ecp_write_addr;
-		} else {
+		else
 			fn = port->ops->ecp_write_data;
-		}
+
 		break;
 
 	case IEEE1284_MODE_ECPSWE:
@@ -661,11 +661,11 @@ ssize_t parport_write(struct parport *port, const void *buffer, size_t len)
 			 port->name);
 		/* The caller has specified that it must be emulated,
 		 * even if we have ECP hardware! */
-		if (addr) {
+		if (addr)
 			fn = parport_ieee1284_ecp_write_addr;
-		} else {
+		else
 			fn = parport_ieee1284_ecp_write_data;
-		}
+
 		break;
 
 	default:
@@ -726,9 +726,9 @@ ssize_t parport_read(struct parport *port, void *buffer, size_t len)
 			fn = port->ops->byte_read_data;
 			break;
 		}
-		if (parport_negotiate(port, IEEE1284_MODE_NIBBLE)) {
+		if (parport_negotiate(port, IEEE1284_MODE_NIBBLE))
 			return -EIO;
-		}
+
 		/* fall through to NIBBLE */
 	case IEEE1284_MODE_NIBBLE:
 		DPRINTK(KERN_DEBUG "%s: Using nibble mode\n", port->name);
@@ -742,20 +742,20 @@ ssize_t parport_read(struct parport *port, void *buffer, size_t len)
 
 	case IEEE1284_MODE_EPP:
 		DPRINTK(KERN_DEBUG "%s: Using EPP mode\n", port->name);
-		if (addr) {
+		if (addr)
 			fn = port->ops->epp_read_addr;
-		} else {
+		else
 			fn = port->ops->epp_read_data;
-		}
+
 		break;
 	case IEEE1284_MODE_EPPSWE:
 		DPRINTK(KERN_DEBUG "%s: Using software-emulated EPP mode\n",
 			port->name);
-		if (addr) {
+		if (addr)
 			fn = parport_ieee1284_epp_read_addr;
-		} else {
+		else
 			fn = parport_ieee1284_epp_read_data;
-		}
+
 		break;
 	case IEEE1284_MODE_ECP:
 	case IEEE1284_MODE_ECPRLE:
diff --git a/drivers/parport/ieee1284_ops.c b/drivers/parport/ieee1284_ops.c
index b431ab6349fe..bc1c0e5f9199 100644
--- a/drivers/parport/ieee1284_ops.c
+++ b/drivers/parport/ieee1284_ops.c
@@ -251,9 +251,8 @@ size_t parport_ieee1284_read_byte(struct parport *port,
 		unsigned char byte;
 
 		/* Data available? */
-		if (parport_read_status(port) & PARPORT_STATUS_ERROR) {
+		if (parport_read_status(port) & PARPORT_STATUS_ERROR)
 			goto end_of_data;
-		}
 
 		/* Event 14: Place data bus in high impedance state. */
 		parport_data_reverse(port);
@@ -796,9 +795,8 @@ size_t parport_ieee1284_epp_read_data(struct parport *port,
 				      PARPORT_CONTROL_AUTOFD,
 				      PARPORT_CONTROL_AUTOFD);
 		/* Event 58: wait for Busy to go high */
-		if (parport_wait_peripheral(port, PARPORT_STATUS_BUSY, 0)) {
+		if (parport_wait_peripheral(port, PARPORT_STATUS_BUSY, 0))
 			break;
-		}
 
 		*bp = parport_read_data(port);
 
@@ -884,9 +882,8 @@ size_t parport_ieee1284_epp_read_addr(struct parport *port,
 				      PARPORT_CONTROL_SELECT);
 
 		/* Event 58: wait for Busy to go high */
-		if (parport_wait_peripheral(port, PARPORT_STATUS_BUSY, 0)) {
+		if (parport_wait_peripheral(port, PARPORT_STATUS_BUSY, 0))
 			break;
-		}
 
 		*bp = parport_read_data(port);
 
diff --git a/drivers/parport/parport_gsc.c b/drivers/parport/parport_gsc.c
index 9c2493fa29ff..e11c09874ad0 100644
--- a/drivers/parport/parport_gsc.c
+++ b/drivers/parport/parport_gsc.c
@@ -290,15 +290,14 @@ struct parport *parport_gsc_probe_port(unsigned long base,
 
 	printk(KERN_INFO "%s: PC-style at 0x%lx", p->name, p->base);
 	p->irq = irq;
-	if (p->irq == PARPORT_IRQ_AUTO) {
+	if (p->irq == PARPORT_IRQ_AUTO)
 		p->irq = PARPORT_IRQ_NONE;
-	}
+
 	if (p->irq != PARPORT_IRQ_NONE) {
 		pr_cont(", irq %d", p->irq);
 
-		if (p->dma == PARPORT_DMA_AUTO) {
+		if (p->dma == PARPORT_DMA_AUTO)
 			p->dma = PARPORT_DMA_NONE;
-		}
 	}
 	if (p->dma == PARPORT_DMA_AUTO) /* To use DMA, giving the irq
                                            is mandatory (see above) */
diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c
index 5548193a28a6..15d7693f8202 100644
--- a/drivers/parport/parport_pc.c
+++ b/drivers/parport/parport_pc.c
@@ -1729,9 +1729,8 @@ static int intel_bug_present_check_epp(struct parport *pb)
 static int intel_bug_present(struct parport *pb)
 {
 /* Check whether the device is legacy, not PCI or PCMCIA. Only legacy is known to be affected. */
-	if (pb->dev != NULL) {
+	if (pb->dev != NULL)
 		return 0;
-	}
 
 	return intel_bug_present_check_epp(pb);
 }
diff --git a/drivers/parport/parport_sunbpp.c b/drivers/parport/parport_sunbpp.c
index 6037008579f1..50820fa1750f 100644
--- a/drivers/parport/parport_sunbpp.c
+++ b/drivers/parport/parport_sunbpp.c
@@ -142,32 +142,28 @@ static unsigned char parport_sunbpp_frob_control(struct parport *p,
 	dprintk((KERN_DEBUG "frob1: tcr 0x%x or 0x%x\n",
 		 value_tcr, value_or));
 	if (mask & PARPORT_CONTROL_STROBE) {
-		if (val & PARPORT_CONTROL_STROBE) {
+		if (val & PARPORT_CONTROL_STROBE)
 			value_tcr &= ~P_TCR_DS;
-		} else {
+		else
 			value_tcr |= P_TCR_DS;
-		}
 	}
 	if (mask & PARPORT_CONTROL_AUTOFD) {
-		if (val & PARPORT_CONTROL_AUTOFD) {
+		if (val & PARPORT_CONTROL_AUTOFD)
 			value_or &= ~P_OR_AFXN;
-		} else {
+		else
 			value_or |= P_OR_AFXN;
-		}
 	}
 	if (mask & PARPORT_CONTROL_INIT) {
-		if (val & PARPORT_CONTROL_INIT) {
+		if (val & PARPORT_CONTROL_INIT)
 			value_or &= ~P_OR_INIT;
-		} else {
+		else
 			value_or |= P_OR_INIT;
-		}
 	}
 	if (mask & PARPORT_CONTROL_SELECT) {
-		if (val & PARPORT_CONTROL_SELECT) {
+		if (val & PARPORT_CONTROL_SELECT)
 			value_or |= P_OR_SLCT_IN;
-		} else {
+		else
 			value_or &= ~P_OR_SLCT_IN;
-		}
 	}
 
 	sbus_writeb(value_or, &regs->p_or);
diff --git a/drivers/parport/procfs.c b/drivers/parport/procfs.c
index 6ee97b5849c5..e42f03f2d24e 100644
--- a/drivers/parport/procfs.c
+++ b/drivers/parport/procfs.c
@@ -49,14 +49,12 @@ static int do_active_device(struct ctl_table *table, int write,
 	}
 	
 	for (dev = port->devices; dev ; dev = dev->next) {
-		if(dev == port->cad) {
+		if(dev == port->cad)
 			len += sprintf(buffer, "%s\n", dev->name);
-		}
 	}
 
-	if(!len) {
+	if(!len)
 		len += sprintf(buffer, "%s\n", "none");
-	}
 
 	if (len > *lenp)
 		len = *lenp;
-- 
2.11.0