}
 }
 
-static void serial21285_enable_ms(struct uart_port *port)
-{
-}
-
 static irqreturn_t serial21285_rx_chars(int irq, void *dev_id)
 {
        struct uart_port *port = dev_id;
        .stop_tx        = serial21285_stop_tx,
        .start_tx       = serial21285_start_tx,
        .stop_rx        = serial21285_stop_rx,
-       .enable_ms      = serial21285_enable_ms,
        .break_ctl      = serial21285_break_ctl,
        .startup        = serial21285_startup,
        .shutdown       = serial21285_shutdown,
 
 {
 }
 
-static void altera_jtaguart_enable_ms(struct uart_port *port)
-{
-}
-
 static void altera_jtaguart_set_termios(struct uart_port *port,
                                        struct ktermios *termios,
                                        struct ktermios *old)
        .start_tx       = altera_jtaguart_start_tx,
        .stop_tx        = altera_jtaguart_stop_tx,
        .stop_rx        = altera_jtaguart_stop_rx,
-       .enable_ms      = altera_jtaguart_enable_ms,
        .break_ctl      = altera_jtaguart_break_ctl,
        .startup        = altera_jtaguart_startup,
        .shutdown       = altera_jtaguart_shutdown,
 
        spin_unlock_irqrestore(&port->lock, flags);
 }
 
-static void altera_uart_enable_ms(struct uart_port *port)
-{
-}
-
 static void altera_uart_set_termios(struct uart_port *port,
                                    struct ktermios *termios,
                                    struct ktermios *old)
        .start_tx       = altera_uart_start_tx,
        .stop_tx        = altera_uart_stop_tx,
        .stop_rx        = altera_uart_stop_rx,
-       .enable_ms      = altera_uart_enable_ms,
        .break_ctl      = altera_uart_break_ctl,
        .startup        = altera_uart_startup,
        .shutdown       = altera_uart_shutdown,
 
        UART_PUT_CTRL(port, cr);
 }
 
-static void apbuart_enable_ms(struct uart_port *port)
-{
-       /* No modem status change interrupts for APBUART */
-}
-
 static void apbuart_rx_chars(struct uart_port *port)
 {
        unsigned int status, ch, rsr, flag;
        .stop_tx = apbuart_stop_tx,
        .start_tx = apbuart_start_tx,
        .stop_rx = apbuart_stop_rx,
-       .enable_ms = apbuart_enable_ms,
        .break_ctl = apbuart_break_ctl,
        .startup = apbuart_startup,
        .shutdown = apbuart_shutdown,
 
        spin_unlock_irqrestore(&up->port.lock, flags);
 }
 
-static void ar933x_uart_enable_ms(struct uart_port *port)
-{
-}
-
 /*
  * baudrate = (clk / (scale + 1)) * (step * (1 / 2^17))
  */
        .stop_tx        = ar933x_uart_stop_tx,
        .start_tx       = ar933x_uart_start_tx,
        .stop_rx        = ar933x_uart_stop_rx,
-       .enable_ms      = ar933x_uart_enable_ms,
        .break_ctl      = ar933x_uart_break_ctl,
        .startup        = ar933x_uart_startup,
        .shutdown       = ar933x_uart_shutdown,
 
        /* MCR not present */
 }
 
-/* Enable Modem Status Interrupts */
-
-static void arc_serial_enable_ms(struct uart_port *port)
-{
-       /* MSR not present */
-}
-
 static void arc_serial_break_ctl(struct uart_port *port, int break_state)
 {
        /* ARC UART doesn't support sending Break signal */
        .stop_tx        = arc_serial_stop_tx,
        .start_tx       = arc_serial_start_tx,
        .stop_rx        = arc_serial_stop_rx,
-       .enable_ms      = arc_serial_enable_ms,
        .break_ctl      = arc_serial_break_ctl,
        .startup        = arc_serial_startup,
        .shutdown       = arc_serial_shutdown,
 
        SSYNC();
 }
 
