drivers/tty/serial/serial_ks8695.c

   1 /*
   2  *  Driver for KS8695 serial ports
   3  *
   4  *  Based on drivers/serial/serial_amba.c, by Kam Lee.
   5  *
   6  *  Copyright 2002-2005 Micrel Inc.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  */
  14 #include <linux/module.h>
  15 #include <linux/tty.h>
  16 #include <linux/tty_flip.h>
  17 #include <linux/ioport.h>
  18 #include <linux/init.h>
  19 #include <linux/serial.h>
  20 #include <linux/console.h>
  21 #include <linux/sysrq.h>
  22 #include <linux/device.h>
  23
  24 #include <asm/io.h>
  25 #include <asm/irq.h>
  26 #include <asm/mach/irq.h>
  27
  28 #include <mach/regs-uart.h>
  29 #include <mach/regs-irq.h>
  30
  31 #if defined(CONFIG_SERIAL_KS8695_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  32 #define SUPPORT_SYSRQ
  33 #endif
  34
  35 #include <linux/serial_core.h>
  36
  37
  38 #define SERIAL_KS8695_MAJOR     204
  39 #define SERIAL_KS8695_MINOR     16
  40 #define SERIAL_KS8695_DEVNAME   "ttyAM"
  41
  42 #define SERIAL_KS8695_NR        1
  43
  44 /*
  45  * Access macros for the KS8695 UART
  46  */
  47 #define UART_GET_CHAR(p)        (__raw_readl((p)->membase + KS8695_URRB) & 0xFF)
  48 #define UART_PUT_CHAR(p, c)     __raw_writel((c), (p)->membase + KS8695_URTH)
  49 #define UART_GET_FCR(p)         __raw_readl((p)->membase + KS8695_URFC)
  50 #define UART_PUT_FCR(p, c)      __raw_writel((c), (p)->membase + KS8695_URFC)
  51 #define UART_GET_MSR(p)         __raw_readl((p)->membase + KS8695_URMS)
  52 #define UART_GET_LSR(p)         __raw_readl((p)->membase + KS8695_URLS)
  53 #define UART_GET_LCR(p)         __raw_readl((p)->membase + KS8695_URLC)
  54 #define UART_PUT_LCR(p, c)      __raw_writel((c), (p)->membase + KS8695_URLC)
  55 #define UART_GET_MCR(p)         __raw_readl((p)->membase + KS8695_URMC)
  56 #define UART_PUT_MCR(p, c)      __raw_writel((c), (p)->membase + KS8695_URMC)
  57 #define UART_GET_BRDR(p)        __raw_readl((p)->membase + KS8695_URBD)
  58 #define UART_PUT_BRDR(p, c)     __raw_writel((c), (p)->membase + KS8695_URBD)
  59
  60 #define KS8695_CLR_TX_INT()     __raw_writel(1 << KS8695_IRQ_UART_TX, KS8695_IRQ_VA + KS8695_INTST)
  61
  62 #define UART_DUMMY_LSR_RX       0x100
  63 #define UART_PORT_SIZE          (KS8695_USR - KS8695_URRB + 4)
  64
  65 static inline int tx_enabled(struct uart_port *port)
  66 {
  67         return port->unused[0] & 1;
  68 }
  69
  70 static inline int rx_enabled(struct uart_port *port)
  71 {
  72         return port->unused[0] & 2;
  73 }
  74
  75 static inline int ms_enabled(struct uart_port *port)
  76 {
  77         return port->unused[0] & 4;
  78 }
  79
  80 static inline void ms_enable(struct uart_port *port, int enabled)
  81 {
  82         if(enabled)
  83                 port->unused[0] |= 4;
  84         else
  85                 port->unused[0] &= ~4;
  86 }
  87
  88 static inline void rx_enable(struct uart_port *port, int enabled)
  89 {
  90         if(enabled)
  91                 port->unused[0] |= 2;
  92         else
  93                 port->unused[0] &= ~2;
  94 }
  95
  96 static inline void tx_enable(struct uart_port *port, int enabled)
  97 {
  98         if(enabled)
  99                 port->unused[0] |= 1;
 100         else
 101                 port->unused[0] &= ~1;
 102 }
 103
 104
 105 #ifdef SUPPORT_SYSRQ
 106 static struct console ks8695_console;
 107 #endif
 108
 109 static void ks8695uart_stop_tx(struct uart_port *port)
 110 {
 111         if (tx_enabled(port)) {
 112                 /* use disable_irq_nosync() and not disable_irq() to avoid self
 113                  * imposed deadlock by not waiting for irq handler to end,
 114                  * since this ks8695uart_stop_tx() is called from interrupt context.
 115                  */
 116                 disable_irq_nosync(KS8695_IRQ_UART_TX);
 117                 tx_enable(port, 0);
 118         }
 119 }
 120
 121 static void ks8695uart_start_tx(struct uart_port *port)
 122 {
 123         if (!tx_enabled(port)) {
 124                 enable_irq(KS8695_IRQ_UART_TX);
 125                 tx_enable(port, 1);
 126         }
 127 }
 128
 129 static void ks8695uart_stop_rx(struct uart_port *port)
 130 {
 131         if (rx_enabled(port)) {
 132                 disable_irq(KS8695_IRQ_UART_RX);
 133                 rx_enable(port, 0);
 134         }
 135 }
 136
 137 static void ks8695uart_enable_ms(struct uart_port *port)
 138 {
 139         if (!ms_enabled(port)) {
 140                 enable_irq(KS8695_IRQ_UART_MODEM_STATUS);
 141                 ms_enable(port,1);
 142         }
 143 }
 144
 145 static void ks8695uart_disable_ms(struct uart_port *port)
 146 {
 147         if (ms_enabled(port)) {
 148                 disable_irq(KS8695_IRQ_UART_MODEM_STATUS);
 149                 ms_enable(port,0);
 150         }
 151 }
 152
 153 static irqreturn_t ks8695uart_rx_chars(int irq, void *dev_id)
 154 {
 155         struct uart_port *port = dev_id;
 156         struct tty_struct *tty = port->state->port.tty;
 157         unsigned int status, ch, lsr, flg, max_count = 256;
 158
 159         status = UART_GET_LSR(port);            /* clears pending LSR interrupts */
 160         while ((status & URLS_URDR) && max_count--) {
 161                 ch = UART_GET_CHAR(port);
 162                 flg = TTY_NORMAL;
 163
 164                 port->icount.rx++;
 165
 166                 /*
 167                  * Note that the error handling code is
 168                  * out of the main execution path
 169                  */
 170                 lsr = UART_GET_LSR(port) | UART_DUMMY_LSR_RX;
 171                 if (unlikely(lsr & (URLS_URBI | URLS_URPE | URLS_URFE | URLS_URROE))) {
 172                         if (lsr & URLS_URBI) {
 173                                 lsr &= ~(URLS_URFE | URLS_URPE);
 174                                 port->icount.brk++;
 175                                 if (uart_handle_break(port))
 176                                         goto ignore_char;
 177                         }
 178                         if (lsr & URLS_URPE)
 179                                 port->icount.parity++;
 180                         if (lsr & URLS_URFE)
 181                                 port->icount.frame++;
 182                         if (lsr & URLS_URROE)
 183                                 port->icount.overrun++;
 184
 185                         lsr &= port->read_status_mask;
 186
 187                         if (lsr & URLS_URBI)
 188                                 flg = TTY_BREAK;
 189                         else if (lsr & URLS_URPE)
 190                                 flg = TTY_PARITY;
 191                         else if (lsr & URLS_URFE)
 192                                 flg = TTY_FRAME;
 193                 }
 194
 195                 if (uart_handle_sysrq_char(port, ch))
 196                         goto ignore_char;
 197
 198                 uart_insert_char(port, lsr, URLS_URROE, ch, flg);
 199
 200 ignore_char:
 201                 status = UART_GET_LSR(port);
 202         }
 203         tty_flip_buffer_push(tty);
 204
 205         return IRQ_HANDLED;
 206 }
 207
 208
 209 static irqreturn_t ks8695uart_tx_chars(int irq, void *dev_id)
 210 {
 211         struct uart_port *port = dev_id;
 212         struct circ_buf *xmit = &port->state->xmit;
 213         unsigned int count;
 214
 215         if (port->x_char) {
 216                 KS8695_CLR_TX_INT();
 217                 UART_PUT_CHAR(port, port->x_char);
 218                 port->icount.tx++;
 219                 port->x_char = 0;
 220                 return IRQ_HANDLED;
 221         }
 222
 223         if (uart_tx_stopped(port) || uart_circ_empty(xmit)) {
 224                 ks8695uart_stop_tx(port);
 225                 return IRQ_HANDLED;
 226         }
 227
 228         count = 16;     /* fifo size */
 229         while (!uart_circ_empty(xmit) && (count-- > 0)) {
 230                 KS8695_CLR_TX_INT();
 231                 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
 232
 233                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 234                 port->icount.tx++;
 235         }
 236
 237         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 238                 uart_write_wakeup(port);
 239
 240         if (uart_circ_empty(xmit))
 241                 ks8695uart_stop_tx(port);
 242
 243         return IRQ_HANDLED;
 244 }
 245
 246 static irqreturn_t ks8695uart_modem_status(int irq, void *dev_id)
 247 {
 248         struct uart_port *port = dev_id;
 249         unsigned int status;
 250
 251         /*
 252          * clear modem interrupt by reading MSR
 253          */
 254         status = UART_GET_MSR(port);
 255
 256         if (status & URMS_URDDCD)
 257                 uart_handle_dcd_change(port, status & URMS_URDDCD);
 258
 259         if (status & URMS_URDDST)
 260                 port->icount.dsr++;
 261
 262         if (status & URMS_URDCTS)
 263                 uart_handle_cts_change(port, status & URMS_URDCTS);
 264
 265         if (status & URMS_URTERI)
 266                 port->icount.rng++;
 267
 268         wake_up_interruptible(&port->state->port.delta_msr_wait);
 269
 270         return IRQ_HANDLED;
 271 }
 272
 273 static unsigned int ks8695uart_tx_empty(struct uart_port *port)
 274 {
 275         return (UART_GET_LSR(port) & URLS_URTE) ? TIOCSER_TEMT : 0;
 276 }
 277
 278 static unsigned int ks8695uart_get_mctrl(struct uart_port *port)
 279 {
 280         unsigned int result = 0;
 281         unsigned int status;
 282
 283         status = UART_GET_MSR(port);
 284         if (status & URMS_URDCD)
 285                 result |= TIOCM_CAR;
 286         if (status & URMS_URDSR)
 287                 result |= TIOCM_DSR;
 288         if (status & URMS_URCTS)
 289                 result |= TIOCM_CTS;
 290         if (status & URMS_URRI)
 291                 result |= TIOCM_RI;
 292
 293         return result;
 294 }
 295
 296 static void ks8695uart_set_mctrl(struct uart_port *port, u_int mctrl)
 297 {
 298         unsigned int mcr;
 299
 300         mcr = UART_GET_MCR(port);
 301         if (mctrl & TIOCM_RTS)
 302                 mcr |= URMC_URRTS;
 303         else
 304                 mcr &= ~URMC_URRTS;
 305
 306         if (mctrl & TIOCM_DTR)
 307                 mcr |= URMC_URDTR;
 308         else
 309                 mcr &= ~URMC_URDTR;
 310
 311         UART_PUT_MCR(port, mcr);
 312 }
 313
 314 static void ks8695uart_break_ctl(struct uart_port *port, int break_state)
 315 {
 316         unsigned int lcr;
 317
 318         lcr = UART_GET_LCR(port);
 319
 320         if (break_state == -1)
 321                 lcr |= URLC_URSBC;
 322         else
 323                 lcr &= ~URLC_URSBC;
 324
 325         UART_PUT_LCR(port, lcr);
 326 }
 327
 328 static int ks8695uart_startup(struct uart_port *port)
 329 {
 330         int retval;
 331
 332         set_irq_flags(KS8695_IRQ_UART_TX, IRQF_VALID | IRQF_NOAUTOEN);
 333         tx_enable(port, 0);
 334         rx_enable(port, 1);
 335         ms_enable(port, 1);
 336
 337         /*
 338          * Allocate the IRQ
 339          */
 340         retval = request_irq(KS8695_IRQ_UART_TX, ks8695uart_tx_chars, IRQF_DISABLED, "UART TX", port);
 341         if (retval)
 342                 goto err_tx;
 343
 344         retval = request_irq(KS8695_IRQ_UART_RX, ks8695uart_rx_chars, IRQF_DISABLED, "UART RX", port);
 345         if (retval)
 346                 goto err_rx;
 347
 348         retval = request_irq(KS8695_IRQ_UART_LINE_STATUS, ks8695uart_rx_chars, IRQF_DISABLED, "UART LineStatus", port);
 349         if (retval)
 350                 goto err_ls;
 351
 352         retval = request_irq(KS8695_IRQ_UART_MODEM_STATUS, ks8695uart_modem_status, IRQF_DISABLED, "UART ModemStatus", port);
 353         if (retval)
 354                 goto err_ms;
 355
 356         return 0;
 357
 358 err_ms:
 359         free_irq(KS8695_IRQ_UART_LINE_STATUS, port);
 360 err_ls:
 361         free_irq(KS8695_IRQ_UART_RX, port);
 362 err_rx:
 363         free_irq(KS8695_IRQ_UART_TX, port);
 364 err_tx:
 365         return retval;
 366 }
 367
 368 static void ks8695uart_shutdown(struct uart_port *port)
 369 {
 370         /*
 371          * Free the interrupt
 372          */
 373         free_irq(KS8695_IRQ_UART_RX, port);
 374         free_irq(KS8695_IRQ_UART_TX, port);
 375         free_irq(KS8695_IRQ_UART_MODEM_STATUS, port);
 376         free_irq(KS8695_IRQ_UART_LINE_STATUS, port);
 377
 378         /* disable break condition and fifos */
 379         UART_PUT_LCR(port, UART_GET_LCR(port) & ~URLC_URSBC);
 380         UART_PUT_FCR(port, UART_GET_FCR(port) & ~URFC_URFE);
 381 }
 382
 383 static void ks8695uart_set_termios(struct uart_port *port, struct ktermios *termios, struct ktermios *old)
 384 {
 385         unsigned int lcr, fcr = 0;
 386         unsigned long flags;
 387         unsigned int baud, quot;
 388
 389         /*
 390          * Ask the core to calculate the divisor for us.
 391          */
 392         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
 393         quot = uart_get_divisor(port, baud);
 394
 395         switch (termios->c_cflag & CSIZE) {
 396         case CS5:
 397                 lcr = URCL_5;
 398                 break;
 399         case CS6:
 400                 lcr = URCL_6;
 401                 break;
 402         case CS7:
 403                 lcr = URCL_7;
 404                 break;
 405         default:
 406                 lcr = URCL_8;
 407                 break;
 408         }
 409
 410         /* stop bits */
 411         if (termios->c_cflag & CSTOPB)
 412                 lcr |= URLC_URSB;
 413
 414         /* parity */
 415         if (termios->c_cflag & PARENB) {
 416                 if (termios->c_cflag & CMSPAR) {        /* Mark or Space parity */
 417                         if (termios->c_cflag & PARODD)
 418                                 lcr |= URPE_MARK;
 419                         else
 420                                 lcr |= URPE_SPACE;
 421                 }
 422                 else if (termios->c_cflag & PARODD)
 423                         lcr |= URPE_ODD;
 424                 else
 425                         lcr |= URPE_EVEN;
 426         }
 427
 428         if (port->fifosize > 1)
 429                 fcr = URFC_URFRT_8 | URFC_URTFR | URFC_URRFR | URFC_URFE;
 430
 431         spin_lock_irqsave(&port->lock, flags);
 432
 433         /*
 434          * Update the per-port timeout.
 435          */
 436         uart_update_timeout(port, termios->c_cflag, baud);
 437
 438         port->read_status_mask = URLS_URROE;
 439         if (termios->c_iflag & INPCK)
 440                 port->read_status_mask |= (URLS_URFE | URLS_URPE);
 441         if (termios->c_iflag & (BRKINT | PARMRK))
 442                 port->read_status_mask |= URLS_URBI;
 443
 444         /*
 445          * Characters to ignore
 446          */
 447         port->ignore_status_mask = 0;
 448         if (termios->c_iflag & IGNPAR)
 449                 port->ignore_status_mask |= (URLS_URFE | URLS_URPE);
 450         if (termios->c_iflag & IGNBRK) {
 451                 port->ignore_status_mask |= URLS_URBI;
 452                 /*
 453                  * If we're ignoring parity and break indicators,
 454                  * ignore overruns too (for real raw support).
 455                  */
 456                 if (termios->c_iflag & IGNPAR)
 457                         port->ignore_status_mask |= URLS_URROE;
 458         }
 459
 460         /*
 461          * Ignore all characters if CREAD is not set.
 462          */
 463         if ((termios->c_cflag & CREAD) == 0)
 464                 port->ignore_status_mask |= UART_DUMMY_LSR_RX;
 465
 466         /* first, disable everything */
 467         if (UART_ENABLE_MS(port, termios->c_cflag))
 468                 ks8695uart_enable_ms(port);
 469         else
 470                 ks8695uart_disable_ms(port);
 471
 472         /* Set baud rate */
 473         UART_PUT_BRDR(port, quot);
 474
 475         UART_PUT_LCR(port, lcr);
 476         UART_PUT_FCR(port, fcr);
 477
 478         spin_unlock_irqrestore(&port->lock, flags);
 479 }
 480
 481 static const char *ks8695uart_type(struct uart_port *port)
 482 {
 483         return port->type == PORT_KS8695 ? "KS8695" : NULL;
 484 }
 485
 486 /*
 487  * Release the memory region(s) being used by 'port'
 488  */
 489 static void ks8695uart_release_port(struct uart_port *port)
 490 {
 491         release_mem_region(port->mapbase, UART_PORT_SIZE);
 492 }
 493
 494 /*
 495  * Request the memory region(s) being used by 'port'
 496  */
 497 static int ks8695uart_request_port(struct uart_port *port)
 498 {
 499         return request_mem_region(port->mapbase, UART_PORT_SIZE,
 500                         "serial_ks8695") != NULL ? 0 : -EBUSY;
 501 }
 502
 503 /*
 504  * Configure/autoconfigure the port.
 505  */
 506 static void ks8695uart_config_port(struct uart_port *port, int flags)
 507 {
 508         if (flags & UART_CONFIG_TYPE) {
 509                 port->type = PORT_KS8695;
 510                 ks8695uart_request_port(port);
 511         }
 512 }
 513
 514 /*
 515  * verify the new serial_struct (for TIOCSSERIAL).
 516  */
 517 static int ks8695uart_verify_port(struct uart_port *port, struct serial_struct *ser)
 518 {
 519         int ret = 0;
 520
 521         if (ser->type != PORT_UNKNOWN && ser->type != PORT_KS8695)
 522                 ret = -EINVAL;
 523         if (ser->irq != port->irq)
 524                 ret = -EINVAL;
 525         if (ser->baud_base < 9600)
 526                 ret = -EINVAL;
 527         return ret;
 528 }
 529
 530 static struct uart_ops ks8695uart_pops = {
 531         .tx_empty       = ks8695uart_tx_empty,
 532         .set_mctrl      = ks8695uart_set_mctrl,
 533         .get_mctrl      = ks8695uart_get_mctrl,
 534         .stop_tx        = ks8695uart_stop_tx,
 535         .start_tx       = ks8695uart_start_tx,
 536         .stop_rx        = ks8695uart_stop_rx,
 537         .enable_ms      = ks8695uart_enable_ms,
 538         .break_ctl      = ks8695uart_break_ctl,
 539         .startup        = ks8695uart_startup,
 540         .shutdown       = ks8695uart_shutdown,
 541         .set_termios    = ks8695uart_set_termios,
 542         .type           = ks8695uart_type,
 543         .release_port   = ks8695uart_release_port,
 544         .request_port   = ks8695uart_request_port,
 545         .config_port    = ks8695uart_config_port,
 546         .verify_port    = ks8695uart_verify_port,
 547 };
 548
 549 static struct uart_port ks8695uart_ports[SERIAL_KS8695_NR] = {
 550         {
 551                 .membase        = (void *) KS8695_UART_VA,
 552                 .mapbase        = KS8695_UART_VA,
 553                 .iotype         = SERIAL_IO_MEM,
 554                 .irq            = KS8695_IRQ_UART_TX,
 555                 .uartclk        = KS8695_CLOCK_RATE * 16,
 556                 .fifosize       = 16,
 557                 .ops            = &ks8695uart_pops,
 558                 .flags          = ASYNC_BOOT_AUTOCONF,
 559                 .line           = 0,
 560         }
 561 };
 562
 563 #ifdef CONFIG_SERIAL_KS8695_CONSOLE
 564 static void ks8695_console_putchar(struct uart_port *port, int ch)
 565 {
 566         while (!(UART_GET_LSR(port) & URLS_URTHRE))
 567                 barrier();
 568
 569         UART_PUT_CHAR(port, ch);
 570 }
 571
 572 static void ks8695_console_write(struct console *co, const char *s, u_int count)
 573 {
 574         struct uart_port *port = ks8695uart_ports + co->index;
 575
 576         uart_console_write(port, s, count, ks8695_console_putchar);
 577 }
 578
 579 static void __init ks8695_console_get_options(struct uart_port *port, int *baud, int *parity, int *bits)
 580 {
 581         unsigned int lcr;
 582
 583         lcr = UART_GET_LCR(port);
 584
 585         switch (lcr & URLC_PARITY) {
 586                 case URPE_ODD:
 587                         *parity = 'o';
 588                         break;
 589                 case URPE_EVEN:
 590                         *parity = 'e';
 591                         break;
 592                 default:
 593                         *parity = 'n';
 594         }
 595
 596         switch (lcr & URLC_URCL) {
 597                 case URCL_5:
 598                         *bits = 5;
 599                         break;
 600                 case URCL_6:
 601                         *bits = 6;
 602                         break;
 603                 case URCL_7:
 604                         *bits = 7;
 605                         break;
 606                 default:
 607                         *bits = 8;
 608         }
 609
 610         *baud = port->uartclk / (UART_GET_BRDR(port) & 0x0FFF);
 611         *baud /= 16;
 612         *baud &= 0xFFFFFFF0;
 613 }
 614
 615 static int __init ks8695_console_setup(struct console *co, char *options)
 616 {
 617         struct uart_port *port;
 618         int baud = 115200;
 619         int bits = 8;
 620         int parity = 'n';
 621         int flow = 'n';
 622
 623         /*
 624          * Check whether an invalid uart number has been specified, and
 625          * if so, search for the first available port that does have
 626          * console support.
 627          */
 628         port = uart_get_console(ks8695uart_ports, SERIAL_KS8695_NR, co);
 629
 630         if (options)
 631                 uart_parse_options(options, &baud, &parity, &bits, &flow);
 632         else
 633                 ks8695_console_get_options(port, &baud, &parity, &bits);
 634
 635         return uart_set_options(port, co, baud, parity, bits, flow);
 636 }
 637
 638 static struct uart_driver ks8695_reg;
 639
 640 static struct console ks8695_console = {
 641         .name           = SERIAL_KS8695_DEVNAME,
 642         .write          = ks8695_console_write,
 643         .device         = uart_console_device,
 644         .setup          = ks8695_console_setup,
 645         .flags          = CON_PRINTBUFFER,
 646         .index          = -1,
 647         .data           = &ks8695_reg,
 648 };
 649
 650 static int __init ks8695_console_init(void)
 651 {
 652         add_preferred_console(SERIAL_KS8695_DEVNAME, 0, NULL);
 653         register_console(&ks8695_console);
 654         return 0;
 655 }
 656
 657 console_initcall(ks8695_console_init);
 658
 659 #define KS8695_CONSOLE  &ks8695_console
 660 #else
 661 #define KS8695_CONSOLE  NULL
 662 #endif
 663
 664 static struct uart_driver ks8695_reg = {
 665         .owner                  = THIS_MODULE,
 666         .driver_name            = "serial_ks8695",
 667         .dev_name               = SERIAL_KS8695_DEVNAME,
 668         .major                  = SERIAL_KS8695_MAJOR,
 669         .minor                  = SERIAL_KS8695_MINOR,
 670         .nr                     = SERIAL_KS8695_NR,
 671         .cons                   = KS8695_CONSOLE,
 672 };
 673
 674 static int __init ks8695uart_init(void)
 675 {
 676         int i, ret;
 677
 678         printk(KERN_INFO "Serial: Micrel KS8695 UART driver\n");
 679
 680         ret = uart_register_driver(&ks8695_reg);
 681         if (ret)
 682                 return ret;
 683
 684         for (i = 0; i < SERIAL_KS8695_NR; i++)
 685                 uart_add_one_port(&ks8695_reg, &ks8695uart_ports[0]);
 686
 687         return 0;
 688 }
 689
 690 static void __exit ks8695uart_exit(void)
 691 {
 692         int i;
 693
 694         for (i = 0; i < SERIAL_KS8695_NR; i++)
 695                 uart_remove_one_port(&ks8695_reg, &ks8695uart_ports[0]);
 696         uart_unregister_driver(&ks8695_reg);
 697 }
 698
 699 module_init(ks8695uart_init);
 700 module_exit(ks8695uart_exit);
 701
 702 MODULE_DESCRIPTION("KS8695 serial port driver");
 703 MODULE_AUTHOR("Micrel Inc.");
 704 MODULE_LICENSE("GPL");