Merge git://git.kernel.org/pub/scm/linux/kernel/git/bunk/trivial

3 files changed, 65 insertions, 85 deletions

diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index d6fcd0a36f9f..4135d8c5bcae 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -881,16 +881,6 @@ config FTAPE
           module. To compile this driver as a module, choose M here: the
           module will be called ftape.
 
-          Note that the Ftape-HOWTO is out of date (sorry) and documents the
-          older version 2.08 of this software but still contains useful
-          information.  There is a web page with more recent documentation at
-          <http://www.instmath.rwth-aachen.de/~heine/ftape/>.  This page
-          always contains the latest release of the ftape driver and useful
-          information (backup software, ftape related patches and
-          documentation, FAQ).  Note that the file system interface has
-          changed quite a bit compared to previous versions of ftape.  Please
-          read <file:Documentation/ftape.txt>.
-
 source "drivers/char/ftape/Kconfig"
 
 endmenu
diff --git a/drivers/char/ftape/Kconfig b/drivers/char/ftape/Kconfig
index 7d3ecb56a1bd..0d65189a7ae8 100644
--- a/drivers/char/ftape/Kconfig
+++ b/drivers/char/ftape/Kconfig
@@ -25,17 +25,7 @@ config ZFTAPE
           support", above) then `zft-compressor' will be loaded
           automatically by zftape when needed.
 
-          Despite its name, zftape does NOT use compression by default.  The
-          file <file:Documentation/ftape.txt> contains a short description of
-          the most important changes in the file system interface compared to
-          previous versions of ftape.  The ftape home page
-          <http://www.instmath.rwth-aachen.de/~heine/ftape/> contains
-          further information.
-
-          IMPORTANT NOTE: zftape can read archives created by previous
-          versions of ftape and provide file mark support (i.e. fast skipping
-          between tape archives) but previous version of ftape will lack file
-          mark support when reading archives produced by zftape.
+          Despite its name, zftape does NOT use compression by default.
 
 config ZFT_DFLT_BLK_SZ
         int "Default block size"
diff --git a/drivers/char/stallion.c b/drivers/char/stallion.c
index 0e20780d4a29..bdaab6992109 100644
--- a/drivers/char/stallion.c
+++ b/drivers/char/stallion.c
@@ -738,7 +738,7 @@ static int __init stallion_module_init(void)
         stl_init();
         restore_flags(flags);
 
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -889,7 +889,7 @@ static unsigned long stl_atol(char *str)
                 }
                 val = (val * base) + c;
         }
-        return(val);
+        return val;
 }
 
 /*****************************************************************************/
@@ -908,7 +908,7 @@ static int stl_parsebrd(stlconf_t *confp, char **argp)
 #endif
 
         if ((argp[0] == (char *) NULL) || (*argp[0] == 0))
-                return(0);
+                return 0;
 
         for (sp = argp[0], i = 0; ((*sp != 0) && (i < 25)); sp++, i++)
                 *sp = TOLOWER(*sp);
@@ -935,7 +935,7 @@ static int stl_parsebrd(stlconf_t *confp, char **argp)
         }
         if ((argp[i] != (char *) NULL) && (*argp[i] != 0))
                 confp->irq = stl_atol(argp[i]);
-        return(1);
+        return 1;
 }
 
 /*****************************************************************************/
@@ -946,7 +946,7 @@ static int stl_parsebrd(stlconf_t *confp, char **argp)
 
 static void *stl_memalloc(int len)
 {
-        return((void *) kmalloc(len, GFP_KERNEL));
+        return (void *) kmalloc(len, GFP_KERNEL);
 }
 
 /*****************************************************************************/
@@ -963,12 +963,12 @@ static stlbrd_t *stl_allocbrd(void)
         if (brdp == (stlbrd_t *) NULL) {
                 printk("STALLION: failed to allocate memory (size=%d)\n",
                         sizeof(stlbrd_t));
-                return((stlbrd_t *) NULL);
+                return (stlbrd_t *) NULL;
         }
 
         memset(brdp, 0, sizeof(stlbrd_t));
         brdp->magic = STL_BOARDMAGIC;
-        return(brdp);
+        return brdp;
 }
 
 /*****************************************************************************/
@@ -988,10 +988,10 @@ static int stl_open(struct tty_struct *tty, struct file *filp)
         minordev = tty->index;
         brdnr = MINOR2BRD(minordev);
         if (brdnr >= stl_nrbrds)
-                return(-ENODEV);
+                return -ENODEV;
         brdp = stl_brds[brdnr];
         if (brdp == (stlbrd_t *) NULL)