-static void sport_enable_ms(struct uart_port *port)
-{
-       pr_debug("%s enter\n", __func__);
-}
-
 static void sport_break_ctl(struct uart_port *port, int break_state)
 {
        pr_debug("%s enter\n", __func__);
        .stop_tx        = sport_stop_tx,
        .start_tx       = sport_start_tx,
        .stop_rx        = sport_stop_rx,
-       .enable_ms      = sport_enable_ms,
        .break_ctl      = sport_break_ctl,
        .startup        = sport_startup,
        .shutdown       = sport_shutdown,
 
        UART_CLEAR_IER(uart, ERBFI);
 }
 
-/*
- * Set the modem control timer to fire immediately.
- */
-static void bfin_serial_enable_ms(struct uart_port *port)
-{
-}
-
-
 #if ANOMALY_05000363 && defined(CONFIG_SERIAL_BFIN_PIO)
 # define UART_GET_ANOMALY_THRESHOLD(uart)    ((uart)->anomaly_threshold)
 # define UART_SET_ANOMALY_THRESHOLD(uart, v) ((uart)->anomaly_threshold = (v))
        .stop_tx        = bfin_serial_stop_tx,
        .start_tx       = bfin_serial_start_tx,
        .stop_rx        = bfin_serial_stop_rx,
-       .enable_ms      = bfin_serial_enable_ms,
        .break_ctl      = bfin_serial_break_ctl,
        .startup        = bfin_serial_startup,
        .shutdown       = bfin_serial_shutdown,
 
        .stop_tx        = uart_clps711x_stop_tx,
        .start_tx       = uart_clps711x_start_tx,
        .stop_rx        = uart_clps711x_nop_void,
-       .enable_ms      = uart_clps711x_nop_void,
        .break_ctl      = uart_clps711x_break_ctl,
        .set_ldisc      = uart_clps711x_set_ldisc,
        .startup        = uart_clps711x_startup,
 
                clrbits16(&sccp->scc_sccm, UART_SCCM_RX);
 }
 
-/*
- * Enable Modem status interrupts
- */
-static void cpm_uart_enable_ms(struct uart_port *port)
-{
-       pr_debug("CPM uart[%d]:enable ms\n", port->line);
-}
-
 /*
  * Generate a break.
  */
        .stop_tx        = cpm_uart_stop_tx,
        .start_tx       = cpm_uart_start_tx,
        .stop_rx        = cpm_uart_stop_rx,
-       .enable_ms      = cpm_uart_enable_ms,
        .break_ctl      = cpm_uart_break_ctl,
        .startup        = cpm_uart_startup,
        .shutdown       = cpm_uart_shutdown,
 
        dz_out(dport, DZ_LPR, dport->cflag);
 }
 
-static void dz_enable_ms(struct uart_port *uport)
-{
-       /* nothing to do */
-}
-
 /*
  * ------------------------------------------------------------
  *
        .stop_tx        = dz_stop_tx,
        .start_tx       = dz_start_tx,
        .stop_rx        = dz_stop_rx,
-       .enable_ms      = dz_enable_ms,
        .break_ctl      = dz_break_ctl,
        .startup        = dz_startup,
        .shutdown       = dz_shutdown,
 
        efm32_uart_write32(efm_port, UARTn_CMD_RXDIS, UARTn_CMD);
 }
 
-static void efm32_uart_enable_ms(struct uart_port *port)
-{
-       /* no handshake lines, no modem status interrupts */
-}
-
 static void efm32_uart_break_ctl(struct uart_port *port, int ctl)
 {
        /* not possible without fiddling with gpios */
        .stop_tx = efm32_uart_stop_tx,
        .start_tx = efm32_uart_start_tx,
        .stop_rx = efm32_uart_stop_rx,
-       .enable_ms = efm32_uart_enable_ms,
        .break_ctl = efm32_uart_break_ctl,
        .startup = efm32_uart_startup,
        .shutdown = efm32_uart_shutdown,
 
        writeb(temp & ~UARTCR2_RE, port->membase + UARTCR2);
 }
 
-static void lpuart_enable_ms(struct uart_port *port)
-{
-}
-
 static void lpuart_copy_rx_to_tty(struct lpuart_port *sport,
                struct tty_port *tty, int count)
 {
        .stop_tx        = lpuart_stop_tx,
        .start_tx       = lpuart_start_tx,
        .stop_rx        = lpuart_stop_rx,
-       .enable_ms      = lpuart_enable_ms,
        .break_ctl      = lpuart_break_ctl,
        .startup        = lpuart_startup,
        .shutdown       = lpuart_shutdown,
 
        writeb(cmdReg & ~CMD_RCV_ENABLE, &ICOM_PORT->dram->CmdReg);
 }
 
