static irqreturn_t serial21285_rx_chars(int irq, void *dev_id)
 {
        struct uart_port *port = dev_id;
-       struct tty_struct *tty = port->info->tty;
+       struct tty_struct *tty = port->info->port.tty;
        unsigned int status, ch, flag, rxs, max_count = 256;
 
        status = *CSR_UARTFLG;
        baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16); 
        quot = uart_get_divisor(port, baud);
 
-       if (port->info && port->info->tty) {
-               struct tty_struct *tty = port->info->tty;
+       if (port->info && port->info->port.tty) {
+               struct tty_struct *tty = port->info->port.tty;
                unsigned int b = port->uartclk / (16 * quot);
                tty_encode_baud_rate(tty, b, b);
        }
 
 {
 #if 0
        if(status & DCD) {
-               if((info->tty->termios->c_cflag & CRTSCTS) &&
+               if((info->port.tty->termios->c_cflag & CRTSCTS) &&
                   ((info->curregs[3] & AUTO_ENAB)==0)) {
                        info->curregs[3] |= AUTO_ENAB;
                        info->pendregs[3] |= AUTO_ENAB;
 
 static void receive_chars(struct m68k_serial *info, unsigned short rx)
 {
-       struct tty_struct *tty = info->tty;
+       struct tty_struct *tty = info->port.tty;
        m68328_uart *uart = &uart_addr[info->line];
        unsigned char ch, flag;
 
                goto clear_and_return;
        }
 
-       if((info->xmit_cnt <= 0) || info->tty->stopped) {
+       if((info->xmit_cnt <= 0) || info->port.tty->stopped) {
                /* That's peculiar... TX ints off */
                uart->ustcnt &= ~USTCNT_TX_INTR_MASK;
                goto clear_and_return;
        struct m68k_serial      *info = container_of(work, struct m68k_serial, tqueue);
        struct tty_struct       *tty;
        
-       tty = info->tty;
+       tty = info->port.tty;
        if (!tty)
                return;
 #if 0
        struct m68k_serial      *info = container_of(work, struct m68k_serial, tqueue_hangup);
        struct tty_struct       *tty;
        
-       tty = info->tty;
+       tty = info->port.tty;
        if (!tty)
                return;
 
        uart->ustcnt = USTCNT_UEN | USTCNT_RXEN | USTCNT_RX_INTR_MASK;
 #endif
 
-       if (info->tty)
-               clear_bit(TTY_IO_ERROR, &info->tty->flags);
+       if (info->port.tty)
+               clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
        info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
 
        /*
                info->xmit_buf = 0;
        }
 
-       if (info->tty)
-               set_bit(TTY_IO_ERROR, &info->tty->flags);
+       if (info->port.tty)
+               set_bit(TTY_IO_ERROR, &info->port.tty->flags);
        
        info->flags &= ~S_INITIALIZED;
        local_irq_restore(flags);
        unsigned cflag;
        int     i;
 
-       if (!info->tty || !info->tty->termios)
+       if (!info->port.tty || !info->port.tty->termios)
                return;
-       cflag = info->tty->termios->c_cflag;
+       cflag = info->port.tty->termios->c_cflag;
        if (!(port = info->port))
                return;
 
        tty_ldisc_flush(tty);
        tty->closing = 0;
        info->event = 0;
-       info->tty = 0;
+       info->port.tty = NULL;
 #warning "This is not and has never been valid so fix it"      
 #if 0
        if (tty->ldisc.num != ldiscs[N_TTY].num) {
        info->event = 0;
        info->count = 0;
        info->flags &= ~S_NORMAL_ACTIVE;
-       info->tty = 0;
+       info->port.tty = NULL;
        wake_up_interruptible(&info->open_wait);
 }
 
 
        info->count++;
        tty->driver_data = info;
-       info->tty = tty;
+       info->port.tty = tty;
 
        /*
         * Start up serial port
            info = &m68k_soft[i];
            info->magic = SERIAL_MAGIC;
            info->port = (int) &uart_addr[i];
-           info->tty = 0;
+           info->port.tty = NULL;
            info->irq = uart_irqs[i];
            info->custom_divisor = 16;
            info->close_delay = 50;
 
 
 static _INLINE_ void receive_chars(ser_info_t *info)
 {
-       struct tty_struct *tty = info->tty;
+       struct tty_struct *tty = info->port.tty;
        unsigned char ch, flag, *cp;
        /*int   ignored = 0;*/
        int     i;
 
 static _INLINE_ void receive_break(ser_info_t *info)
 {
-       struct tty_struct *tty = info->tty;
+       struct tty_struct *tty = info->port.tty;
 
        info->state->icount.brk++;
        /* Check to see if there is room in the tty buffer for
 {
 
        if ((info->flags & TX_WAKEUP) ||
-           (info->tty->flags & (1 << TTY_DO_WRITE_WAKEUP))) {
+           (info->port.tty->flags & (1 << TTY_DO_WRITE_WAKEUP))) {
                schedule_work(&info->tqueue);
        }
 
                }
        }
        if (info->flags & ASYNC_CTS_FLOW) {
-               if (info->tty->hw_stopped) {
+               if (info->port.tty->hw_stopped) {
                        if (status & UART_MSR_CTS) {
 #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
                                printk("CTS tx start...");
 #endif
-                               info->tty->hw_stopped = 0;
+                               info->port.tty->hw_stopped = 0;
                                info->IER |= UART_IER_THRI;
                                serial_out(info, UART_IER, info->IER);
                                rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
 #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
                                printk("CTS tx stop...");
 #endif
-                               info->tty->hw_stopped = 1;
+                               info->port.tty->hw_stopped = 1;
                                info->IER &= ~UART_IER_THRI;
                                serial_out(info, UART_IER, info->IER);
                        }
        ser_info_t      *info = (ser_info_t *) private_;
        struct tty_struct       *tty;
        
-       tty = info->tty;
+       tty = info->port.tty;
        if (!tty)
                return;
 
        struct async_struct     *info = (struct async_struct *) private_;
        struct tty_struct       *tty;
        
-       tty = info->tty;
+       tty = info->port.tty;
        if (!tty)
                return;
 
 
 #ifdef maybe
        if (!state->port || !state->type) {
-               if (info->tty)
-                       set_bit(TTY_IO_ERROR, &info->tty->flags);
+               if (info->port.tty)
+                       set_bit(TTY_IO_ERROR, &info->port.tty->flags);
                goto errout;
        }
 #endif
 
 #ifdef modem_control
        info->MCR = 0;
-       if (info->tty->termios->c_cflag & CBAUD)
+       if (info->port.tty->termios->c_cflag & CBAUD)
                info->MCR = UART_MCR_DTR | UART_MCR_RTS;
 #endif
        
-       if (info->tty)
-               clear_bit(TTY_IO_ERROR, &info->tty->flags);
+       if (info->port.tty)
+               clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
 
        /*
         * and set the speed of the serial port
                        smcp->smc_smcmr &= ~(SMCMR_REN | SMCMR_TEN);
        }
        
-       if (info->tty)
-               set_bit(TTY_IO_ERROR, &info->tty->flags);
+       if (info->port.tty)
+               set_bit(TTY_IO_ERROR, &info->port.tty->flags);
 
        info->flags &= ~ASYNC_INITIALIZED;
        local_irq_restore(flags);
        volatile struct smc_regs        *smcp;
        volatile struct scc_regs        *sccp;
 
-       if (!info->tty || !info->tty->termios)
+       if (!info->port.tty || !info->port.tty->termios)
                return;
-       cflag = info->tty->termios->c_cflag;
+       cflag = info->port.tty->termios->c_cflag;
 
        state = info->state;
 
         * Set up parity check flag
         */
        info->read_status_mask = (BD_SC_EMPTY | BD_SC_OV);
-       if (I_INPCK(info->tty))
+       if (I_INPCK(info->port.tty))
                info->read_status_mask |= BD_SC_FR | BD_SC_PR;
-       if (I_BRKINT(info->tty) || I_PARMRK(info->tty))
+       if (I_BRKINT(info->port.tty) || I_PARMRK(info->port.tty))
                info->read_status_mask |= BD_SC_BR;
        
        /*
         * Characters to ignore
         */
        info->ignore_status_mask = 0;
-       if (I_IGNPAR(info->tty))
+       if (I_IGNPAR(info->port.tty))
                info->ignore_status_mask |= BD_SC_PR | BD_SC_FR;
-       if (I_IGNBRK(info->tty)) {
+       if (I_IGNBRK(info->port.tty)) {
                info->ignore_status_mask |= BD_SC_BR;
                /*
                 * If we're ignore parity and break indicators, ignore 
                 * overruns too.  (For real raw support).
                 */
-               if (I_IGNPAR(info->tty))
+               if (I_IGNPAR(info->port.tty))
                        info->ignore_status_mask |= BD_SC_OV;
        }
        /*
        tty_ldisc_flush(tty);           
        tty->closing = 0;
        info->event = 0;
-       info->tty = 0;
+       info->port.tty = NULL;
        if (info->blocked_open) {
                if (info->close_delay) {
                        msleep_interruptible(jiffies_to_msecs(info->close_delay));
        info->event = 0;
        state->count = 0;
        info->flags &= ~ASYNC_NORMAL_ACTIVE;
-       info->tty = 0;
+       info->port.tty = NULL;
        wake_up_interruptible(&info->open_wait);
 }
 
        printk("rs_open %s, count = %d\n", tty->name, info->state->count);
 #endif
        tty->driver_data = info;
-       info->tty = tty;
+       info->port.tty = tty;
 
        /*
         * Start up serial port
                info->port = state->port;
                info->flags = state->flags;
                info->quot = 0;
-               info->tty = 0;
+               info->port.tty = NULL;
        }
        local_irq_disable();
        status = serial_in(info, UART_MSR);
 
 
 static void pl010_rx_chars(struct uart_amba_port *uap)
 {
-       struct tty_struct *tty = uap->port.info->tty;
+       struct tty_struct *tty = uap->port.info->port.tty;
        unsigned int status, ch, flag, rsr, max_count = 256;
 
        status = readb(uap->port.membase + UART01x_FR);
 
 
 static void pl011_rx_chars(struct uart_amba_port *uap)
 {
-       struct tty_struct *tty = uap->port.info->tty;
+       struct tty_struct *tty = uap->port.info->port.tty;
        unsigned int status, ch, flag, max_count = 256;
 
        status = readw(uap->port.membase + UART01x_FR);
 
 #ifdef CONFIG_SERIAL_BFIN_PIO
 static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
 {
-       struct tty_struct *tty = uart->port.info->tty;
+       struct tty_struct *tty = uart->port.info->port.tty;
        unsigned int status, ch, flg;
        static struct timeval anomaly_start = { .tv_sec = 0 };
 
 
 static void bfin_serial_dma_rx_chars(struct bfin_serial_port *uart)
 {
-       struct tty_struct *tty = uart->port.info->tty;
+       struct tty_struct *tty = uart->port.info->port.tty;
        int i, flg, status;
 
        status = UART_GET_LSR(uart);
 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
        unsigned int status;
        struct uart_info *info = uart->port.info;
-       struct tty_struct *tty = info->tty;
+       struct tty_struct *tty = info->port.tty;
 
        status = bfin_serial_get_mctrl(&uart->port);
        uart_handle_cts_change(&uart->port, status & TIOCM_CTS);
        int line = port->line;
        unsigned short val;
 
-       if (line >= port->info->tty->driver->num)
+       if (line >= port->info->port.tty->driver->num)
                return;
 
-       switch (port->info->tty->ldisc.num) {
+       switch (port->info->port.tty->ldisc.num) {
        case N_IRDA:
                val = UART_GET_GCTL(&bfin_serial_ports[line]);
                val |= (IREN | RPOLC);
 
 static irqreturn_t sport_uart_rx_irq(int irq, void *dev_id)
 {
        struct sport_uart_port *up = dev_id;
-       struct tty_struct *tty = up->port.info->tty;
+       struct tty_struct *tty = up->port.info->port.tty;
        unsigned int ch;
 
        do {
 static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
 {
        struct sport_uart_port *up = dev_id;
-       struct tty_struct *tty = up->port.info->tty;
+       struct tty_struct *tty = up->port.info->port.tty;
        unsigned int stat = SPORT_GET_STAT(up);
 
        /* Overflow in RX FIFO */
 
 static irqreturn_t clps711xuart_int_rx(int irq, void *dev_id)
 {
        struct uart_port *port = dev_id;
-       struct tty_struct *tty = port->info->tty;
+       struct tty_struct *tty = port->info->port.tty;
        unsigned int status, ch, flg;
 
        status = clps_readl(SYSFLG(port));
 
 /* Calculate the chartime depending on baudrate, numbor of bits etc. */
 static void update_char_time(struct e100_serial * info)
 {
-       tcflag_t cflags = info->tty->termios->c_cflag;
+       tcflag_t cflags = info->port.tty->termios->c_cflag;
        int bits;
 
        /* calc. number of bits / data byte */
                                CIRC_CNT(info->xmit.head,
                                         info->xmit.tail,SERIAL_XMIT_SIZE)));
 
-               xoff = IO_FIELD(R_SERIAL0_XOFF, xoff_char, STOP_CHAR(info->tty));
+               xoff = IO_FIELD(R_SERIAL0_XOFF, xoff_char,
+                               STOP_CHAR(info->port.tty));
                xoff |= IO_STATE(R_SERIAL0_XOFF, tx_stop, stop);
                if (tty->termios->c_iflag & IXON ) {
                        xoff |= IO_STATE(R_SERIAL0_XOFF, auto_xoff, enable);
 
                info->icount.rx++;
        } else {
-               struct tty_struct *tty = info->tty;
+               struct tty_struct *tty = info->port.tty;
                tty_insert_flip_char(tty, data, flag);
                info->icount.rx++;
        }
                descr->status = 0;
 
                DFLOW(  DEBUG_LOG(info->line, "RX %lu\n", recvl);
-                       if (info->tty->stopped) {
+                       if (info->port.tty->stopped) {
                                unsigned char *buf = phys_to_virt(descr->buf);
                                DEBUG_LOG(info->line, "rx 0x%02X\n", buf[0]);
                                DEBUG_LOG(info->line, "rx 0x%02X\n", buf[1]);
                IO_STATE(R_DMA_CH6_CLR_INTR, clr_descr, do) |
                IO_STATE(R_DMA_CH6_CLR_INTR, clr_eop, do);
 
-       tty = info->tty;
+       tty = info->port.tty;
        if (!tty) /* Something wrong... */
                return;
 
        unsigned long flags;
 
        local_irq_save(flags);
-       tty = info->tty;
+       tty = info->port.tty;
 
        if (!tty) {
                local_irq_restore(flags);
 struct e100_serial * handle_ser_rx_interrupt_no_dma(struct e100_serial *info)
 {
        unsigned long data_read;
-       struct tty_struct *tty = info->tty;
+       struct tty_struct *tty = info->port.tty;
 
        if (!tty) {
                printk("!NO TTY!\n");
                                        data_in, data_read);
                                char flag = TTY_NORMAL;
                                if (info->errorcode == ERRCODE_INSERT_BREAK) {
-                                       struct tty_struct *tty = info->tty;
+                                       struct tty_struct *tty = info->port.tty;
                                        tty_insert_flip_char(tty, 0, flag);
                                        info->icount.rx++;
                                }
                goto more_data;
        }
 
-       tty_flip_buffer_push(info->tty);
+       tty_flip_buffer_push(info->port.tty);
        return info;
 }
 
                rstat = info->port[REG_STATUS];
                DFLOW(DEBUG_LOG(info->line, "stat %x\n", rstat));
                e100_disable_serial_tx_ready_irq(info);
-               if (info->tty->stopped)
-                       rs_stop(info->tty);
+               if (info->port.tty->stopped)
+                       rs_stop(info->port.tty);
                /* Enable the DMA channel and tell it to continue */
                e100_enable_txdma_channel(info);
                /* Wait 12 cycles before doing the DMA command */
        }
        /* Normal char-by-char interrupt */
        if (info->xmit.head == info->xmit.tail
-           || info->tty->stopped
-           || info->tty->hw_stopped) {
-               DFLOW(DEBUG_LOG(info->line, "tx_int: stopped %i\n", info->tty->stopped));
+           || info->port.tty->stopped
+           || info->port.tty->hw_stopped) {
+               DFLOW(DEBUG_LOG(info->line, "tx_int: stopped %i\n",
+                               info->port.tty->stopped));
                e100_disable_serial_tx_ready_irq(info);
                info->tr_running = 0;
                return;
 
        info = container_of(work, struct e100_serial, work);
 
-       tty = info->tty;
+       tty = info->port.tty;
        if (!tty)
                return;
 
        /* Bits and pieces collected from below.  Better to have them
           in one ifdef:ed clause than to mix in a lot of ifdefs,
           right? */
-       if (info->tty)
-               clear_bit(TTY_IO_ERROR, &info->tty->flags);
+       if (info->port.tty)
+               clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
 
        info->xmit.head = info->xmit.tail = 0;
        info->first_recv_buffer = info->last_recv_buffer = NULL;
                e100_disable_txdma_channel(info);
        }
 
-       if (info->tty)
-               clear_bit(TTY_IO_ERROR, &info->tty->flags);
+       if (info->port.tty)
+               clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
 
        info->xmit.head = info->xmit.tail = 0;
        info->first_recv_buffer = info->last_recv_buffer = NULL;
                        descr[i].buf = 0;
                }
 
-       if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
+       if (!info->port.tty || (info->port.tty->termios->c_cflag & HUPCL)) {
                /* hang up DTR and RTS if HUPCL is enabled */
                e100_dtr(info, 0);
                e100_rts(info, 0); /* could check CRTSCTS before doing this */
        }
 
-       if (info->tty)
-               set_bit(TTY_IO_ERROR, &info->tty->flags);
+       if (info->port.tty)
+               set_bit(TTY_IO_ERROR, &info->port.tty->flags);
 
        info->flags &= ~ASYNC_INITIALIZED;
        local_irq_restore(flags);
        unsigned long flags;
        /* first some safety checks */
 
-       if (!info->tty || !info->tty->termios)
+       if (!info->port.tty || !info->port.tty->termios)
                return;
        if (!info->port)
                return;
 
-       cflag = info->tty->termios->c_cflag;
+       cflag = info->port.tty->termios->c_cflag;
 
        /* possibly, the tx/rx should be disabled first to do this safely */
 
 
        info->port[REG_TR_CTRL] = info->tx_ctrl;
        info->port[REG_REC_CTRL] = info->rx_ctrl;
-       xoff = IO_FIELD(R_SERIAL0_XOFF, xoff_char, STOP_CHAR(info->tty));
+       xoff = IO_FIELD(R_SERIAL0_XOFF, xoff_char, STOP_CHAR(info->port.tty));
        xoff |= IO_STATE(R_SERIAL0_XOFF, tx_stop, enable);
-       if (info->tty->termios->c_iflag & IXON ) {
-               DFLOW(DEBUG_LOG(info->line, "FLOW XOFF enabled 0x%02X\n", STOP_CHAR(info->tty)));
+       if (info->port.tty->termios->c_iflag & IXON ) {
+               DFLOW(DEBUG_LOG(info->line, "FLOW XOFF enabled 0x%02X\n",
+                               STOP_CHAR(info->port.tty)));
                xoff |= IO_STATE(R_SERIAL0_XOFF, auto_xoff, enable);
        }
 
        info->type = new_serial.type;
        info->close_delay = new_serial.close_delay;
        info->closing_wait = new_serial.closing_wait;
-       info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+       info->port.tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
  check_and_exit:
        if (info->flags & ASYNC_INITIALIZED) {
        tty_ldisc_flush(tty);
        tty->closing = 0;
        info->event = 0;
-       info->tty = 0;
+       info->port.tty = NULL;
        if (info->blocked_open) {
                if (info->close_delay)
                        schedule_timeout_interruptible(info->close_delay);
        info->event = 0;
        info->count = 0;
        info->flags &= ~ASYNC_NORMAL_ACTIVE;
-       info->tty = 0;
+       info->port.tty = NULL;
        wake_up_interruptible(&info->open_wait);
 }
 
 
        info->count++;
        tty->driver_data = info;
-       info->tty = tty;
+       info->port.tty = tty;
 
-       info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+       info->port.tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
        if (!tmp_buf) {
                page = get_zeroed_page(GFP_KERNEL);
                       (unsigned long)info->max_recv_cnt);
 
 #if 1
-       if (info->tty) {
+       if (info->port.tty) {
 
-               if (info->tty->stopped)
+               if (info->port.tty->stopped)
                        ret += sprintf(buf+ret, " stopped:%i",
-                                      (int)info->tty->stopped);
-               if (info->tty->hw_stopped)
+                                      (int)info->port.tty->stopped);
+               if (info->port.tty->hw_stopped)
                        ret += sprintf(buf+ret, " hw_stopped:%i",
-                                      (int)info->tty->hw_stopped);
+                                      (int)info->port.tty->hw_stopped);
        }
 
        {
                info->uses_dma_in = 0;
                info->uses_dma_out = 0;
                info->line = i;
-               info->tty = 0;
+               info->port.tty = NULL;
                info->type = PORT_ETRAX;
                info->tr_running = 0;
                info->forced_eop = 0;
 
        while ((status = dz_in(dport, DZ_RBUF)) & DZ_DVAL) {
                dport = &mux->dport[LINE(status)];
                uport = &dport->port;
-               tty = uport->info->tty;         /* point to the proper dev */
+               tty = uport->info->port.tty;    /* point to the proper dev */
 
                ch = UCHAR(status);             /* grab the char */
                flag = TTY_NORMAL;
        }
        for (i = 0; i < DZ_NB_PORT; i++)
                if (lines_rx[i])
-                       tty_flip_buffer_push(mux->dport[i].port.info->tty);
+                       tty_flip_buffer_push(mux->dport[i].port.info->port.tty);
 }
 
 /*
 
 {
        struct imx_port *sport = dev_id;
        unsigned int rx,flg,ignored = 0;
-       struct tty_struct *tty = sport->port.info->tty;
+       struct tty_struct *tty = sport->port.info->port.tty;
        unsigned long flags, temp;
 
        spin_lock_irqsave(&sport->port.lock,flags);
 
                return;
 
        info = the_port->info;
-       tty = info->tty;
+       tty = info->port.tty;
 
        if (uart_circ_empty(&info->xmit) || uart_tx_stopped(the_port)) {
                /* Nothing to do or hw stopped */
 
        the_port->ignore_status_mask = N_ALL_INPUT;
 
-       info->tty->low_latency = 1;
+       info->port.tty->low_latency = 1;
 
-       if (I_IGNPAR(info->tty))
+       if (I_IGNPAR(info->port.tty))
                the_port->ignore_status_mask &= ~(N_PARITY_ERROR
                                                | N_FRAMING_ERROR);
-       if (I_IGNBRK(info->tty)) {
+       if (I_IGNBRK(info->port.tty)) {
                the_port->ignore_status_mask &= ~N_BREAK;
-               if (I_IGNPAR(info->tty))
+               if (I_IGNPAR(info->port.tty))
                        the_port->ignore_status_mask &= ~N_OVERRUN_ERROR;
        }
        if (!(cflag & CREAD)) {
        ioc4_set_proto(port, the_port->mapbase);
 
        /* set the speed of the serial port */
-       ioc4_change_speed(the_port, info->tty->termios, (struct ktermios *)0);
+       ioc4_change_speed(the_port, info->port.tty->termios,
+                         (struct ktermios *)0);
 
        return 0;
 }
        /* Make sure all the pointers are "good" ones */
        if (!info)
                return;
-       if (!info->tty)
+       if (!info->port.tty)
                return;
 
        spin_lock_irqsave(&the_port->lock, pflags);
-       tty = info->tty;
+       tty = info->port.tty;
 
        request_count = tty_buffer_request_room(tty, IOC4_MAX_CHARS);
 
 
        wake_up_interruptible(&info->delta_msr_wait);
 
-       if (info->tty)
-               set_bit(TTY_IO_ERROR, &info->tty->flags);
+       if (info->port.tty)
+               set_bit(TTY_IO_ERROR, &info->port.tty->flags);
 
        spin_lock_irqsave(&the_port->lock, port_flags);
        set_notification(port, N_ALL, 0);
 
 
        tty = NULL;
        if (up->port.info != NULL &&
-           up->port.info->tty != NULL)
-               tty = up->port.info->tty;
+           up->port.info->port.tty != NULL)
+               tty = up->port.info->port.tty;
 
        for (;;) {
                ch = readb(&channel->control);
 
 
 static void receive_chars(struct uart_sio_port *up, int *status)
 {
-       struct tty_struct *tty = up->port.info->tty;
+       struct tty_struct *tty = up->port.info->port.tty;
        unsigned char ch;
        unsigned char flag;
        int max_count = 256;
 
                uart_insert_char(port, status, MCFUART_USR_RXOVERRUN, ch, flag);
        }
 
-       tty_flip_buffer_push(port->info->tty);
+       tty_flip_buffer_push(port->info->port.tty);
 }
 
 /****************************************************************************/
 
 static inline void receive_chars(struct mcf_serial *info)
 {
        volatile unsigned char  *uartp;
-       struct tty_struct       *tty = info->tty;
+       struct tty_struct       *tty = info->port.tty;
        unsigned char           status, ch, flag;
 
        if (!tty)
                info->stats.tx++;
        }
 
-       if ((info->xmit_cnt <= 0) || info->tty->stopped) {
+       if ((info->xmit_cnt <= 0) || info->port.tty->stopped) {
                info->imr &= ~MCFUART_UIR_TXREADY;
                uartp[MCFUART_UIMR] = info->imr;
                return;
 static void mcfrs_offintr(struct work_struct *work)
 {
        struct mcf_serial *info = container_of(work, struct mcf_serial, tqueue);
-       struct tty_struct *tty = info->tty;
+       struct tty_struct *tty = info->port.tty;
        
        if (tty)
                tty_wakeup(tty);
 static void do_serial_hangup(struct work_struct *work)
 {
        struct mcf_serial *info = container_of(work, struct mcf_serial, tqueue_hangup);
-       struct tty_struct *tty = info->tty;
+       struct tty_struct *tty = info->port.tty;
        
        if (tty)
                tty_hangup(tty);
        uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETTX;  /* reset TX */
        mcfrs_setsignals(info, 1, 1);
 
-       if (info->tty)
-               clear_bit(TTY_IO_ERROR, &info->tty->flags);
+       if (info->port.tty)
+               clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
        info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
 
        /*
        uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETRX;  /* reset RX */
        uartp[MCFUART_UCR] = MCFUART_UCR_CMDRESETTX;  /* reset TX */
 
-       if (!info->tty || (info->tty->termios->c_cflag & HUPCL))
+       if (!info->port.tty || (info->port.tty->termios->c_cflag & HUPCL))
                mcfrs_setsignals(info, 0, 0);
 
        if (info->xmit_buf) {
                info->xmit_buf = 0;
        }
 
-       if (info->tty)
-               set_bit(TTY_IO_ERROR, &info->tty->flags);
+       if (info->port.tty)
+               set_bit(TTY_IO_ERROR, &info->port.tty->flags);
        
        info->flags &= ~ASYNC_INITIALIZED;
        local_irq_restore(flags);
        unsigned int            fraction;
 #endif
 
-       if (!info->tty || !info->tty->termios)
+       if (!info->port.tty || !info->port.tty->termios)
                return;
-       cflag = info->tty->termios->c_cflag;
+       cflag = info->port.tty->termios->c_cflag;
        if (info->addr == 0)
                return;
 
        if (i & CBAUDEX) {
                i &= ~CBAUDEX;
                if (i < 1 || i > 4)
-                       info->tty->termios->c_cflag &= ~CBAUDEX;
+                       info->port.tty->termios->c_cflag &= ~CBAUDEX;
                else
                        i += 15;
        }
        
        tty->closing = 0;
        info->event = 0;
-       info->tty = 0;
+       info->port.tty = NULL;
 #if 0  
        if (tty->ldisc.num != ldiscs[N_TTY].num) {
                if (tty->ldisc.close)
        info->event = 0;
        info->count = 0;
        info->flags &= ~ASYNC_NORMAL_ACTIVE;
-       info->tty = 0;
+       info->port.tty = NULL;
        wake_up_interruptible(&info->open_wait);
 }
 
 #endif
        info->count++;
        tty->driver_data = info;
-       info->tty = tty;
+       info->port.tty = tty;
 
        /*
         * Start up serial port
        for (i = 0, info = mcfrs_table; (i < NR_PORTS); i++, info++) {
                info->magic = SERIAL_MAGIC;
                info->line = i;
-               info->tty = 0;
+               info->port.tty = NULL;
                info->custom_divisor = 16;
                info->close_delay = 50;
                info->closing_wait = 3000;
 
 static inline int
 mpc52xx_uart_int_rx_chars(struct uart_port *port)
 {
-       struct tty_struct *tty = port->info->tty;
+       struct tty_struct *tty = port->info->port.tty;
        unsigned char ch, flag;
        unsigned short status;
 
 
 static int mpsc_rx_intr(struct mpsc_port_info *pi)
 {
        struct mpsc_rx_desc *rxre;
-       struct tty_struct *tty = pi->port.info->tty;
+       struct tty_struct *tty = pi->port.info->port.tty;
        u32     cmdstat, bytes_in, i;
        int     rc = 0;
        u8      *bp;
 
 static void mux_read(struct uart_port *port)
 {
        int data;
-       struct tty_struct *tty = port->info->tty;
+       struct tty_struct *tty = port->info->port.tty;
        __u32 start_count = port->icount.rx;
 
        while(1) {
 
 static void netx_rxint(struct uart_port *port)
 {
        unsigned char rx, flg, status;
-       struct tty_struct *tty = port->info->tty;
+       struct tty_struct *tty = port->info->port.tty;
 
        while (!(readl(port->membase + UART_FR) & FR_RXFE)) {
                rx = readl(port->membase + UART_DR);
 
 
 static void pnx8xxx_rx_chars(struct pnx8xxx_port *sport)
 {
-       struct tty_struct *tty = sport->port.info->tty;
+       struct tty_struct *tty = sport->port.info->port.tty;
        unsigned int status, ch, flg;
 
        status = FIFO_TO_SM(serial_in(sport, PNX8XXX_FIFO)) |
 
 
 static inline void receive_chars(struct uart_pxa_port *up, int *status)
 {
-       struct tty_struct *tty = up->port.info->tty;
+       struct tty_struct *tty = up->port.info->port.tty;
        unsigned int ch, flag;
        int max_count = 256;
 
 
 static void
 sa1100_rx_chars(struct sa1100_port *sport)
 {
-       struct tty_struct *tty = sport->port.info->tty;
+       struct tty_struct *tty = sport->port.info->port.tty;
        unsigned int status, ch, flg;
 
        status = UTSR1_TO_SM(UART_GET_UTSR1(sport)) |
 
                uart_insert_char(uport, status, M_DUART_OVRUN_ERR, ch, flag);
        }
 
-       tty_flip_buffer_push(uport->info->tty);
+       tty_flip_buffer_push(uport->info->port.tty);
 }
 
 static void sbd_transmit_chars(struct sbd_port *sport)
 
        u8 status;
 
        if (port->info != NULL)         /* Unopened serial console */
-               tty = port->info->tty;
+               tty = port->info->port.tty;
 
        while (limit-- > 0) {
                status = READ_SC_PORT(port, SR);
 
 static irqreturn_t ks8695uart_rx_chars(int irq, void *dev_id)
 {
        struct uart_port *port = dev_id;
-       struct tty_struct *tty = port->info->tty;
+       struct tty_struct *tty = port->info->port.tty;
        unsigned int status, ch, lsr, flg, max_count = 256;
 
        status = UART_GET_LSR(port);            /* clears pending LSR interrupts */
 
 
 static void lh7a40xuart_rx_chars (struct uart_port* port)
 {
-       struct tty_struct* tty = port->info->tty;
+       struct tty_struct* tty = port->info->port.tty;
        int cbRxMax = 256;      /* (Gross) limit on receive */
        unsigned int data;      /* Received data and status */
        unsigned int flag;
 
 static inline void sci_receive_chars(struct uart_port *port)
 {
        struct sci_port *sci_port = (struct sci_port *)port;
-       struct tty_struct *tty = port->info->tty;
+       struct tty_struct *tty = port->info->port.tty;
        int i, count, copied = 0;
        unsigned short status;
        unsigned char flag;
 {
        int copied = 0;
        unsigned short status = sci_in(port, SCxSR);
-       struct tty_struct *tty = port->info->tty;
+       struct tty_struct *tty = port->info->port.tty;
 
        if (status & SCxSR_ORER(port)) {
                /* overrun error */
 {
        int copied = 0;
        unsigned short status = sci_in(port, SCxSR);
-       struct tty_struct *tty = port->info->tty;
+       struct tty_struct *tty = port->info->port.tty;
        struct sci_port *s = &sci_ports[port->line];
 
        if (uart_handle_break(port))
        } else {
 #if defined(SCIF_ORER)
                if((sci_in(port, SCLSR) & SCIF_ORER) != 0) {
-                       struct tty_struct *tty = port->info->tty;
+                       struct tty_struct *tty = port->info->port.tty;
 
                        sci_out(port, SCLSR, 0);
                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
 
 
 static int ulite_receive(struct uart_port *port, int stat)
 {
-       struct tty_struct *tty = port->info->tty;
+       struct tty_struct *tty = port->info->port.tty;
        unsigned char ch = 0;
        char flag = TTY_NORMAL;
 
                busy |= ulite_transmit(port, stat);
        } while (busy);
 
-       tty_flip_buffer_push(port->info->tty);
+       tty_flip_buffer_push(port->info->port.tty);
 
        return IRQ_HANDLED;
 }
 
        int i;
        unsigned char ch, *cp;
        struct uart_port *port = &qe_port->port;
-       struct tty_struct *tty = port->info->tty;
+       struct tty_struct *tty = port->info->port.tty;
        struct qe_bd *bdp;
        u16 status;
        unsigned int flg;
 
 
        port->icount.rx++;
 
-       tty_insert_flip_char (port->info->tty, ch, ch_stat);
-       tty_schedule_flip (port->info->tty);
+       tty_insert_flip_char (port->info->port.tty, ch, ch_stat);
+       tty_schedule_flip (port->info->port.tty);
 
        return IRQ_HANDLED;
 }
 
        char flag;
        int max_count = RX_MAX_COUNT;
 
-       tty = port->info->tty;
+       tty = port->info->port.tty;
        lsr = *status;
 
        do {
 
                uart_insert_char(uport, status, Rx_OVR, ch, flag);
        }
 
-       tty_flip_buffer_push(uport->info->tty);
+       tty_flip_buffer_push(uport->info->port.tty);
 }
 
 static void zs_raw_transmit_chars(struct zs_port *zport)