-                return(-ENODEV);
+                return -ENODEV;
         minordev = MINOR2PORT(minordev);
         for (portnr = -1, panelnr = 0; (panelnr < STL_MAXPANELS); panelnr++) {
                 if (brdp->panels[panelnr] == (stlpanel_t *) NULL)
@@ -1003,11 +1003,11 @@ static int stl_open(struct tty_struct *tty, struct file *filp)
                 minordev -= brdp->panels[panelnr]->nrports;
         }
         if (portnr < 0)
-                return(-ENODEV);
+                return -ENODEV;
 
         portp = brdp->panels[panelnr]->ports[portnr];
         if (portp == (stlport_t *) NULL)
-                return(-ENODEV);
+                return -ENODEV;
 
 /*
  *      On the first open of the device setup the port hardware, and
@@ -1021,7 +1021,7 @@ static int stl_open(struct tty_struct *tty, struct file *filp)
                 if (portp->tx.buf == (char *) NULL) {
                         portp->tx.buf = (char *) stl_memalloc(STL_TXBUFSIZE);
                         if (portp->tx.buf == (char *) NULL)
-                                return(-ENOMEM);
+                                return -ENOMEM;
                         portp->tx.head = portp->tx.buf;
                         portp->tx.tail = portp->tx.buf;
                 }
@@ -1043,8 +1043,8 @@ static int stl_open(struct tty_struct *tty, struct file *filp)
         if (portp->flags & ASYNC_CLOSING) {
                 interruptible_sleep_on(&portp->close_wait);
                 if (portp->flags & ASYNC_HUP_NOTIFY)
-                        return(-EAGAIN);
-                return(-ERESTARTSYS);
+                        return -EAGAIN;
+                return -ERESTARTSYS;
         }
 
 /*
@@ -1054,11 +1054,11 @@ static int stl_open(struct tty_struct *tty, struct file *filp)
  */
         if (!(filp->f_flags & O_NONBLOCK)) {
                 if ((rc = stl_waitcarrier(portp, filp)) != 0)
-                        return(rc);
+                        return rc;
         }
         portp->flags |= ASYNC_NORMAL_ACTIVE;
 
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -1115,7 +1115,7 @@ static int stl_waitcarrier(stlport_t *portp, struct file *filp)
         portp->openwaitcnt--;
         restore_flags(flags);
 
-        return(rc);
+        return rc;
 }
 
 /*****************************************************************************/
@@ -1211,12 +1211,12 @@ static int stl_write(struct tty_struct *tty, const unsigned char *buf, int count
 
         if ((tty == (struct tty_struct *) NULL) ||
             (stl_tmpwritebuf == (char *) NULL))
-                return(0);
+                return 0;
         portp = tty->driver_data;
         if (portp == (stlport_t *) NULL)
-                return(0);
+                return 0;
         if (portp->tx.buf == (char *) NULL)
-                return(0);
+                return 0;
 
 /*
  *      If copying direct from user space we must cater for page faults,
@@ -1255,7 +1255,7 @@ static int stl_write(struct tty_struct *tty, const unsigned char *buf, int count
         clear_bit(ASYI_TXLOW, &portp->istate);
         stl_startrxtx(portp, -1, 1);
 
-        return(count);
+        return count;
 }
 
 /*****************************************************************************/
@@ -1336,16 +1336,16 @@ static int stl_writeroom(struct tty_struct *tty)
 #endif
 
         if (tty == (struct tty_struct *) NULL)
-                return(0);
+                return 0;
         portp = tty->driver_data;
         if (portp == (stlport_t *) NULL)
-                return(0);
+                return 0;
         if (portp->tx.buf == (char *) NULL)
-                return(0);
+                return 0;
 
         head = portp->tx.head;
         tail = portp->tx.tail;
-        return((head >= tail) ? (STL_TXBUFSIZE - (head - tail) - 1) : (tail - head - 1));
+        return ((head >= tail) ? (STL_TXBUFSIZE - (head - tail) - 1) : (tail - head - 1));
 }
 
 /*****************************************************************************/
@@ -1370,19 +1370,19 @@ static int stl_charsinbuffer(struct tty_struct *tty)
 #endif
 
         if (tty == (struct tty_struct *) NULL)
-                return(0);
+                return 0;
         portp = tty->driver_data;
         if (portp == (stlport_t *) NULL)
-                return(0);
+                return 0;
         if (portp->tx.buf == (char *) NULL)
