drivers/serial/serial_txx9.c

   1 /*
   2  *  drivers/serial/serial_txx9.c
   3  *
   4  * Derived from many drivers using generic_serial interface,
   5  * especially serial_tx3912.c by Steven J. Hill and r39xx_serial.c
   6  * (was in Linux/VR tree) by Jim Pick.
   7  *
   8  *  Copyright (C) 1999 Harald Koerfgen
   9  *  Copyright (C) 2000 Jim Pick <jim@jimpick.com>
  10  *  Copyright (C) 2001 Steven J. Hill (sjhill@realitydiluted.com)
  11  *  Copyright (C) 2000-2002 Toshiba Corporation
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License version 2 as
  15  * published by the Free Software Foundation.
  16  *
  17  *  Serial driver for TX3927/TX4927/TX4925/TX4938 internal SIO controller
  18  *
  19  *  Revision History:
  20  *      0.30    Initial revision. (Renamed from serial_txx927.c)
  21  *      0.31    Use save_flags instead of local_irq_save.
  22  *      0.32    Support SCLK.
  23  *      0.33    Switch TXX9_TTY_NAME by CONFIG_SERIAL_TXX9_STDSERIAL.
  24  *              Support TIOCSERGETLSR.
  25  *      0.34    Support slow baudrate.
  26  *      0.40    Merge codes from mainstream kernel (2.4.22).
  27  *      0.41    Fix console checking in rs_shutdown_port().
  28  *              Disable flow-control in serial_console_write().
  29  *      0.42    Fix minor compiler warning.
  30  *      1.00    Kernel 2.6.  Converted to new serial core (based on 8250.c).
  31  *      1.01    Set fifosize to make tx_empry called properly.
  32  *              Use standard uart_get_divisor.
  33  *      1.02    Cleanup. (import 8250.c changes)
  34  *      1.03    Fix low-latency mode. (import 8250.c changes)
  35  *      1.04    Remove usage of deprecated functions, cleanup.
  36  */
  37 #include <linux/config.h>
  38
  39 #if defined(CONFIG_SERIAL_TXX9_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  40 #define SUPPORT_SYSRQ
  41 #endif
  42
  43 #include <linux/module.h>
  44 #include <linux/ioport.h>
  45 #include <linux/init.h>
  46 #include <linux/console.h>
  47 #include <linux/sysrq.h>
  48 #include <linux/delay.h>
  49 #include <linux/device.h>
  50 #include <linux/pci.h>
  51 #include <linux/tty.h>
  52 #include <linux/tty_flip.h>
  53 #include <linux/serial_core.h>
  54 #include <linux/serial.h>
  55 #include <linux/mutex.h>
  56
  57 #include <asm/io.h>
  58 #include <asm/irq.h>
  59
  60 static char *serial_version = "1.04";
  61 static char *serial_name = "TX39/49 Serial driver";
  62
  63 #define PASS_LIMIT      256
  64
  65 #if !defined(CONFIG_SERIAL_TXX9_STDSERIAL)
  66 /* "ttyS" is used for standard serial driver */
  67 #define TXX9_TTY_NAME "ttyTX"
  68 #define TXX9_TTY_DEVFS_NAME "tttx/"
  69 #define TXX9_TTY_MINOR_START    (64 + 64)       /* ttyTX0(128), ttyTX1(129) */
  70 #else
  71 /* acts like standard serial driver */
  72 #define TXX9_TTY_NAME "ttyS"
  73 #define TXX9_TTY_DEVFS_NAME "tts/"
  74 #define TXX9_TTY_MINOR_START    64
  75 #endif
  76 #define TXX9_TTY_MAJOR  TTY_MAJOR
  77
  78 /* flag aliases */
  79 #define UPF_TXX9_HAVE_CTS_LINE  UPF_BUGGY_UART
  80 #define UPF_TXX9_USE_SCLK       UPF_MAGIC_MULTIPLIER
  81
  82 #ifdef CONFIG_PCI
  83 /* support for Toshiba TC86C001 SIO */
  84 #define ENABLE_SERIAL_TXX9_PCI
  85 #endif
  86
  87 /*
  88  * Number of serial ports
  89  */
  90 #ifdef ENABLE_SERIAL_TXX9_PCI
  91 #define NR_PCI_BOARDS   4
  92 #define UART_NR  (4 + NR_PCI_BOARDS)
  93 #else
  94 #define UART_NR  4
  95 #endif
  96
  97 struct uart_txx9_port {
  98         struct uart_port        port;
  99
 100         /*
 101          * We provide a per-port pm hook.
 102          */
 103         void                    (*pm)(struct uart_port *port,
 104                                       unsigned int state, unsigned int old);
 105 };
 106
 107 #define TXX9_REGION_SIZE        0x24
 108
 109 /* TXX9 Serial Registers */
 110 #define TXX9_SILCR      0x00
 111 #define TXX9_SIDICR     0x04
 112 #define TXX9_SIDISR     0x08
 113 #define TXX9_SICISR     0x0c
 114 #define TXX9_SIFCR      0x10
 115 #define TXX9_SIFLCR     0x14
 116 #define TXX9_SIBGR      0x18
 117 #define TXX9_SITFIFO    0x1c
 118 #define TXX9_SIRFIFO    0x20
 119
 120 /* SILCR : Line Control */
 121 #define TXX9_SILCR_SCS_MASK     0x00000060
 122 #define TXX9_SILCR_SCS_IMCLK    0x00000000
 123 #define TXX9_SILCR_SCS_IMCLK_BG 0x00000020
 124 #define TXX9_SILCR_SCS_SCLK     0x00000040
 125 #define TXX9_SILCR_SCS_SCLK_BG  0x00000060
 126 #define TXX9_SILCR_UEPS 0x00000010
 127 #define TXX9_SILCR_UPEN 0x00000008
 128 #define TXX9_SILCR_USBL_MASK    0x00000004
 129 #define TXX9_SILCR_USBL_1BIT    0x00000000
 130 #define TXX9_SILCR_USBL_2BIT    0x00000004
 131 #define TXX9_SILCR_UMODE_MASK   0x00000003
 132 #define TXX9_SILCR_UMODE_8BIT   0x00000000
 133 #define TXX9_SILCR_UMODE_7BIT   0x00000001
 134
 135 /* SIDICR : DMA/Int. Control */
 136 #define TXX9_SIDICR_TDE 0x00008000
 137 #define TXX9_SIDICR_RDE 0x00004000
 138 #define TXX9_SIDICR_TIE 0x00002000
 139 #define TXX9_SIDICR_RIE 0x00001000
 140 #define TXX9_SIDICR_SPIE        0x00000800
 141 #define TXX9_SIDICR_CTSAC       0x00000600
 142 #define TXX9_SIDICR_STIE_MASK   0x0000003f
 143 #define TXX9_SIDICR_STIE_OERS           0x00000020
 144 #define TXX9_SIDICR_STIE_CTSS           0x00000010
 145 #define TXX9_SIDICR_STIE_RBRKD  0x00000008
 146 #define TXX9_SIDICR_STIE_TRDY           0x00000004
 147 #define TXX9_SIDICR_STIE_TXALS  0x00000002
 148 #define TXX9_SIDICR_STIE_UBRKD  0x00000001
 149
 150 /* SIDISR : DMA/Int. Status */
 151 #define TXX9_SIDISR_UBRK        0x00008000
 152 #define TXX9_SIDISR_UVALID      0x00004000
 153 #define TXX9_SIDISR_UFER        0x00002000
 154 #define TXX9_SIDISR_UPER        0x00001000
 155 #define TXX9_SIDISR_UOER        0x00000800
 156 #define TXX9_SIDISR_ERI 0x00000400
 157 #define TXX9_SIDISR_TOUT        0x00000200
 158 #define TXX9_SIDISR_TDIS        0x00000100
 159 #define TXX9_SIDISR_RDIS        0x00000080
 160 #define TXX9_SIDISR_STIS        0x00000040
 161 #define TXX9_SIDISR_RFDN_MASK   0x0000001f
 162
 163 /* SICISR : Change Int. Status */
 164 #define TXX9_SICISR_OERS        0x00000020
 165 #define TXX9_SICISR_CTSS        0x00000010
 166 #define TXX9_SICISR_RBRKD       0x00000008
 167 #define TXX9_SICISR_TRDY        0x00000004
 168 #define TXX9_SICISR_TXALS       0x00000002
 169 #define TXX9_SICISR_UBRKD       0x00000001
 170
 171 /* SIFCR : FIFO Control */
 172 #define TXX9_SIFCR_SWRST        0x00008000
 173 #define TXX9_SIFCR_RDIL_MASK    0x00000180
 174 #define TXX9_SIFCR_RDIL_1       0x00000000
 175 #define TXX9_SIFCR_RDIL_4       0x00000080
 176 #define TXX9_SIFCR_RDIL_8       0x00000100
 177 #define TXX9_SIFCR_RDIL_12      0x00000180
 178 #define TXX9_SIFCR_RDIL_MAX     0x00000180
 179 #define TXX9_SIFCR_TDIL_MASK    0x00000018
 180 #define TXX9_SIFCR_TDIL_MASK    0x00000018
 181 #define TXX9_SIFCR_TDIL_1       0x00000000
 182 #define TXX9_SIFCR_TDIL_4       0x00000001
 183 #define TXX9_SIFCR_TDIL_8       0x00000010
 184 #define TXX9_SIFCR_TDIL_MAX     0x00000010
 185 #define TXX9_SIFCR_TFRST        0x00000004
 186 #define TXX9_SIFCR_RFRST        0x00000002
 187 #define TXX9_SIFCR_FRSTE        0x00000001
 188 #define TXX9_SIO_TX_FIFO        8
 189 #define TXX9_SIO_RX_FIFO        16
 190
 191 /* SIFLCR : Flow Control */
 192 #define TXX9_SIFLCR_RCS 0x00001000
 193 #define TXX9_SIFLCR_TES 0x00000800
 194 #define TXX9_SIFLCR_RTSSC       0x00000200
 195 #define TXX9_SIFLCR_RSDE        0x00000100
 196 #define TXX9_SIFLCR_TSDE        0x00000080
 197 #define TXX9_SIFLCR_RTSTL_MASK  0x0000001e
 198 #define TXX9_SIFLCR_RTSTL_MAX   0x0000001e
 199 #define TXX9_SIFLCR_TBRK        0x00000001
 200
 201 /* SIBGR : Baudrate Control */
 202 #define TXX9_SIBGR_BCLK_MASK    0x00000300
 203 #define TXX9_SIBGR_BCLK_T0      0x00000000
 204 #define TXX9_SIBGR_BCLK_T2      0x00000100
 205 #define TXX9_SIBGR_BCLK_T4      0x00000200
 206 #define TXX9_SIBGR_BCLK_T6      0x00000300
 207 #define TXX9_SIBGR_BRD_MASK     0x000000ff
 208
 209 static inline unsigned int sio_in(struct uart_txx9_port *up, int offset)
 210 {
 211         switch (up->port.iotype) {
 212         default:
 213                 return *(volatile u32 *)(up->port.membase + offset);
 214         case UPIO_PORT:
 215                 return inl(up->port.iobase + offset);
 216         }
 217 }
 218
 219 static inline void
 220 sio_out(struct uart_txx9_port *up, int offset, int value)
 221 {
 222         switch (up->port.iotype) {
 223         default:
 224                 *(volatile u32 *)(up->port.membase + offset) = value;
 225                 break;
 226         case UPIO_PORT:
 227                 outl(value, up->port.iobase + offset);
 228                 break;
 229         }
 230 }
 231
 232 static inline void
 233 sio_mask(struct uart_txx9_port *up, int offset, unsigned int value)
 234 {
 235         sio_out(up, offset, sio_in(up, offset) & ~value);
 236 }
 237 static inline void
 238 sio_set(struct uart_txx9_port *up, int offset, unsigned int value)
 239 {
 240         sio_out(up, offset, sio_in(up, offset) | value);
 241 }
 242
 243 static inline void
 244 sio_quot_set(struct uart_txx9_port *up, int quot)
 245 {
 246         quot >>= 1;
 247         if (quot < 256)
 248                 sio_out(up, TXX9_SIBGR, quot | TXX9_SIBGR_BCLK_T0);
 249         else if (quot < (256 << 2))
 250                 sio_out(up, TXX9_SIBGR, (quot >> 2) | TXX9_SIBGR_BCLK_T2);
 251         else if (quot < (256 << 4))
 252                 sio_out(up, TXX9_SIBGR, (quot >> 4) | TXX9_SIBGR_BCLK_T4);
 253         else if (quot < (256 << 6))
 254                 sio_out(up, TXX9_SIBGR, (quot >> 6) | TXX9_SIBGR_BCLK_T6);
 255         else
 256                 sio_out(up, TXX9_SIBGR, 0xff | TXX9_SIBGR_BCLK_T6);
 257 }
 258
 259 static void serial_txx9_stop_tx(struct uart_port *port)
 260 {
 261         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
 262         unsigned long flags;
 263
 264         spin_lock_irqsave(&up->port.lock, flags);
 265         sio_mask(up, TXX9_SIDICR, TXX9_SIDICR_TIE);
 266         spin_unlock_irqrestore(&up->port.lock, flags);
 267 }
 268
 269 static void serial_txx9_start_tx(struct uart_port *port)
 270 {
 271         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
 272         unsigned long flags;
 273
 274         spin_lock_irqsave(&up->port.lock, flags);
 275         sio_set(up, TXX9_SIDICR, TXX9_SIDICR_TIE);
 276         spin_unlock_irqrestore(&up->port.lock, flags);
 277 }
 278
 279 static void serial_txx9_stop_rx(struct uart_port *port)
 280 {
 281         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
 282         unsigned long flags;
 283
 284         spin_lock_irqsave(&up->port.lock, flags);
 285         up->port.read_status_mask &= ~TXX9_SIDISR_RDIS;
 286 #if 0
 287         sio_mask(up, TXX9_SIDICR, TXX9_SIDICR_RIE);
 288 #endif
 289         spin_unlock_irqrestore(&up->port.lock, flags);
 290 }
 291
 292 static void serial_txx9_enable_ms(struct uart_port *port)
 293 {
 294         /* TXX9-SIO can not control DTR... */
 295 }
 296
 297 static inline void
 298 receive_chars(struct uart_txx9_port *up, unsigned int *status, struct pt_regs *regs)
 299 {
 300         struct tty_struct *tty = up->port.info->tty;
 301         unsigned char ch;
 302         unsigned int disr = *status;
 303         int max_count = 256;
 304         char flag;
 305
 306         do {
 307                 ch = sio_in(up, TXX9_SIRFIFO);
 308                 flag = TTY_NORMAL;
 309                 up->port.icount.rx++;
 310
 311                 if (unlikely(disr & (TXX9_SIDISR_UBRK | TXX9_SIDISR_UPER |
 312                                      TXX9_SIDISR_UFER | TXX9_SIDISR_UOER))) {
 313                         /*
 314                          * For statistics only
 315                          */
 316                         if (disr & TXX9_SIDISR_UBRK) {
 317                                 disr &= ~(TXX9_SIDISR_UFER | TXX9_SIDISR_UPER);
 318                                 up->port.icount.brk++;
 319                                 /*
 320                                  * We do the SysRQ and SAK checking
 321                                  * here because otherwise the break
 322                                  * may get masked by ignore_status_mask
 323                                  * or read_status_mask.
 324                                  */
 325                                 if (uart_handle_break(&up->port))
 326                                         goto ignore_char;
 327                         } else if (disr & TXX9_SIDISR_UPER)
 328                                 up->port.icount.parity++;
 329                         else if (disr & TXX9_SIDISR_UFER)
 330                                 up->port.icount.frame++;
 331                         if (disr & TXX9_SIDISR_UOER)
 332                                 up->port.icount.overrun++;
 333
 334                         /*
 335                          * Mask off conditions which should be ingored.
 336                          */
 337                         disr &= up->port.read_status_mask;
 338
 339                         if (disr & TXX9_SIDISR_UBRK) {
 340                                 flag = TTY_BREAK;
 341                         } else if (disr & TXX9_SIDISR_UPER)
 342                                 flag = TTY_PARITY;
 343                         else if (disr & TXX9_SIDISR_UFER)
 344                                 flag = TTY_FRAME;
 345                 }
 346                 if (uart_handle_sysrq_char(&up->port, ch, regs))
 347                         goto ignore_char;
 348
 349                 uart_insert_char(&up->port, disr, TXX9_SIDISR_UOER, ch, flag);
 350
 351         ignore_char:
 352                 disr = sio_in(up, TXX9_SIDISR);
 353         } while (!(disr & TXX9_SIDISR_UVALID) && (max_count-- > 0));
 354         spin_unlock(&up->port.lock);
 355         tty_flip_buffer_push(tty);
 356         spin_lock(&up->port.lock);
 357         *status = disr;
 358 }
 359
 360 static inline void transmit_chars(struct uart_txx9_port *up)
 361 {
 362         struct circ_buf *xmit = &up->port.info->xmit;
 363         int count;
 364
 365         if (up->port.x_char) {
 366                 sio_out(up, TXX9_SITFIFO, up->port.x_char);
 367                 up->port.icount.tx++;
 368                 up->port.x_char = 0;
 369                 return;
 370         }
 371         if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) {
 372                 serial_txx9_stop_tx(&up->port);
 373                 return;
 374         }
 375
 376         count = TXX9_SIO_TX_FIFO;
 377         do {
 378                 sio_out(up, TXX9_SITFIFO, xmit->buf[xmit->tail]);
 379                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 380                 up->port.icount.tx++;
 381                 if (uart_circ_empty(xmit))
 382                         break;
 383         } while (--count > 0);
 384
 385         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 386                 uart_write_wakeup(&up->port);
 387
 388         if (uart_circ_empty(xmit))
 389                 serial_txx9_stop_tx(&up->port);
 390 }
 391
 392 static irqreturn_t serial_txx9_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 393 {
 394         int pass_counter = 0;
 395         struct uart_txx9_port *up = dev_id;
 396         unsigned int status;
 397
 398         while (1) {
 399                 spin_lock(&up->port.lock);
 400                 status = sio_in(up, TXX9_SIDISR);
 401                 if (!(sio_in(up, TXX9_SIDICR) & TXX9_SIDICR_TIE))
 402                         status &= ~TXX9_SIDISR_TDIS;
 403                 if (!(status & (TXX9_SIDISR_TDIS | TXX9_SIDISR_RDIS |
 404                                 TXX9_SIDISR_TOUT))) {
 405                         spin_unlock(&up->port.lock);
 406                         break;
 407                 }
 408
 409                 if (status & TXX9_SIDISR_RDIS)
 410                         receive_chars(up, &status, regs);
 411                 if (status & TXX9_SIDISR_TDIS)
 412                         transmit_chars(up);
 413                 /* Clear TX/RX Int. Status */
 414                 sio_mask(up, TXX9_SIDISR,
 415                          TXX9_SIDISR_TDIS | TXX9_SIDISR_RDIS |
 416                          TXX9_SIDISR_TOUT);
 417                 spin_unlock(&up->port.lock);
 418
 419                 if (pass_counter++ > PASS_LIMIT)
 420                         break;
 421         }
 422
 423         return pass_counter ? IRQ_HANDLED : IRQ_NONE;
 424 }
 425
 426 static unsigned int serial_txx9_tx_empty(struct uart_port *port)
 427 {
 428         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
 429         unsigned long flags;
 430         unsigned int ret;
 431
 432         spin_lock_irqsave(&up->port.lock, flags);
 433         ret = (sio_in(up, TXX9_SICISR) & TXX9_SICISR_TXALS) ? TIOCSER_TEMT : 0;
 434         spin_unlock_irqrestore(&up->port.lock, flags);
 435
 436         return ret;
 437 }
 438
 439 static unsigned int serial_txx9_get_mctrl(struct uart_port *port)
 440 {
 441         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
 442         unsigned int ret;
 443
 444         ret =  ((sio_in(up, TXX9_SIFLCR) & TXX9_SIFLCR_RTSSC) ? 0 : TIOCM_RTS)
 445                 | ((sio_in(up, TXX9_SICISR) & TXX9_SICISR_CTSS) ? 0 : TIOCM_CTS);
 446
 447         return ret;
 448 }
 449
 450 static void serial_txx9_set_mctrl(struct uart_port *port, unsigned int mctrl)
 451 {
 452         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
 453         unsigned long flags;
 454
 455         spin_lock_irqsave(&up->port.lock, flags);
 456         if (mctrl & TIOCM_RTS)
 457                 sio_mask(up, TXX9_SIFLCR, TXX9_SIFLCR_RTSSC);
 458         else
 459                 sio_set(up, TXX9_SIFLCR, TXX9_SIFLCR_RTSSC);
 460         spin_unlock_irqrestore(&up->port.lock, flags);
 461 }
 462
 463 static void serial_txx9_break_ctl(struct uart_port *port, int break_state)
 464 {
 465         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
 466         unsigned long flags;
 467
 468         spin_lock_irqsave(&up->port.lock, flags);
 469         if (break_state == -1)
 470                 sio_set(up, TXX9_SIFLCR, TXX9_SIFLCR_TBRK);
 471         else
 472                 sio_mask(up, TXX9_SIFLCR, TXX9_SIFLCR_TBRK);
 473         spin_unlock_irqrestore(&up->port.lock, flags);
 474 }
 475
 476 static int serial_txx9_startup(struct uart_port *port)
 477 {
 478         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
 479         unsigned long flags;
 480         int retval;
 481
 482         /*
 483          * Clear the FIFO buffers and disable them.
 484          * (they will be reeanbled in set_termios())
 485          */
 486         sio_set(up, TXX9_SIFCR,
 487                 TXX9_SIFCR_TFRST | TXX9_SIFCR_RFRST | TXX9_SIFCR_FRSTE);
 488         /* clear reset */
 489         sio_mask(up, TXX9_SIFCR,
 490                  TXX9_SIFCR_TFRST | TXX9_SIFCR_RFRST | TXX9_SIFCR_FRSTE);
 491         sio_out(up, TXX9_SIDICR, 0);
 492
 493         /*
 494          * Clear the interrupt registers.
 495          */
 496         sio_out(up, TXX9_SIDISR, 0);
 497
 498         retval = request_irq(up->port.irq, serial_txx9_interrupt,
 499                              SA_SHIRQ, "serial_txx9", up);
 500         if (retval)
 501                 return retval;
 502
 503         /*
 504          * Now, initialize the UART
 505          */
 506         spin_lock_irqsave(&up->port.lock, flags);
 507         serial_txx9_set_mctrl(&up->port, up->port.mctrl);
 508         spin_unlock_irqrestore(&up->port.lock, flags);
 509
 510         /* Enable RX/TX */
 511         sio_mask(up, TXX9_SIFLCR, TXX9_SIFLCR_RSDE | TXX9_SIFLCR_TSDE);
 512
 513         /*
 514          * Finally, enable interrupts.
 515          */
 516         sio_set(up, TXX9_SIDICR, TXX9_SIDICR_RIE);
 517
 518         return 0;
 519 }
 520
 521 static void serial_txx9_shutdown(struct uart_port *port)
 522 {
 523         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
 524         unsigned long flags;
 525
 526         /*
 527          * Disable interrupts from this port
 528          */
 529         sio_out(up, TXX9_SIDICR, 0);    /* disable all intrs */
 530
 531         spin_lock_irqsave(&up->port.lock, flags);
 532         serial_txx9_set_mctrl(&up->port, up->port.mctrl);
 533         spin_unlock_irqrestore(&up->port.lock, flags);
 534
 535         /*
 536          * Disable break condition
 537          */
 538         sio_mask(up, TXX9_SIFLCR, TXX9_SIFLCR_TBRK);
 539
 540 #ifdef CONFIG_SERIAL_TXX9_CONSOLE
 541         if (up->port.cons && up->port.line == up->port.cons->index) {
 542                 free_irq(up->port.irq, up);
 543                 return;
 544         }
 545 #endif
 546         /* reset FIFOs */
 547         sio_set(up, TXX9_SIFCR,
 548                 TXX9_SIFCR_TFRST | TXX9_SIFCR_RFRST | TXX9_SIFCR_FRSTE);
 549         /* clear reset */
 550         sio_mask(up, TXX9_SIFCR,
 551                  TXX9_SIFCR_TFRST | TXX9_SIFCR_RFRST | TXX9_SIFCR_FRSTE);
 552
 553         /* Disable RX/TX */
 554         sio_set(up, TXX9_SIFLCR, TXX9_SIFLCR_RSDE | TXX9_SIFLCR_TSDE);
 555
 556         free_irq(up->port.irq, up);
 557 }
 558
 559 static void
 560 serial_txx9_set_termios(struct uart_port *port, struct termios *termios,
 561                        struct termios *old)
 562 {
 563         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
 564         unsigned int cval, fcr = 0;
 565         unsigned long flags;
 566         unsigned int baud, quot;
 567
 568         cval = sio_in(up, TXX9_SILCR);
 569         /* byte size and parity */
 570         cval &= ~TXX9_SILCR_UMODE_MASK;
 571         switch (termios->c_cflag & CSIZE) {
 572         case CS7:
 573                 cval |= TXX9_SILCR_UMODE_7BIT;
 574                 break;
 575         default:
 576         case CS5:       /* not supported */
 577         case CS6:       /* not supported */
 578         case CS8:
 579                 cval |= TXX9_SILCR_UMODE_8BIT;
 580                 break;
 581         }
 582
 583         cval &= ~TXX9_SILCR_USBL_MASK;
 584         if (termios->c_cflag & CSTOPB)
 585                 cval |= TXX9_SILCR_USBL_2BIT;
 586         else
 587                 cval |= TXX9_SILCR_USBL_1BIT;
 588         cval &= ~(TXX9_SILCR_UPEN | TXX9_SILCR_UEPS);
 589         if (termios->c_cflag & PARENB)
 590                 cval |= TXX9_SILCR_UPEN;
 591         if (!(termios->c_cflag & PARODD))
 592                 cval |= TXX9_SILCR_UEPS;
 593
 594         /*
 595          * Ask the core to calculate the divisor for us.
 596          */
 597         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16/2);
 598         quot = uart_get_divisor(port, baud);
 599
 600         /* Set up FIFOs */
 601         /* TX Int by FIFO Empty, RX Int by Receiving 1 char. */
 602         fcr = TXX9_SIFCR_TDIL_MAX | TXX9_SIFCR_RDIL_1;
 603
 604         /*
 605          * Ok, we're now changing the port state.  Do it with
 606          * interrupts disabled.
 607          */
 608         spin_lock_irqsave(&up->port.lock, flags);
 609
 610         /*
 611          * Update the per-port timeout.
 612          */
 613         uart_update_timeout(port, termios->c_cflag, baud);
 614
 615         up->port.read_status_mask = TXX9_SIDISR_UOER |
 616                 TXX9_SIDISR_TDIS | TXX9_SIDISR_RDIS;
 617         if (termios->c_iflag & INPCK)
 618                 up->port.read_status_mask |= TXX9_SIDISR_UFER | TXX9_SIDISR_UPER;
 619         if (termios->c_iflag & (BRKINT | PARMRK))
 620                 up->port.read_status_mask |= TXX9_SIDISR_UBRK;
 621
 622         /*
 623          * Characteres to ignore
 624          */
 625         up->port.ignore_status_mask = 0;
 626         if (termios->c_iflag & IGNPAR)
 627                 up->port.ignore_status_mask |= TXX9_SIDISR_UPER | TXX9_SIDISR_UFER;
 628         if (termios->c_iflag & IGNBRK) {
 629                 up->port.ignore_status_mask |= TXX9_SIDISR_UBRK;
 630                 /*
 631                  * If we're ignoring parity and break indicators,
 632                  * ignore overruns too (for real raw support).
 633                  */
 634                 if (termios->c_iflag & IGNPAR)
 635                         up->port.ignore_status_mask |= TXX9_SIDISR_UOER;
 636         }
 637
 638         /*
 639          * ignore all characters if CREAD is not set
 640          */
 641         if ((termios->c_cflag & CREAD) == 0)
 642                 up->port.ignore_status_mask |= TXX9_SIDISR_RDIS;
 643
 644         /* CTS flow control flag */
 645         if ((termios->c_cflag & CRTSCTS) &&
 646             (up->port.flags & UPF_TXX9_HAVE_CTS_LINE)) {
 647                 sio_set(up, TXX9_SIFLCR,
 648                         TXX9_SIFLCR_RCS | TXX9_SIFLCR_TES);
 649         } else {
 650                 sio_mask(up, TXX9_SIFLCR,
 651                          TXX9_SIFLCR_RCS | TXX9_SIFLCR_TES);
 652         }
 653
 654         sio_out(up, TXX9_SILCR, cval);
 655         sio_quot_set(up, quot);
 656         sio_out(up, TXX9_SIFCR, fcr);
 657
 658         serial_txx9_set_mctrl(&up->port, up->port.mctrl);
 659         spin_unlock_irqrestore(&up->port.lock, flags);
 660 }
 661
 662 static void
 663 serial_txx9_pm(struct uart_port *port, unsigned int state,
 664               unsigned int oldstate)
 665 {
 666         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
 667         if (up->pm)
 668                 up->pm(port, state, oldstate);
 669 }
 670
 671 static int serial_txx9_request_resource(struct uart_txx9_port *up)
 672 {
 673         unsigned int size = TXX9_REGION_SIZE;
 674         int ret = 0;
 675
 676         switch (up->port.iotype) {
 677         default:
 678                 if (!up->port.mapbase)
 679                         break;
 680
 681                 if (!request_mem_region(up->port.mapbase, size, "serial_txx9")) {
 682                         ret = -EBUSY;
 683                         break;
 684                 }
 685
 686                 if (up->port.flags & UPF_IOREMAP) {
 687                         up->port.membase = ioremap(up->port.mapbase, size);
 688                         if (!up->port.membase) {
 689                                 release_mem_region(up->port.mapbase, size);
 690                                 ret = -ENOMEM;
 691                         }
 692                 }
 693                 break;
 694
 695         case UPIO_PORT:
 696                 if (!request_region(up->port.iobase, size, "serial_txx9"))
 697                         ret = -EBUSY;
 698                 break;
 699         }
 700         return ret;
 701 }
 702
 703 static void serial_txx9_release_resource(struct uart_txx9_port *up)
 704 {
 705         unsigned int size = TXX9_REGION_SIZE;
 706
 707         switch (up->port.iotype) {
 708         default:
 709                 if (!up->port.mapbase)
 710                         break;
 711
 712                 if (up->port.flags & UPF_IOREMAP) {
 713                         iounmap(up->port.membase);
 714                         up->port.membase = NULL;
 715                 }
 716
 717                 release_mem_region(up->port.mapbase, size);
 718                 break;
 719
 720         case UPIO_PORT:
 721                 release_region(up->port.iobase, size);
 722                 break;
 723         }
 724 }
 725
 726 static void serial_txx9_release_port(struct uart_port *port)
 727 {
 728         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
 729         serial_txx9_release_resource(up);
 730 }
 731
 732 static int serial_txx9_request_port(struct uart_port *port)
 733 {
 734         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
 735         return serial_txx9_request_resource(up);
 736 }
 737
 738 static void serial_txx9_config_port(struct uart_port *port, int uflags)
 739 {
 740         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
 741         unsigned long flags;
 742         int ret;
 743
 744         /*
 745          * Find the region that we can probe for.  This in turn
 746          * tells us whether we can probe for the type of port.
 747          */
 748         ret = serial_txx9_request_resource(up);
 749         if (ret < 0)
 750                 return;
 751         port->type = PORT_TXX9;
 752         up->port.fifosize = TXX9_SIO_TX_FIFO;
 753
 754 #ifdef CONFIG_SERIAL_TXX9_CONSOLE
 755         if (up->port.line == up->port.cons->index)
 756                 return;
 757 #endif
 758         spin_lock_irqsave(&up->port.lock, flags);
 759         /*
 760          * Reset the UART.
 761          */
 762         sio_out(up, TXX9_SIFCR, TXX9_SIFCR_SWRST);
 763 #ifdef CONFIG_CPU_TX49XX
 764         /* TX4925 BUG WORKAROUND.  Accessing SIOC register
 765          * immediately after soft reset causes bus error. */
 766         iob();
 767         udelay(1);
 768 #endif
 769         while (sio_in(up, TXX9_SIFCR) & TXX9_SIFCR_SWRST)
 770                 ;
 771         /* TX Int by FIFO Empty, RX Int by Receiving 1 char. */
 772         sio_set(up, TXX9_SIFCR,
 773                 TXX9_SIFCR_TDIL_MAX | TXX9_SIFCR_RDIL_1);
 774         /* initial settings */
 775         sio_out(up, TXX9_SILCR,
 776                 TXX9_SILCR_UMODE_8BIT | TXX9_SILCR_USBL_1BIT |
 777                 ((up->port.flags & UPF_TXX9_USE_SCLK) ?
 778                  TXX9_SILCR_SCS_SCLK_BG : TXX9_SILCR_SCS_IMCLK_BG));
 779         sio_quot_set(up, uart_get_divisor(port, 9600));
 780         sio_out(up, TXX9_SIFLCR, TXX9_SIFLCR_RTSTL_MAX /* 15 */);
 781         spin_unlock_irqrestore(&up->port.lock, flags);
 782 }
 783
 784 static int
 785 serial_txx9_verify_port(struct uart_port *port, struct serial_struct *ser)
 786 {
 787         if (ser->irq < 0 ||
 788             ser->baud_base < 9600 || ser->type != PORT_TXX9)
 789                 return -EINVAL;
 790         return 0;
 791 }
 792
 793 static const char *
 794 serial_txx9_type(struct uart_port *port)
 795 {
 796         return "txx9";
 797 }
 798
 799 static struct uart_ops serial_txx9_pops = {
 800         .tx_empty       = serial_txx9_tx_empty,
 801         .set_mctrl      = serial_txx9_set_mctrl,
 802         .get_mctrl      = serial_txx9_get_mctrl,
 803         .stop_tx        = serial_txx9_stop_tx,
 804         .start_tx       = serial_txx9_start_tx,
 805         .stop_rx        = serial_txx9_stop_rx,
 806         .enable_ms      = serial_txx9_enable_ms,
 807         .break_ctl      = serial_txx9_break_ctl,
 808         .startup        = serial_txx9_startup,
 809         .shutdown       = serial_txx9_shutdown,
 810         .set_termios    = serial_txx9_set_termios,
 811         .pm             = serial_txx9_pm,
 812         .type           = serial_txx9_type,
 813         .release_port   = serial_txx9_release_port,
 814         .request_port   = serial_txx9_request_port,
 815         .config_port    = serial_txx9_config_port,
 816         .verify_port    = serial_txx9_verify_port,
 817 };
 818
 819 static struct uart_txx9_port serial_txx9_ports[UART_NR];
 820
 821 static void __init serial_txx9_register_ports(struct uart_driver *drv)
 822 {
 823         int i;
 824
 825         for (i = 0; i < UART_NR; i++) {
 826                 struct uart_txx9_port *up = &serial_txx9_ports[i];
 827
 828                 up->port.line = i;
 829                 up->port.ops = &serial_txx9_pops;
 830                 uart_add_one_port(drv, &up->port);
 831         }
 832 }
 833
 834 #ifdef CONFIG_SERIAL_TXX9_CONSOLE
 835
 836 /*
 837  *      Wait for transmitter & holding register to empty
 838  */
 839 static inline void wait_for_xmitr(struct uart_txx9_port *up)
 840 {
 841         unsigned int tmout = 10000;
 842
 843         /* Wait up to 10ms for the character(s) to be sent. */
 844         while (--tmout &&
 845                !(sio_in(up, TXX9_SICISR) & TXX9_SICISR_TXALS))
 846                 udelay(1);
 847
 848         /* Wait up to 1s for flow control if necessary */
 849         if (up->port.flags & UPF_CONS_FLOW) {
 850                 tmout = 1000000;
 851                 while (--tmout &&
 852                        (sio_in(up, TXX9_SICISR) & TXX9_SICISR_CTSS))
 853                         udelay(1);
 854         }
 855 }
 856
 857 /*
 858  *      Print a string to the serial port trying not to disturb
 859  *      any possible real use of the port...
 860  *
 861  *      The console_lock must be held when we get here.
 862  */
 863 static void
 864 serial_txx9_console_write(struct console *co, const char *s, unsigned int count)
 865 {
 866         struct uart_txx9_port *up = &serial_txx9_ports[co->index];
 867         unsigned int ier, flcr;
 868         int i;
 869
 870         /*
 871          *      First save the UER then disable the interrupts
 872          */
 873         ier = sio_in(up, TXX9_SIDICR);
 874         sio_out(up, TXX9_SIDICR, 0);
 875         /*
 876          *      Disable flow-control if enabled (and unnecessary)
 877          */
 878         flcr = sio_in(up, TXX9_SIFLCR);
 879         if (!(up->port.flags & UPF_CONS_FLOW) && (flcr & TXX9_SIFLCR_TES))
 880                 sio_out(up, TXX9_SIFLCR, flcr & ~TXX9_SIFLCR_TES);
 881
 882         /*
 883          *      Now, do each character
 884          */
 885         for (i = 0; i < count; i++, s++) {
 886                 wait_for_xmitr(up);
 887
 888                 /*
 889                  *      Send the character out.
 890                  *      If a LF, also do CR...
 891                  */
 892                 sio_out(up, TXX9_SITFIFO, *s);
 893                 if (*s == 10) {
 894                         wait_for_xmitr(up);
 895                         sio_out(up, TXX9_SITFIFO, 13);
 896                 }
 897         }
 898
 899         /*
 900          *      Finally, wait for transmitter to become empty
 901          *      and restore the IER
 902          */
 903         wait_for_xmitr(up);
 904         sio_out(up, TXX9_SIFLCR, flcr);
 905         sio_out(up, TXX9_SIDICR, ier);
 906 }
 907
 908 static int serial_txx9_console_setup(struct console *co, char *options)
 909 {
 910         struct uart_port *port;
 911         struct uart_txx9_port *up;
 912         int baud = 9600;
 913         int bits = 8;
 914         int parity = 'n';
 915         int flow = 'n';
 916
 917         /*
 918          * Check whether an invalid uart number has been specified, and
 919          * if so, search for the first available port that does have
 920          * console support.
 921          */
 922         if (co->index >= UART_NR)
 923                 co->index = 0;
 924         up = &serial_txx9_ports[co->index];
 925         port = &up->port;
 926         if (!port->ops)
 927                 return -ENODEV;
 928
 929         /*
 930          * Temporary fix.
 931          */
 932         spin_lock_init(&port->lock);
 933
 934         /*
 935          *      Disable UART interrupts, set DTR and RTS high
 936          *      and set speed.
 937          */
 938         sio_out(up, TXX9_SIDICR, 0);
 939         /* initial settings */
 940         sio_out(up, TXX9_SILCR,
 941                 TXX9_SILCR_UMODE_8BIT | TXX9_SILCR_USBL_1BIT |
 942                 ((port->flags & UPF_TXX9_USE_SCLK) ?
 943                  TXX9_SILCR_SCS_SCLK_BG : TXX9_SILCR_SCS_IMCLK_BG));
 944         sio_out(up, TXX9_SIFLCR, TXX9_SIFLCR_RTSTL_MAX /* 15 */);
 945
 946         if (options)
 947                 uart_parse_options(options, &baud, &parity, &bits, &flow);
 948
 949         return uart_set_options(port, co, baud, parity, bits, flow);
 950 }
 951
 952 static struct uart_driver serial_txx9_reg;
 953 static struct console serial_txx9_console = {
 954         .name           = TXX9_TTY_NAME,
 955         .write          = serial_txx9_console_write,
 956         .device         = uart_console_device,
 957         .setup          = serial_txx9_console_setup,
 958         .flags          = CON_PRINTBUFFER,
 959         .index          = -1,
 960         .data           = &serial_txx9_reg,
 961 };
 962
 963 static int __init serial_txx9_console_init(void)
 964 {
 965         register_console(&serial_txx9_console);
 966         return 0;
 967 }
 968 console_initcall(serial_txx9_console_init);
 969
 970 #define SERIAL_TXX9_CONSOLE     &serial_txx9_console
 971 #else
 972 #define SERIAL_TXX9_CONSOLE     NULL
 973 #endif
 974
 975 static struct uart_driver serial_txx9_reg = {
 976         .owner                  = THIS_MODULE,
 977         .driver_name            = "serial_txx9",
 978         .devfs_name             = TXX9_TTY_DEVFS_NAME,
 979         .dev_name               = TXX9_TTY_NAME,
 980         .major                  = TXX9_TTY_MAJOR,
 981         .minor                  = TXX9_TTY_MINOR_START,
 982         .nr                     = UART_NR,
 983         .cons                   = SERIAL_TXX9_CONSOLE,
 984 };
 985
 986 int __init early_serial_txx9_setup(struct uart_port *port)
 987 {
 988         if (port->line >= ARRAY_SIZE(serial_txx9_ports))
 989                 return -ENODEV;
 990
 991         serial_txx9_ports[port->line].port = *port;
 992         serial_txx9_ports[port->line].port.ops = &serial_txx9_pops;
 993         serial_txx9_ports[port->line].port.flags |= UPF_BOOT_AUTOCONF;
 994         return 0;
 995 }
 996
 997 #ifdef ENABLE_SERIAL_TXX9_PCI
 998 /**
 999  *      serial_txx9_suspend_port - suspend one serial port
1000  *      @line:  serial line number
1001  *      @level: the level of port suspension, as per uart_suspend_port
1002  *
1003  *      Suspend one serial port.
1004  */
1005 static void serial_txx9_suspend_port(int line)
1006 {
1007         uart_suspend_port(&serial_txx9_reg, &serial_txx9_ports[line].port);
1008 }
1009
1010 /**
1011  *      serial_txx9_resume_port - resume one serial port
1012  *      @line:  serial line number
1013  *      @level: the level of port resumption, as per uart_resume_port
1014  *
1015  *      Resume one serial port.
1016  */
1017 static void serial_txx9_resume_port(int line)
1018 {
1019         uart_resume_port(&serial_txx9_reg, &serial_txx9_ports[line].port);
1020 }
1021
1022 static DEFINE_MUTEX(serial_txx9_mutex);
1023
1024 /**
1025  *      serial_txx9_register_port - register a serial port
1026  *      @port: serial port template
1027  *
1028  *      Configure the serial port specified by the request.
1029  *
1030  *      The port is then probed and if necessary the IRQ is autodetected
1031  *      If this fails an error is returned.
1032  *
1033  *      On success the port is ready to use and the line number is returned.
1034  */
1035 static int __devinit serial_txx9_register_port(struct uart_port *port)
1036 {
1037         int i;
1038         struct uart_txx9_port *uart;
1039         int ret = -ENOSPC;
1040
1041         mutex_lock(&serial_txx9_mutex);
1042         for (i = 0; i < UART_NR; i++) {
1043                 uart = &serial_txx9_ports[i];
1044                 if (uart->port.type == PORT_UNKNOWN)
1045                         break;
1046         }
1047         if (i < UART_NR) {
1048                 uart_remove_one_port(&serial_txx9_reg, &uart->port);
1049                 uart->port.iobase = port->iobase;
1050                 uart->port.membase = port->membase;
1051                 uart->port.irq      = port->irq;
1052                 uart->port.uartclk  = port->uartclk;
1053                 uart->port.iotype   = port->iotype;
1054                 uart->port.flags    = port->flags | UPF_BOOT_AUTOCONF;
1055                 uart->port.mapbase  = port->mapbase;
1056                 if (port->dev)
1057                         uart->port.dev = port->dev;
1058                 ret = uart_add_one_port(&serial_txx9_reg, &uart->port);
1059                 if (ret == 0)
1060                         ret = uart->port.line;
1061         }
1062         mutex_unlock(&serial_txx9_mutex);
1063         return ret;
1064 }
1065
1066 /**
1067  *      serial_txx9_unregister_port - remove a txx9 serial port at runtime
1068  *      @line: serial line number
1069  *
1070  *      Remove one serial port.  This may not be called from interrupt
1071  *      context.  We hand the port back to the our control.
1072  */
1073 static void __devexit serial_txx9_unregister_port(int line)
1074 {
1075         struct uart_txx9_port *uart = &serial_txx9_ports[line];
1076
1077         mutex_lock(&serial_txx9_mutex);
1078         uart_remove_one_port(&serial_txx9_reg, &uart->port);
1079         uart->port.flags = 0;
1080         uart->port.type = PORT_UNKNOWN;
1081         uart->port.iobase = 0;
1082         uart->port.mapbase = 0;
1083         uart->port.membase = 0;
1084         uart->port.dev = NULL;
1085         uart_add_one_port(&serial_txx9_reg, &uart->port);
1086         mutex_unlock(&serial_txx9_mutex);
1087 }
1088
1089 /*
1090  * Probe one serial board.  Unfortunately, there is no rhyme nor reason
1091  * to the arrangement of serial ports on a PCI card.
1092  */
1093 static int __devinit
1094 pciserial_txx9_init_one(struct pci_dev *dev, const struct pci_device_id *ent)
1095 {
1096         struct uart_port port;
1097         int line;
1098         int rc;
1099
1100         rc = pci_enable_device(dev);
1101         if (rc)
1102                 return rc;
1103
1104         memset(&port, 0, sizeof(port));
1105         port.ops = &serial_txx9_pops;
1106         port.flags |= UPF_TXX9_HAVE_CTS_LINE;
1107         port.uartclk = 66670000;
1108         port.irq = dev->irq;
1109         port.iotype = UPIO_PORT;
1110         port.iobase = pci_resource_start(dev, 1);
1111         port.dev = &dev->dev;
1112         line = serial_txx9_register_port(&port);
1113         if (line < 0) {
1114                 printk(KERN_WARNING "Couldn't register serial port %s: %d\n", pci_name(dev), line);
1115         }
1116         pci_set_drvdata(dev, (void *)(long)line);
1117
1118         return 0;
1119 }
1120
1121 static void __devexit pciserial_txx9_remove_one(struct pci_dev *dev)
1122 {
1123         int line = (int)(long)pci_get_drvdata(dev);
1124
1125         pci_set_drvdata(dev, NULL);
1126
1127         if (line) {
1128                 serial_txx9_unregister_port(line);
1129                 pci_disable_device(dev);
1130         }
1131 }
1132
1133 static int pciserial_txx9_suspend_one(struct pci_dev *dev, pm_message_t state)
1134 {
1135         int line = (int)(long)pci_get_drvdata(dev);
1136
1137         if (line)
1138                 serial_txx9_suspend_port(line);
1139         pci_save_state(dev);
1140         pci_set_power_state(dev, pci_choose_state(dev, state));
1141         return 0;
1142 }
1143
1144 static int pciserial_txx9_resume_one(struct pci_dev *dev)
1145 {
1146         int line = (int)(long)pci_get_drvdata(dev);
1147
1148         pci_set_power_state(dev, PCI_D0);
1149         pci_restore_state(dev);
1150
1151         if (line) {
1152                 pci_enable_device(dev);
1153                 serial_txx9_resume_port(line);
1154         }
1155         return 0;
1156 }
1157
1158 static struct pci_device_id serial_txx9_pci_tbl[] = {
1159         {       PCI_VENDOR_ID_TOSHIBA_2, PCI_DEVICE_ID_TOSHIBA_TC86C001_MISC,
1160                 PCI_ANY_ID, PCI_ANY_ID,
1161                 0, 0, 0 },
1162         { 0, }
1163 };
1164
1165 static struct pci_driver serial_txx9_pci_driver = {
1166         .name           = "serial_txx9",
1167         .probe          = pciserial_txx9_init_one,
1168         .remove         = __devexit_p(pciserial_txx9_remove_one),
1169         .suspend        = pciserial_txx9_suspend_one,
1170         .resume         = pciserial_txx9_resume_one,
1171         .id_table       = serial_txx9_pci_tbl,
1172 };
1173
1174 MODULE_DEVICE_TABLE(pci, serial_txx9_pci_tbl);
1175 #endif /* ENABLE_SERIAL_TXX9_PCI */
1176
1177 static int __init serial_txx9_init(void)
1178 {
1179         int ret;
1180
1181         printk(KERN_INFO "%s version %s\n", serial_name, serial_version);
1182
1183         ret = uart_register_driver(&serial_txx9_reg);
1184         if (ret >= 0) {
1185                 serial_txx9_register_ports(&serial_txx9_reg);
1186
1187 #ifdef ENABLE_SERIAL_TXX9_PCI
1188                 ret = pci_register_driver(&serial_txx9_pci_driver);
1189 #endif
1190         }
1191         return ret;
1192 }
1193
1194 static void __exit serial_txx9_exit(void)
1195 {
1196         int i;
1197
1198 #ifdef ENABLE_SERIAL_TXX9_PCI
1199         pci_unregister_driver(&serial_txx9_pci_driver);
1200 #endif
1201         for (i = 0; i < UART_NR; i++)
1202                 uart_remove_one_port(&serial_txx9_reg, &serial_txx9_ports[i].port);
1203
1204         uart_unregister_driver(&serial_txx9_reg);
1205 }
1206
1207 module_init(serial_txx9_init);
1208 module_exit(serial_txx9_exit);
1209
1210 MODULE_LICENSE("GPL");
1211 MODULE_DESCRIPTION("TX39/49 serial driver");
1212
1213 MODULE_ALIAS_CHARDEV_MAJOR(TXX9_TTY_MAJOR);