based on checkpatch, remove prohibited space between function name and
open parenthesis '('.Signed-off-by: Carlos Palminha <[email protected]> --- 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(®s->p_tcr); @@ -202,7 +202,7 @@ static void parport_sunbpp_data_forward (struct parport *p) sbus_writeb(value_tcr, ®s->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(®s->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