-static void icom_enable_ms(struct uart_port *port)
-{
-       /* no-op */
-}
-
 static void icom_break(struct uart_port *port, int break_state)
 {
        unsigned char cmdReg;
        .start_tx = icom_start_tx,
        .send_xchar = icom_send_xchar,
        .stop_rx = icom_stop_rx,
-       .enable_ms = icom_enable_ms,
        .break_ctl = icom_break,
        .startup = icom_open,
        .shutdown = icom_close,
 
        .stop_tx = ic3_stop_tx,
        .start_tx = ic3_start_tx,
        .stop_rx = ic3_stop_rx,
-       .enable_ms = null_void_function,
        .break_ctl = ic3_break_ctl,
        .startup = ic3_startup,
        .shutdown = ic3_shutdown,
 
        .stop_tx        = ic4_stop_tx,
        .start_tx       = ic4_start_tx,
        .stop_rx        = null_void_function,
-       .enable_ms      = null_void_function,
        .break_ctl      = ic4_break_ctl,
        .startup        = ic4_startup,
        .shutdown       = ic4_shutdown,
 
        channel->ch_bd->bd_ops->disable_receiver(channel);
 }
 
-static void jsm_tty_enable_ms(struct uart_port *port)
-{
-       /* Nothing needed */
-}
-
 static void jsm_tty_break(struct uart_port *port, int break_state)
 {
        unsigned long lock_flags;
        .start_tx       = jsm_tty_start_tx,
        .send_xchar     = jsm_tty_send_xchar,
        .stop_rx        = jsm_tty_stop_rx,
-       .enable_ms      = jsm_tty_enable_ms,
        .break_ctl      = jsm_tty_break,
        .startup        = jsm_tty_open,
        .shutdown       = jsm_tty_close,
 
        ltq_w32(ASCWHBSTATE_CLRREN, port->membase + LTQ_ASC_WHBSTATE);
 }
 
-static void
-lqasc_enable_ms(struct uart_port *port)
-{
-}
-
 static int
 lqasc_rx_chars(struct uart_port *port)
 {
        .stop_tx =      lqasc_stop_tx,
        .start_tx =     lqasc_start_tx,
        .stop_rx =      lqasc_stop_rx,
-       .enable_ms =    lqasc_enable_ms,
        .break_ctl =    lqasc_break_ctl,
        .startup =      lqasc_startup,
        .shutdown =     lqasc_shutdown,
 
                LPC32XX_HSU_FE_INT), LPC32XX_HSUART_IIR(port->membase));
 }
 
-/* port->lock held by caller.  */
-static void serial_lpc32xx_enable_ms(struct uart_port *port)
-{
-       /* Modem status is not supported */
-}
-
 /* port->lock is not held.  */
 static void serial_lpc32xx_break_ctl(struct uart_port *port,
                                     int break_state)
        .stop_tx        = serial_lpc32xx_stop_tx,
        .start_tx       = serial_lpc32xx_start_tx,
        .stop_rx        = serial_lpc32xx_stop_rx,
-       .enable_ms      = serial_lpc32xx_enable_ms,
        .break_ctl      = serial_lpc32xx_break_ctl,
        .startup        = serial_lpc32xx_startup,
        .shutdown       = serial_lpc32xx_shutdown,
 
        .stop_tx        = max310x_null_void,
        .start_tx       = max310x_start_tx,
        .stop_rx        = max310x_null_void,
-       .enable_ms      = max310x_null_void,
        .break_ctl      = max310x_break_ctl,
        .startup        = max310x_startup,
        .shutdown       = max310x_shutdown,
 
 
 /****************************************************************************/
 
-static void mcf_enable_ms(struct uart_port *port)
-{
-}
-
-/****************************************************************************/
-
 static int mcf_startup(struct uart_port *port)
 {
        struct mcf_uart *pp = container_of(port, struct mcf_uart, port);
        .start_tx       = mcf_start_tx,
        .stop_tx        = mcf_stop_tx,
        .stop_rx        = mcf_stop_rx,
-       .enable_ms      = mcf_enable_ms,
        .break_ctl      = mcf_break_ctl,
        .startup        = mcf_startup,
        .shutdown       = mcf_shutdown,
 
        mpsc_sdma_cmd(pi, SDMA_SDCM_AR);
 }
 