-                return(0);
+                return 0;
 
         head = portp->tx.head;
         tail = portp->tx.tail;
         size = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
         if ((size == 0) && test_bit(ASYI_TXBUSY, &portp->istate))
                 size = 1;
-        return(size);
+        return size;
 }
 
 /*****************************************************************************/
@@ -1447,7 +1447,7 @@ static int stl_setserial(stlport_t *portp, struct serial_struct __user *sp)
                     (sio.close_delay != portp->close_delay) ||
                     ((sio.flags & ~ASYNC_USR_MASK) !=
                     (portp->flags & ~ASYNC_USR_MASK)))
-                        return(-EPERM);
+                        return -EPERM;
         } 
 
         portp->flags = (portp->flags & ~ASYNC_USR_MASK) |
@@ -1457,7 +1457,7 @@ static int stl_setserial(stlport_t *portp, struct serial_struct __user *sp)
         portp->closing_wait = sio.closing_wait;
         portp->custom_divisor = sio.custom_divisor;
         stl_setport(portp, portp->tty->termios);
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -1467,12 +1467,12 @@ static int stl_tiocmget(struct tty_struct *tty, struct file *file)
         stlport_t       *portp;
 
         if (tty == (struct tty_struct *) NULL)
-                return(-ENODEV);
+                return -ENODEV;
         portp = tty->driver_data;
         if (portp == (stlport_t *) NULL)
-                return(-ENODEV);
+                return -ENODEV;
         if (tty->flags & (1 << TTY_IO_ERROR))
-                return(-EIO);
+                return -EIO;
 
         return stl_getsignals(portp);
 }
@@ -1484,12 +1484,12 @@ static int stl_tiocmset(struct tty_struct *tty, struct file *file,
         int rts = -1, dtr = -1;
 
         if (tty == (struct tty_struct *) NULL)
-                return(-ENODEV);
+                return -ENODEV;
         portp = tty->driver_data;
         if (portp == (stlport_t *) NULL)
-                return(-ENODEV);
+                return -ENODEV;
         if (tty->flags & (1 << TTY_IO_ERROR))
-                return(-EIO);
+                return -EIO;
 
         if (set & TIOCM_RTS)
                 rts = 1;
@@ -1517,15 +1517,15 @@ static int stl_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd
 #endif
 
         if (tty == (struct tty_struct *) NULL)
-                return(-ENODEV);
+                return -ENODEV;
         portp = tty->driver_data;
         if (portp == (stlport_t *) NULL)
-                return(-ENODEV);
+                return -ENODEV;
 
         if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
             (cmd != COM_GETPORTSTATS) && (cmd != COM_CLRPORTSTATS)) {
                 if (tty->flags & (1 << TTY_IO_ERROR))
-                        return(-EIO);
+                        return -EIO;
         }
 
         rc = 0;
@@ -1566,7 +1566,7 @@ static int stl_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd
                 break;
         }
 
-        return(rc);
+        return rc;
 }
 
 /*****************************************************************************/
@@ -1872,7 +1872,7 @@ static int stl_portinfo(stlport_t *portp, int portnr, char *pos)
                 pos[(MAXLINE - 2)] = '+';
         pos[(MAXLINE - 1)] = '\n';
 
-        return(MAXLINE);
+        return MAXLINE;
 }
 
 /*****************************************************************************/
@@ -1957,7 +1957,7 @@ static int stl_readproc(char *page, char **start, off_t off, int count, int *eof
 
 stl_readdone:
         *start = page;
-        return(pos - page);
+        return (pos - page);
 }
 
 /*****************************************************************************/
@@ -2349,7 +2349,7 @@ static inline int stl_initeio(stlbrd_t *brdp)
         } else {
                 rc = 0;
         }
-        return(rc);
+        return rc;
 }
 
 /*****************************************************************************/
@@ -3116,7 +3116,7 @@ static int __init stl_init(void)
                 return -1;
         }
 
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -3132,7 +3132,7 @@ static int __init stl_init(void)
 static int stl_cd1400getreg(stlport_t *portp, int regnr)
 {
         outb((regnr + portp->uartaddr), portp->ioaddr);
-        return(inb(portp->ioaddr + EREG_DATA));
+        return inb(portp->ioaddr + EREG_DATA);
 }
 
 static void stl_cd1400setreg(stlport_t *portp, int regnr, int value)
@@ -3146,9 +3146,9 @@ static int stl_cd1400updatereg(stlport_t *portp, int regnr, int value)
         outb((regnr + portp->uartaddr), portp->ioaddr);
         if (inb(portp->ioaddr + EREG_DATA) != value) {
                 outb(value, portp->ioaddr + EREG_DATA);
-                return(1);
+                return 1;
         }
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -3206,7 +3206,7 @@ static int stl_cd1400panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
         }
 
         BRDDISABLE(panelp->brdnr);
