static void tx_timeout(struct timer_list *t);
 
 static bool carrier_raised(struct tty_port *port);
-static void dtr_rts(struct tty_port *port, bool onoff);
+static void dtr_rts(struct tty_port *port, bool active);
 
 #if SYNCLINK_GENERIC_HDLC
 #define dev_to_port(D) (dev_to_hdlc(D)->priv)
        return info->serial_signals & SerialSignal_DCD;
 }
 
-static void dtr_rts(struct tty_port *port, bool onoff)
+static void dtr_rts(struct tty_port *port, bool active)
 {
        MGSLPC_INFO *info = container_of(port, MGSLPC_INFO, port);
        unsigned long flags;
 
        spin_lock_irqsave(&info->lock, flags);
-       if (onoff)
+       if (active)
                info->serial_signals |= SerialSignal_RTS | SerialSignal_DTR;
        else
                info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
 
 /**
  *     uart_dtr_rts            -        port helper to set uart signals
  *     @tport: tty port to be updated
- *     @onoff: set to turn on DTR/RTS
+ *     @active: set to turn on DTR/RTS
  *
  *     Called by the tty port helpers when the modem signals need to be
  *     adjusted during an open, close and hangup.
  */
 
-static void uart_dtr_rts(struct tty_port *tport, bool onoff)
+static void uart_dtr_rts(struct tty_port *tport, bool active)
 {
        struct sdio_uart_port *port =
                        container_of(tport, struct sdio_uart_port, port);
        int ret = sdio_uart_claim_func(port);
        if (ret)
                return;
-       if (!onoff)
+       if (!active)
                sdio_uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
        else
                sdio_uart_set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
 
        return -ENOIOCTLCMD;
 }
 
-static void gb_tty_dtr_rts(struct tty_port *port, bool on)
+static void gb_tty_dtr_rts(struct tty_port *port, bool active)
 {
        struct gb_tty *gb_tty;
        u8 newctrl;
        gb_tty = container_of(port, struct gb_tty, port);
        newctrl = gb_tty->ctrlout;
 
-       if (on)
+       if (active)
                newctrl |= (GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
        else
                newctrl &= ~(GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
 
        return !(ciab.pra & SER_DCD);
 }
 
-static void amiga_dtr_rts(struct tty_port *port, bool raise)
+static void amiga_dtr_rts(struct tty_port *port, bool active)
 {
        struct serial_state *info = container_of(port, struct serial_state,
                        tport);
        unsigned long flags;
 
-       if (raise)
+       if (active)
                info->MCR |= SER_DTR|SER_RTS;
        else
                info->MCR &= ~(SER_DTR|SER_RTS);
 
        int (*tiocmset)(struct hvc_struct *hp, unsigned int set, unsigned int clear);
 
        /* Callbacks to handle tty ports */
-       void (*dtr_rts)(struct hvc_struct *hp, bool raise);
+       void (*dtr_rts)(struct hvc_struct *hp, bool active);
 };
 
 /* Register a vterm and a slot index for use as a console (console_init) */
 
 /**
  * hvc_iucv_dtr_rts() - HVC notifier for handling DTR/RTS
  * @hp:                Pointer the HVC device (struct hvc_struct)
- * @raise:     True to raise or false to lower DTR/RTS lines
+ * @active:    True to raise or false to lower DTR/RTS lines
  *
  * This routine notifies the HVC back-end to raise or lower DTR/RTS
  * lines.  Raising DTR/RTS is ignored.  Lowering DTR/RTS indicates to
  * drop the IUCV connection (similar to hang up the modem).
  */
-static void hvc_iucv_dtr_rts(struct hvc_struct *hp, bool raise)
+static void hvc_iucv_dtr_rts(struct hvc_struct *hp, bool active)
 {
        struct hvc_iucv_private *priv;
        struct iucv_path        *path;
        /* Raising the DTR/RTS is ignored as IUCV connections can be
         * established at any times.
         */
-       if (raise)
+       if (active)
                return;
 
        priv = hvc_iucv_get_private(hp->vtermno);
 
        return inb(mp->ioaddr + UART_MSR) & UART_MSR_DCD;
 }
 
-static void mxser_dtr_rts(struct tty_port *port, bool on)
+static void mxser_dtr_rts(struct tty_port *port, bool active)
 {
        struct mxser_port *mp = container_of(port, struct mxser_port, port);
        unsigned long flags;
 
        spin_lock_irqsave(&mp->slock, flags);
        mcr = inb(mp->ioaddr + UART_MCR);
-       if (on)
+       if (active)
                mcr |= UART_MCR_DTR | UART_MCR_RTS;
        else
                mcr &= ~(UART_MCR_DTR | UART_MCR_RTS);
 
        return dlci->modem_rx & TIOCM_CD;
 }
 
-static void gsm_dtr_rts(struct tty_port *port, bool onoff)
+static void gsm_dtr_rts(struct tty_port *port, bool active)
 {
        struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
        unsigned int modem_tx = dlci->modem_tx;
-       if (onoff)
+       if (active)
                modem_tx |= TIOCM_DTR | TIOCM_RTS;
        else
                modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
 
 #define uart_set_mctrl(port, set)      uart_update_mctrl(port, set, 0)
 #define uart_clear_mctrl(port, clear)  uart_update_mctrl(port, 0, clear)
 
-static void uart_port_dtr_rts(struct uart_port *uport, bool raise)
+static void uart_port_dtr_rts(struct uart_port *uport, bool active)
 {
-       if (raise)
+       if (active)
                uart_set_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
        else
                uart_clear_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
        return mctrl & TIOCM_CAR;
 }
 
-static void uart_dtr_rts(struct tty_port *port, bool raise)
+static void uart_dtr_rts(struct tty_port *port, bool active)
 {
        struct uart_state *state = container_of(port, struct uart_state, port);
        struct uart_port *uport;
        uport = uart_port_ref(state);
        if (!uport)
                return;
-       uart_port_dtr_rts(uport, raise);
+       uart_port_dtr_rts(uport, active);
        uart_port_deref(uport);
 }
 
 
        return info->signals & SerialSignal_DCD;
 }
 
-static void dtr_rts(struct tty_port *port, bool on)
+static void dtr_rts(struct tty_port *port, bool active)
 {
        unsigned long flags;
        struct slgt_info *info = container_of(port, struct slgt_info, port);
 
        spin_lock_irqsave(&info->lock,flags);
-       if (on)
+       if (active)
                info->signals |= SerialSignal_RTS | SerialSignal_DTR;
        else
                info->signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
 
        return tty_port_open(&acm->port, tty, filp);
 }
 
-static void acm_port_dtr_rts(struct tty_port *port, bool raise)
+static void acm_port_dtr_rts(struct tty_port *port, bool active)
 {
        struct acm *acm = container_of(port, struct acm, port);
        int val;
        int res;
 
-       if (raise)
+       if (active)
                val = USB_CDC_CTRL_DTR | USB_CDC_CTRL_RTS;
        else
                val = 0;
 
 /**
  * struct tty_port_operations -- operations on tty_port
  * @carrier_raised: return true if the carrier is raised on @port
- * @dtr_rts: raise the DTR line if @raise is true, otherwise lower DTR
+ * @dtr_rts: raise the DTR line if @active is true, otherwise lower DTR
  * @shutdown: called when the last close completes or a hangup finishes IFF the
  *     port was initialized. Do not use to free resources. Turn off the device
  *     only. Called under the port mutex to serialize against @activate and
  */
 struct tty_port_operations {
        bool (*carrier_raised)(struct tty_port *port);
-       void (*dtr_rts)(struct tty_port *port, bool raise);
+       void (*dtr_rts)(struct tty_port *port, bool active);
        void (*shutdown)(struct tty_port *port);
        int (*activate)(struct tty_port *port, struct tty_struct *tty);
        void (*destruct)(struct tty_port *port);