-static void mpsc_enable_ms(struct uart_port *port)
-{
-}
-
 static void mpsc_break_ctl(struct uart_port *port, int ctl)
 {
        struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
        .stop_tx        = mpsc_stop_tx,
        .start_tx       = mpsc_start_tx,
        .stop_rx        = mpsc_stop_rx,
-       .enable_ms      = mpsc_enable_ms,
        .break_ctl      = mpsc_break_ctl,
        .startup        = mpsc_startup,
        .shutdown       = mpsc_shutdown,
 
 {
 }
 
-static void serial_m3110_enable_ms(struct uart_port *port)
-{
-}
-
 static struct uart_ops serial_m3110_ops = {
        .tx_empty       = serial_m3110_tx_empty,
        .set_mctrl      = serial_m3110_set_mctrl,
        .stop_tx        = serial_m3110_stop_tx,
        .start_tx       = serial_m3110_start_tx,
        .stop_rx        = serial_m3110_stop_rx,
-       .enable_ms      = serial_m3110_enable_ms,
        .break_ctl      = serial_m3110_break_ctl,
        .startup        = serial_m3110_startup,
        .shutdown       = serial_m3110_shutdown,
 
 {
 }
 
-/**
- * mux_enable_ms - Enable modum status interrupts.
- * @port: Ptr to the uart_port.
- *
- * The Serial Mux does not support this function.
- */
-static void mux_enable_ms(struct uart_port *port)
-{
-}
-
 /**
  * mux_break_ctl - Control the transmitssion of a break signal.
  * @port: Ptr to the uart_port.
        .stop_tx =              mux_stop_tx,
        .start_tx =             mux_start_tx,
        .stop_rx =              mux_stop_rx,
-       .enable_ms =            mux_enable_ms,
        .break_ctl =            mux_break_ctl,
        .startup =              mux_startup,
        .shutdown =             mux_shutdown,
 
                             u->membase + AUART_LINECTRL_CLR);
 }
 
-static void mxs_auart_enable_ms(struct uart_port *port)
-{
-       /* just empty */
-}
-
 static struct uart_ops mxs_auart_ops = {
        .tx_empty       = mxs_auart_tx_empty,
        .start_tx       = mxs_auart_start_tx,
        .stop_tx        = mxs_auart_stop_tx,
        .stop_rx        = mxs_auart_stop_rx,
-       .enable_ms      = mxs_auart_enable_ms,
        .break_ctl      = mxs_auart_break_ctl,
        .set_mctrl      = mxs_auart_set_mctrl,
        .get_mctrl      = mxs_auart_get_mctrl,
 
        /* N/A */
 }
 
-static void nwpserial_enable_ms(struct uart_port *port)
-{
-       /* N/A */
-}
-
 static void nwpserial_stop_rx(struct uart_port *port)
 {
        struct nwpserial_port *up;
        .stop_tx      = nwpserial_stop_tx,
        .start_tx     = nwpserial_start_tx,
        .stop_rx      = nwpserial_stop_rx,
-       .enable_ms    = nwpserial_enable_ms,
        .break_ctl    = nwpserial_break_ctl,
        .startup      = nwpserial_startup,
        .shutdown     = nwpserial_shutdown,
 
        }
 }
 
-static void s3c24xx_serial_enable_ms(struct uart_port *port)
-{
-}
-
 static inline struct s3c24xx_uart_info *s3c24xx_port_to_info(struct uart_port *port)
 {
        return to_ourport(port)->info;
        .stop_tx        = s3c24xx_serial_stop_tx,
        .start_tx       = s3c24xx_serial_start_tx,
        .stop_rx        = s3c24xx_serial_stop_rx,
-       .enable_ms      = s3c24xx_serial_enable_ms,
        .break_ctl      = s3c24xx_serial_break_ctl,
        .startup        = s3c24xx_serial_startup,
        .shutdown       = s3c24xx_serial_shutdown,
 
        .stop_tx        = sc16is7xx_stop_tx,
        .start_tx       = sc16is7xx_start_tx,
        .stop_rx        = sc16is7xx_stop_rx,
-       .enable_ms      = sc16is7xx_null_void,
        .break_ctl      = sc16is7xx_break_ctl,
        .startup        = sc16is7xx_startup,
        .shutdown       = sc16is7xx_shutdown,
 
        return (val & SR_TXEMT) ? TIOCSER_TEMT : 0;
 }
 
