static void tx_timeout(struct timer_list *t);
 
-static int carrier_raised(struct tty_port *port);
+static bool carrier_raised(struct tty_port *port);
 static void dtr_rts(struct tty_port *port, int onoff);
 
 #if SYNCLINK_GENERIC_HDLC
        tty_port_hangup(&info->port);
 }
 
-static int carrier_raised(struct tty_port *port)
+static bool carrier_raised(struct tty_port *port)
 {
        MGSLPC_INFO *info = container_of(port, MGSLPC_INFO, port);
        unsigned long flags;
        get_signals(info);
        spin_unlock_irqrestore(&info->lock, flags);
 
-       if (info->serial_signals & SerialSignal_DCD)
-               return 1;
-       return 0;
+       return info->serial_signals & SerialSignal_DCD;
 }
 
 static void dtr_rts(struct tty_port *port, int onoff)
 
        port->in_sdio_uart_irq = NULL;
 }
 
-static int uart_carrier_raised(struct tty_port *tport)
+static bool uart_carrier_raised(struct tty_port *tport)
 {
        struct sdio_uart_port *port =
                        container_of(tport, struct sdio_uart_port, port);
                return 1;
        ret = sdio_uart_get_mctrl(port);
        sdio_uart_release_func(port);
-       if (ret & TIOCM_CAR)
-               return 1;
-       return 0;
+
+       return ret & TIOCM_CAR;
 }
 
 /**
 
        .proc_show = rs_proc_show,
 };
 
-static int amiga_carrier_raised(struct tty_port *port)
+static bool amiga_carrier_raised(struct tty_port *port)
 {
        return !(ciab.pra & SER_DCD);
 }
 
 static void moxa_poll(struct timer_list *);
 static void moxa_set_tty_param(struct tty_struct *, const struct ktermios *);
 static void moxa_shutdown(struct tty_port *);
-static int moxa_carrier_raised(struct tty_port *);
+static bool moxa_carrier_raised(struct tty_port *);
 static void moxa_dtr_rts(struct tty_port *, int);
 /*
  * moxa board interface functions:
        MoxaPortFlushData(ch, 2);
 }
 
-static int moxa_carrier_raised(struct tty_port *port)
+static bool moxa_carrier_raised(struct tty_port *port)
 {
        struct moxa_port *ch = container_of(port, struct moxa_port, port);
        int dcd;
 
        outb(info->IER, info->ioaddr + UART_IER);
 }
 
-static int mxser_carrier_raised(struct tty_port *port)
+static bool mxser_carrier_raised(struct tty_port *port)
 {
        struct mxser_port *mp = container_of(port, struct mxser_port, port);
-       return (inb(mp->ioaddr + UART_MSR) & UART_MSR_DCD)?1:0;
+
+       return inb(mp->ioaddr + UART_MSR) & UART_MSR_DCD;
 }
 
 static void mxser_dtr_rts(struct tty_port *port, int on)
 
        return -EPROTONOSUPPORT;
 }
 
-static int gsm_carrier_raised(struct tty_port *port)
+static bool gsm_carrier_raised(struct tty_port *port)
 {
        struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
        struct gsm_mux *gsm = dlci->gsm;
 
        /* Not yet open so no carrier info */
        if (dlci->state != DLCI_OPEN)
-               return 0;
+               return false;
        if (debug & DBG_CD_ON)
-               return 1;
+               return true;
 
        /*
         * Basic mode with control channel in ADM mode may not respond
         */
        if (gsm->encoding == GSM_BASIC_OPT &&
            gsm->dlci[0]->mode == DLCI_MODE_ADM && !dlci->modem_rx)
-               return 1;
+               return true;
 
        return dlci->modem_rx & TIOCM_CD;
 }
 
        }
 }
 
-static int uart_carrier_raised(struct tty_port *port)
+static bool uart_carrier_raised(struct tty_port *port)
 {
        struct uart_state *state = container_of(port, struct uart_state, port);
        struct uart_port *uport;
         * continue and not sleep
         */
        if (WARN_ON(!uport))
-               return 1;
+               return true;
        spin_lock_irq(&uport->lock);
        uart_enable_ms(uport);
        mctrl = uport->ops->get_mctrl(uport);
        spin_unlock_irq(&uport->lock);
        uart_port_deref(uport);
-       if (mctrl & TIOCM_CAR)
-               return 1;
-       return 0;
+
+       return mctrl & TIOCM_CAR;
 }
 
 static void uart_dtr_rts(struct tty_port *port, int raise)
 
        return 0;
 }
 
-static int carrier_raised(struct tty_port *port)
+static bool carrier_raised(struct tty_port *port)
 {
        unsigned long flags;
        struct slgt_info *info = container_of(port, struct slgt_info, port);
        spin_lock_irqsave(&info->lock,flags);
        get_gtsignals(info);
        spin_unlock_irqrestore(&info->lock,flags);
-       return (info->signals & SerialSignal_DCD) ? 1 : 0;
+
+       return info->signals & SerialSignal_DCD;
 }
 
 static void dtr_rts(struct tty_port *port, int on)
        int             retval;
        bool            do_clocal = false;
        unsigned long   flags;
-       int             cd;
+       bool            cd;
        struct tty_port *port = &info->port;
 
        DBGINFO(("%s block_til_ready\n", tty->driver->name));
 
  * to hide some internal details. This will eventually become entirely
  * internal to the tty port.
  */
-int tty_port_carrier_raised(struct tty_port *port)
+bool tty_port_carrier_raised(struct tty_port *port)
 {
        if (port->ops->carrier_raised == NULL)
-               return 1;
+               return true;
        return port->ops->carrier_raised(port);
 }
 EXPORT_SYMBOL(tty_port_carrier_raised);
 
        return NULL;
 }
 
-static int serial_port_carrier_raised(struct tty_port *port)
+static bool serial_port_carrier_raised(struct tty_port *port)
 {
        struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
        struct usb_serial_driver *drv = p->serial->type;
        if (drv->carrier_raised)
                return drv->carrier_raised(p);
        /* No carrier control - don't block */
-       return 1;
+       return true;
 }
 
 static void serial_port_dtr_rts(struct tty_port *port, int on)
 
 
 /**
  * struct tty_port_operations -- operations on tty_port
- * @carrier_raised: return 1 if the carrier is raised on @port
+ * @carrier_raised: return true if the carrier is raised on @port
  * @dtr_rts: raise the DTR line if @raise is nonzero, 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
  *     the port itself.
  */
 struct tty_port_operations {
-       int (*carrier_raised)(struct tty_port *port);
+       bool (*carrier_raised)(struct tty_port *port);
        void (*dtr_rts)(struct tty_port *port, int raise);
        void (*shutdown)(struct tty_port *port);
        int (*activate)(struct tty_port *port, struct tty_struct *tty);
 
 struct tty_struct *tty_port_tty_get(struct tty_port *port);
 void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty);
-int tty_port_carrier_raised(struct tty_port *port);
+bool tty_port_carrier_raised(struct tty_port *port);
 void tty_port_raise_dtr_rts(struct tty_port *port);
 void tty_port_lower_dtr_rts(struct tty_port *port);
 void tty_port_hangup(struct tty_port *port);
 
 }
 
 /* we block the open until the dlc->state becomes BT_CONNECTED */
-static int rfcomm_dev_carrier_raised(struct tty_port *port)
+static bool rfcomm_dev_carrier_raised(struct tty_port *port)
 {
        struct rfcomm_dev *dev = container_of(port, struct rfcomm_dev, port);