-        return(chipmask);
+        return chipmask;
 }
 
 /*****************************************************************************/
@@ -3557,7 +3557,7 @@ static int stl_cd1400getsignals(stlport_t *portp)
 #else
         sigs |= TIOCM_DSR;
 #endif
-        return(sigs);
+        return sigs;
 }
 
 /*****************************************************************************/
@@ -3830,9 +3830,9 @@ static int stl_cd1400datastate(stlport_t *portp)
 #endif
 
         if (portp == (stlport_t *) NULL)
-                return(0);
+                return 0;
 
-        return(test_bit(ASYI_TXBUSY, &portp->istate) ? 1 : 0);
+        return test_bit(ASYI_TXBUSY, &portp->istate) ? 1 : 0;
 }
 
 /*****************************************************************************/
@@ -3912,20 +3912,20 @@ static inline int stl_cd1400breakisr(stlport_t *portp, int ioaddr)
                 outb((SRER + portp->uartaddr), ioaddr);
                 outb((inb(ioaddr + EREG_DATA) & ~(SRER_TXDATA | SRER_TXEMPTY)),
                         (ioaddr + EREG_DATA));
-                return(1);
+                return 1;
         } else if (portp->brklen > 1) {
                 outb((TDR + portp->uartaddr), ioaddr);
                 outb(ETC_CMD, (ioaddr + EREG_DATA));
                 outb(ETC_STOPBREAK, (ioaddr + EREG_DATA));
                 portp->brklen = -1;
-                return(1);
+                return 1;
         } else {
                 outb((COR2 + portp->uartaddr), ioaddr);
                 outb((inb(ioaddr + EREG_DATA) & ~COR2_ETC),
                         (ioaddr + EREG_DATA));
                 portp->brklen = 0;
         }
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -4166,7 +4166,7 @@ static void stl_cd1400mdmisr(stlpanel_t *panelp, int ioaddr)
 static int stl_sc26198getreg(stlport_t *portp, int regnr)
 {
         outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR));
-        return(inb(portp->ioaddr + XP_DATA));
+        return inb(portp->ioaddr + XP_DATA);
 }
 
 static void stl_sc26198setreg(stlport_t *portp, int regnr, int value)
@@ -4180,9 +4180,9 @@ static int stl_sc26198updatereg(stlport_t *portp, int regnr, int value)
         outb((regnr | portp->uartaddr), (portp->ioaddr + XP_ADDR));
         if (inb(portp->ioaddr + XP_DATA) != value) {
                 outb(value, (portp->ioaddr + XP_DATA));
-                return(1);
+                return 1;
         }
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -4194,7 +4194,7 @@ static int stl_sc26198updatereg(stlport_t *portp, int regnr, int value)
 static int stl_sc26198getglobreg(stlport_t *portp, int regnr)
 {
         outb(regnr, (portp->ioaddr + XP_ADDR));
-        return(inb(portp->ioaddr + XP_DATA));
+        return inb(portp->ioaddr + XP_DATA);
 }
 
 #if 0
@@ -4252,7 +4252,7 @@ static int stl_sc26198panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
         }
 
         BRDDISABLE(panelp->brdnr);
-        return(chipmask);
+        return chipmask;
 }
 
 /*****************************************************************************/
@@ -4546,7 +4546,7 @@ static int stl_sc26198getsignals(stlport_t *portp)
         sigs |= (ipr & IPR_DTR) ? 0: TIOCM_DTR;
         sigs |= (ipr & IPR_RTS) ? 0: TIOCM_RTS;
         sigs |= TIOCM_DSR;
-        return(sigs);
+        return sigs;
 }
 
 /*****************************************************************************/
@@ -4828,9 +4828,9 @@ static int stl_sc26198datastate(stlport_t *portp)
 #endif
 
         if (portp == (stlport_t *) NULL)
-                return(0);
+                return 0;
         if (test_bit(ASYI_TXBUSY, &portp->istate))
-                return(1);
+                return 1;
 
         save_flags(flags);
         cli();
@@ -4839,7 +4839,7 @@ static int stl_sc26198datastate(stlport_t *portp)
         BRDDISABLE(portp->brdnr);
         restore_flags(flags);
 
-        return((sr & SR_TXEMPTY) ? 0 : 1);
+        return (sr & SR_TXEMPTY) ? 0 : 1;
 }
 
 /*****************************************************************************/