-static void sccnxp_enable_ms(struct uart_port *port)
-{
-       /* Do nothing */
-}
-
 static void sccnxp_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
        struct sccnxp_port *s = dev_get_drvdata(port->dev);
        .stop_tx        = sccnxp_stop_tx,
        .start_tx       = sccnxp_start_tx,
        .stop_rx        = sccnxp_stop_rx,
-       .enable_ms      = sccnxp_enable_ms,
        .break_ctl      = sccnxp_break_ctl,
        .startup        = sccnxp_startup,
        .shutdown       = sccnxp_shutdown,
 
        up->port.read_status_mask &= ~TXX9_SIDISR_RDIS;
 }
 
-static void serial_txx9_enable_ms(struct uart_port *port)
-{
-       /* TXX9-SIO can not control DTR... */
-}
-
 static void serial_txx9_initialize(struct uart_port *port)
 {
        struct uart_txx9_port *up = to_uart_txx9_port(port);
        .stop_tx        = serial_txx9_stop_tx,
        .start_tx       = serial_txx9_start_tx,
        .stop_rx        = serial_txx9_stop_rx,
-       .enable_ms      = serial_txx9_enable_ms,
        .break_ctl      = serial_txx9_break_ctl,
        .startup        = serial_txx9_startup,
        .shutdown       = serial_txx9_shutdown,
 
        serial_port_out(port, SCSCR, ctrl);
 }
 
-static void sci_enable_ms(struct uart_port *port)
-{
-       /*
-        * Not supported by hardware, always a nop.
-        */
-}
-
 static void sci_break_ctl(struct uart_port *port, int break_state)
 {
        struct sci_port *s = to_sci_port(port);
        .start_tx       = sci_start_tx,
        .stop_tx        = sci_stop_tx,
        .stop_rx        = sci_stop_rx,
-       .enable_ms      = sci_enable_ms,
        .break_ctl      = sci_break_ctl,
        .startup        = sci_startup,
        .shutdown       = sci_shutdown,
 
 {
 }
 
-/**
- * snp_enable_ms - Force modem status interrupts on - no-op for us
- * @port: Port to operate on - we ignore - no-op function
- *
- */
-static void snp_enable_ms(struct uart_port *port)
-{
-}
-
 /**
  * snp_shutdown - shut down the port - free irq and disable - no-op for us
  * @port: Port to shut down - we ignore
        .stop_tx = snp_stop_tx,
        .start_tx = snp_start_tx,
        .stop_rx = snp_stop_rx,
-       .enable_ms = snp_enable_ms,
        .break_ctl = snp_break_ctl,
        .startup = snp_startup,
        .shutdown = snp_shutdown,
 
        asc_disable_rx_interrupts(port);
 }
 
-/* Force modem status interrupts on */
-static void asc_enable_ms(struct uart_port *port)
-{
-       /* Nothing here yet .. */
-}
-
 /* Handle breaks - ignored by us */
 static void asc_break_ctl(struct uart_port *port, int break_state)
 {
        .start_tx       = asc_start_tx,
        .stop_tx        = asc_stop_tx,
        .stop_rx        = asc_stop_rx,
-       .enable_ms      = asc_enable_ms,
        .break_ctl      = asc_break_ctl,
        .startup        = asc_startup,
        .shutdown       = asc_shutdown,
 
 {
 }
 
-/* port->lock held by caller.  */
-static void sunhv_enable_ms(struct uart_port *port)
-{
-}
-
 /* port->lock is not held.  */
 static void sunhv_break_ctl(struct uart_port *port, int break_state)
 {
        .start_tx       = sunhv_start_tx,
        .send_xchar     = sunhv_send_xchar,
        .stop_rx        = sunhv_stop_rx,
-       .enable_ms      = sunhv_enable_ms,
        .break_ctl      = sunhv_break_ctl,
        .startup        = sunhv_startup,
        .shutdown       = sunhv_shutdown,
 
        writeb(up->interrupt_mask1, &up->regs->w.imr0);
 }
 
-/* port->lock held by caller.  */
-static void sunsab_enable_ms(struct uart_port *port)
-{
-       /* For now we always receive these interrupts.  */
-}
-
 /* port->lock is not held.  */
 static void sunsab_break_ctl(struct uart_port *port, int break_state)
 {
        .start_tx       = sunsab_start_tx,
        .send_xchar     = sunsab_send_xchar,
        .stop_rx        = sunsab_stop_rx,
-       .enable_ms      = sunsab_enable_ms,
        .break_ctl      = sunsab_break_ctl,
        .startup        = sunsab_startup,
        .shutdown       = sunsab_shutdown,
 
        mutex_unlock(&tile_uart->mutex);
 }
 
-
-/*
- * Enable modem status interrupts.
- */
-static void tilegx_enable_ms(struct uart_port *port)
-{
-       /* N/A */
-}
-
 /*
  * Control the transmission of a break signal.
  */
        .stop_tx        = tilegx_stop_tx,
        .start_tx       = tilegx_start_tx,
        .stop_rx        = tilegx_stop_rx,
-       .enable_ms      = tilegx_enable_ms,
        .break_ctl      = tilegx_break_ctl,
        .startup        = tilegx_startup,
        .shutdown       = tilegx_shutdown,
 
        *ier |= CTS_DELTA;
 }
 
-static void timbuart_enable_ms(struct uart_port *port)
-{
-       /* N/A */
-}
-
 static void timbuart_break_ctl(struct uart_port *port, int ctl)
 {
        /* N/A */
        .start_tx = timbuart_start_tx,
        .flush_buffer = timbuart_flush_buffer,
        .stop_rx = timbuart_stop_rx,
-       .enable_ms = timbuart_enable_ms,
        .break_ctl = timbuart_break_ctl,
        .startup = timbuart_startup,
        .shutdown = timbuart_shutdown,
 
                | ULITE_STATUS_FRAME | ULITE_STATUS_OVERRUN;
 }
 
-static void ulite_enable_ms(struct uart_port *port)
-{
-       /* N/A */
-}
-
 static void ulite_break_ctl(struct uart_port *port, int ctl)
 {
        /* N/A */
        .stop_tx        = ulite_stop_tx,
        .start_tx       = ulite_start_tx,
        .stop_rx        = ulite_stop_rx,
-       .enable_ms      = ulite_enable_ms,
        .break_ctl      = ulite_break_ctl,
        .startup        = ulite_startup,
        .shutdown       = ulite_shutdown,
 
        clrbits16(&qe_port->uccp->uccm, UCC_UART_UCCE_RX);
 }
 
-/*
- * Enable status change interrupts
- *
- * We don't support status change interrupts, but we need to define this
- * function otherwise the kernel will panic.
- */
-static void qe_uart_enable_ms(struct uart_port *port)
-{
-}
-
 /* Start or stop sending  break signal
  *
  * This function controls the sending of a break signal.  If break_state=1,
        .stop_tx        = qe_uart_stop_tx,
        .start_tx       = qe_uart_start_tx,
        .stop_rx        = qe_uart_stop_rx,
-       .enable_ms      = qe_uart_enable_ms,
        .break_ctl      = qe_uart_break_ctl,
        .startup        = qe_uart_startup,
        .shutdown       = qe_uart_shutdown,
 
        /* N/A */
 }
 
-static void cdns_uart_enable_ms(struct uart_port *port)
-{
-       /* N/A */
-}
-
 #ifdef CONFIG_CONSOLE_POLL
 static int cdns_uart_poll_get_char(struct uart_port *port)
 {
 static struct uart_ops cdns_uart_ops = {
        .set_mctrl      = cdns_uart_set_mctrl,
        .get_mctrl      = cdns_uart_get_mctrl,
-       .enable_ms      = cdns_uart_enable_ms,
        .start_tx       = cdns_uart_start_tx,
        .stop_tx        = cdns_uart_stop_tx,
        .stop_rx        = cdns_uart_stop_rx,