drivers/serial/at91_serial.c

   1 /*
   2  *  linux/drivers/char/at91_serial.c
   3  *
   4  *  Driver for Atmel AT91RM9200 Serial ports
   5  *  Copyright (C) 2003 Rick Bronson
   6  *
   7  *  Based on drivers/char/serial_sa1100.c, by Deep Blue Solutions Ltd.
   8  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  *
  24  */
  25 #include <linux/module.h>
  26 #include <linux/tty.h>
  27 #include <linux/ioport.h>
  28 #include <linux/slab.h>
  29 #include <linux/init.h>
  30 #include <linux/serial.h>
  31 #include <linux/clk.h>
  32 #include <linux/console.h>
  33 #include <linux/sysrq.h>
  34 #include <linux/tty_flip.h>
  35 #include <linux/platform_device.h>
  36
  37 #include <asm/io.h>
  38
  39 #include <asm/arch/at91rm9200_usart.h>
  40 #include <asm/arch/at91rm9200_pdc.h>
  41 #include <asm/mach/serial_at91.h>
  42 #include <asm/arch/board.h>
  43 #include <asm/arch/system.h>
  44
  45 #if defined(CONFIG_SERIAL_AT91_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  46 #define SUPPORT_SYSRQ
  47 #endif
  48
  49 #include <linux/serial_core.h>
  50
  51 #ifdef CONFIG_SERIAL_AT91_TTYAT
  52
  53 /* Use device name ttyAT, major 204 and minor 154-169.  This is necessary if we
  54  * should coexist with the 8250 driver, such as if we have an external 16C550
  55  * UART. */
  56 #define SERIAL_AT91_MAJOR       204
  57 #define MINOR_START             154
  58 #define AT91_DEVICENAME         "ttyAT"
  59
  60 #else
  61
  62 /* Use device name ttyS, major 4, minor 64-68.  This is the usual serial port
  63  * name, but it is legally reserved for the 8250 driver. */
  64 #define SERIAL_AT91_MAJOR       TTY_MAJOR
  65 #define MINOR_START             64
  66 #define AT91_DEVICENAME         "ttyS"
  67
  68 #endif
  69
  70 #define AT91_ISR_PASS_LIMIT     256
  71
  72 #define UART_PUT_CR(port,v)     writel(v, (port)->membase + AT91_US_CR)
  73 #define UART_GET_MR(port)       readl((port)->membase + AT91_US_MR)
  74 #define UART_PUT_MR(port,v)     writel(v, (port)->membase + AT91_US_MR)
  75 #define UART_PUT_IER(port,v)    writel(v, (port)->membase + AT91_US_IER)
  76 #define UART_PUT_IDR(port,v)    writel(v, (port)->membase + AT91_US_IDR)
  77 #define UART_GET_IMR(port)      readl((port)->membase + AT91_US_IMR)
  78 #define UART_GET_CSR(port)      readl((port)->membase + AT91_US_CSR)
  79 #define UART_GET_CHAR(port)     readl((port)->membase + AT91_US_RHR)
  80 #define UART_PUT_CHAR(port,v)   writel(v, (port)->membase + AT91_US_THR)
  81 #define UART_GET_BRGR(port)     readl((port)->membase + AT91_US_BRGR)
  82 #define UART_PUT_BRGR(port,v)   writel(v, (port)->membase + AT91_US_BRGR)
  83 #define UART_PUT_RTOR(port,v)   writel(v, (port)->membase + AT91_US_RTOR)
  84
  85 // #define UART_GET_CR(port)    readl((port)->membase + AT91_US_CR)             // is write-only
  86
  87  /* PDC registers */
  88 #define UART_PUT_PTCR(port,v)   writel(v, (port)->membase + AT91_PDC_PTCR)
  89 #define UART_GET_PTSR(port)     readl((port)->membase + AT91_PDC_PTSR)
  90
  91 #define UART_PUT_RPR(port,v)    writel(v, (port)->membase + AT91_PDC_RPR)
  92 #define UART_GET_RPR(port)      readl((port)->membase + AT91_PDC_RPR)
  93 #define UART_PUT_RCR(port,v)    writel(v, (port)->membase + AT91_PDC_RCR)
  94 #define UART_PUT_RNPR(port,v)   writel(v, (port)->membase + AT91_PDC_RNPR)
  95 #define UART_PUT_RNCR(port,v)   writel(v, (port)->membase + AT91_PDC_RNCR)
  96
  97 #define UART_PUT_TPR(port,v)    writel(v, (port)->membase + AT91_PDC_TPR)
  98 #define UART_PUT_TCR(port,v)    writel(v, (port)->membase + AT91_PDC_TCR)
  99 //#define UART_PUT_TNPR(port,v) writel(v, (port)->membase + AT91_PDC_TNPR)
 100 //#define UART_PUT_TNCR(port,v) writel(v, (port)->membase + AT91_PDC_TNCR)
 101
 102 static int (*at91_open)(struct uart_port *);
 103 static void (*at91_close)(struct uart_port *);
 104
 105 /*
 106  * We wrap our port structure around the generic uart_port.
 107  */
 108 struct at91_uart_port {
 109         struct uart_port        uart;           /* uart */
 110         struct clk              *clk;           /* uart clock */
 111         unsigned short          suspended;      /* is port suspended? */
 112 };
 113
 114 static struct at91_uart_port at91_ports[AT91_NR_UART];
 115
 116 #ifdef SUPPORT_SYSRQ
 117 static struct console at91_console;
 118 #endif
 119
 120 /*
 121  * Return TIOCSER_TEMT when transmitter FIFO and Shift register is empty.
 122  */
 123 static u_int at91_tx_empty(struct uart_port *port)
 124 {
 125         return (UART_GET_CSR(port) & AT91_US_TXEMPTY) ? TIOCSER_TEMT : 0;
 126 }
 127
 128 /*
 129  * Set state of the modem control output lines
 130  */
 131 static void at91_set_mctrl(struct uart_port *port, u_int mctrl)
 132 {
 133         unsigned int control = 0;
 134         unsigned int mode;
 135
 136         if (arch_identify() == ARCH_ID_AT91RM9200) {
 137                 /*
 138                  * AT91RM9200 Errata #39: RTS0 is not internally connected to PA21.
 139                  *  We need to drive the pin manually.
 140                  */
 141                 if (port->mapbase == AT91_BASE_US0) {
 142                         if (mctrl & TIOCM_RTS)
 143                                 at91_sys_write(AT91_PIOA + PIO_CODR, AT91_PA21_RTS0);
 144                         else
 145                                 at91_sys_write(AT91_PIOA + PIO_SODR, AT91_PA21_RTS0);
 146                 }
 147         }
 148
 149         if (mctrl & TIOCM_RTS)
 150                 control |= AT91_US_RTSEN;
 151         else
 152                 control |= AT91_US_RTSDIS;
 153
 154         if (mctrl & TIOCM_DTR)
 155                 control |= AT91_US_DTREN;
 156         else
 157                 control |= AT91_US_DTRDIS;
 158
 159         UART_PUT_CR(port, control);
 160
 161         /* Local loopback mode? */
 162         mode = UART_GET_MR(port) & ~AT91_US_CHMODE;
 163         if (mctrl & TIOCM_LOOP)
 164                 mode |= AT91_US_CHMODE_LOC_LOOP;
 165         else
 166                 mode |= AT91_US_CHMODE_NORMAL;
 167         UART_PUT_MR(port, mode);
 168 }
 169
 170 /*
 171  * Get state of the modem control input lines
 172  */
 173 static u_int at91_get_mctrl(struct uart_port *port)
 174 {
 175         unsigned int status, ret = 0;
 176
 177         status = UART_GET_CSR(port);
 178
 179         /*
 180          * The control signals are active low.
 181          */
 182         if (!(status & AT91_US_DCD))
 183                 ret |= TIOCM_CD;
 184         if (!(status & AT91_US_CTS))
 185                 ret |= TIOCM_CTS;
 186         if (!(status & AT91_US_DSR))
 187                 ret |= TIOCM_DSR;
 188         if (!(status & AT91_US_RI))
 189                 ret |= TIOCM_RI;
 190
 191         return ret;
 192 }
 193
 194 /*
 195  * Stop transmitting.
 196  */
 197 static void at91_stop_tx(struct uart_port *port)
 198 {
 199         struct at91_uart_port *at91_port = (struct at91_uart_port *) port;
 200
 201         UART_PUT_IDR(port, AT91_US_TXRDY);
 202 }
 203
 204 /*
 205  * Start transmitting.
 206  */
 207 static void at91_start_tx(struct uart_port *port)
 208 {
 209         struct at91_uart_port *at91_port = (struct at91_uart_port *) port;
 210
 211         UART_PUT_IER(port, AT91_US_TXRDY);
 212 }
 213
 214 /*
 215  * Stop receiving - port is in process of being closed.
 216  */
 217 static void at91_stop_rx(struct uart_port *port)
 218 {
 219         struct at91_uart_port *at91_port = (struct at91_uart_port *) port;
 220
 221         UART_PUT_IDR(port, AT91_US_RXRDY);
 222 }
 223
 224 /*
 225  * Enable modem status interrupts
 226  */
 227 static void at91_enable_ms(struct uart_port *port)
 228 {
 229         UART_PUT_IER(port, AT91_US_RIIC | AT91_US_DSRIC | AT91_US_DCDIC | AT91_US_CTSIC);
 230 }
 231
 232 /*
 233  * Control the transmission of a break signal
 234  */
 235 static void at91_break_ctl(struct uart_port *port, int break_state)
 236 {
 237         if (break_state != 0)
 238                 UART_PUT_CR(port, AT91_US_STTBRK);      /* start break */
 239         else
 240                 UART_PUT_CR(port, AT91_US_STPBRK);      /* stop break */
 241 }
 242
 243 /*
 244  * Characters received (called from interrupt handler)
 245  */
 246 static void at91_rx_chars(struct uart_port *port, struct pt_regs *regs)
 247 {
 248         struct tty_struct *tty = port->info->tty;
 249         unsigned int status, ch, flg;
 250
 251         status = UART_GET_CSR(port);
 252         while (status & AT91_US_RXRDY) {
 253                 ch = UART_GET_CHAR(port);
 254
 255                 port->icount.rx++;
 256
 257                 flg = TTY_NORMAL;
 258
 259                 /*
 260                  * note that the error handling code is
 261                  * out of the main execution path
 262                  */
 263                 if (unlikely(status & (AT91_US_PARE | AT91_US_FRAME | AT91_US_OVRE | AT91_US_RXBRK))) {
 264                         UART_PUT_CR(port, AT91_US_RSTSTA);      /* clear error */
 265                         if (status & AT91_US_RXBRK) {
 266                                 status &= ~(AT91_US_PARE | AT91_US_FRAME);      /* ignore side-effect */
 267                                 port->icount.brk++;
 268                                 if (uart_handle_break(port))
 269                                         goto ignore_char;
 270                         }
 271                         if (status & AT91_US_PARE)
 272                                 port->icount.parity++;
 273                         if (status & AT91_US_FRAME)
 274                                 port->icount.frame++;
 275                         if (status & AT91_US_OVRE)
 276                                 port->icount.overrun++;
 277
 278                         status &= port->read_status_mask;
 279
 280                         if (status & AT91_US_RXBRK)
 281                                 flg = TTY_BREAK;
 282                         else if (status & AT91_US_PARE)
 283                                 flg = TTY_PARITY;
 284                         else if (status & AT91_US_FRAME)
 285                                 flg = TTY_FRAME;
 286                 }
 287
 288                 if (uart_handle_sysrq_char(port, ch, regs))
 289                         goto ignore_char;
 290
 291                 uart_insert_char(port, status, AT91_US_OVRE, ch, flg);
 292
 293         ignore_char:
 294                 status = UART_GET_CSR(port);
 295         }
 296
 297         tty_flip_buffer_push(tty);
 298 }
 299
 300 /*
 301  * Transmit characters (called from interrupt handler)
 302  */
 303 static void at91_tx_chars(struct uart_port *port)
 304 {
 305         struct circ_buf *xmit = &port->info->xmit;
 306
 307         if (port->x_char) {
 308                 UART_PUT_CHAR(port, port->x_char);
 309                 port->icount.tx++;
 310                 port->x_char = 0;
 311                 return;
 312         }
 313         if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
 314                 at91_stop_tx(port);
 315                 return;
 316         }
 317
 318         while (UART_GET_CSR(port) & AT91_US_TXRDY) {
 319                 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
 320                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 321                 port->icount.tx++;
 322                 if (uart_circ_empty(xmit))
 323                         break;
 324         }
 325
 326         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 327                 uart_write_wakeup(port);
 328
 329         if (uart_circ_empty(xmit))
 330                 at91_stop_tx(port);
 331 }
 332
 333 /*
 334  * Interrupt handler
 335  */
 336 static irqreturn_t at91_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 337 {
 338         struct uart_port *port = dev_id;
 339         struct at91_uart_port *at91_port = (struct at91_uart_port *) port;
 340         unsigned int status, pending, pass_counter = 0;
 341
 342         status = UART_GET_CSR(port);
 343         pending = status & UART_GET_IMR(port);
 344         while (pending) {
 345                 /* Interrupt receive */
 346                 if (pending & AT91_US_RXRDY)
 347                         at91_rx_chars(port, regs);
 348
 349                 // TODO: All reads to CSR will clear these interrupts!
 350                 if (pending & AT91_US_RIIC) port->icount.rng++;
 351                 if (pending & AT91_US_DSRIC) port->icount.dsr++;
 352                 if (pending & AT91_US_DCDIC)
 353                         uart_handle_dcd_change(port, !(status & AT91_US_DCD));
 354                 if (pending & AT91_US_CTSIC)
 355                         uart_handle_cts_change(port, !(status & AT91_US_CTS));
 356                 if (pending & (AT91_US_RIIC | AT91_US_DSRIC | AT91_US_DCDIC | AT91_US_CTSIC))
 357                         wake_up_interruptible(&port->info->delta_msr_wait);
 358
 359                 /* Interrupt transmit */
 360                 if (pending & AT91_US_TXRDY)
 361                         at91_tx_chars(port);
 362
 363                 if (pass_counter++ > AT91_ISR_PASS_LIMIT)
 364                         break;
 365
 366                 status = UART_GET_CSR(port);
 367                 pending = status & UART_GET_IMR(port);
 368         }
 369         return IRQ_HANDLED;
 370 }
 371
 372 /*
 373  * Perform initialization and enable port for reception
 374  */
 375 static int at91_startup(struct uart_port *port)
 376 {
 377         struct at91_uart_port *at91_port = (struct at91_uart_port *) port;
 378         int retval;
 379
 380         /*
 381          * Ensure that no interrupts are enabled otherwise when
 382          * request_irq() is called we could get stuck trying to
 383          * handle an unexpected interrupt
 384          */
 385         UART_PUT_IDR(port, -1);
 386
 387         /*
 388          * Allocate the IRQ
 389          */
 390         retval = request_irq(port->irq, at91_interrupt, IRQF_SHARED, "at91_serial", port);
 391         if (retval) {
 392                 printk("at91_serial: at91_startup - Can't get irq\n");
 393                 return retval;
 394         }
 395
 396         /*
 397          * If there is a specific "open" function (to register
 398          * control line interrupts)
 399          */
 400         if (at91_open) {
 401                 retval = at91_open(port);
 402                 if (retval) {
 403                         free_irq(port->irq, port);
 404                         return retval;
 405                 }
 406         }
 407
 408         /*
 409          * Finally, enable the serial port
 410          */
 411         UART_PUT_CR(port, AT91_US_RSTSTA | AT91_US_RSTRX);
 412         UART_PUT_CR(port, AT91_US_TXEN | AT91_US_RXEN);         /* enable xmit & rcvr */
 413
 414         UART_PUT_IER(port, AT91_US_RXRDY);              /* enable receive only */
 415
 416         return 0;
 417 }
 418
 419 /*
 420  * Disable the port
 421  */
 422 static void at91_shutdown(struct uart_port *port)
 423 {
 424         struct at91_uart_port *at91_port = (struct at91_uart_port *) port;
 425
 426         /*
 427          * Disable all interrupts, port and break condition.
 428          */
 429         UART_PUT_CR(port, AT91_US_RSTSTA);
 430         UART_PUT_IDR(port, -1);
 431
 432         /*
 433          * Free the interrupt
 434          */
 435         free_irq(port->irq, port);
 436
 437         /*
 438          * If there is a specific "close" function (to unregister
 439          * control line interrupts)
 440          */
 441         if (at91_close)
 442                 at91_close(port);
 443 }
 444
 445 /*
 446  * Power / Clock management.
 447  */
 448 static void at91_serial_pm(struct uart_port *port, unsigned int state, unsigned int oldstate)
 449 {
 450         struct at91_uart_port *at91_port = (struct at91_uart_port *) port;
 451
 452         switch (state) {
 453                 case 0:
 454                         /*
 455                          * Enable the peripheral clock for this serial port.
 456                          * This is called on uart_open() or a resume event.
 457                          */
 458                         clk_enable(at91_port->clk);
 459                         break;
 460                 case 3:
 461                         /*
 462                          * Disable the peripheral clock for this serial port.
 463                          * This is called on uart_close() or a suspend event.
 464                          */
 465                         clk_disable(at91_port->clk);
 466                         break;
 467                 default:
 468                         printk(KERN_ERR "at91_serial: unknown pm %d\n", state);
 469         }
 470 }
 471
 472 /*
 473  * Change the port parameters
 474  */
 475 static void at91_set_termios(struct uart_port *port, struct termios * termios, struct termios * old)
 476 {
 477         unsigned long flags;
 478         unsigned int mode, imr, quot, baud;
 479
 480         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
 481         quot = uart_get_divisor(port, baud);
 482
 483         /* Get current mode register */
 484         mode = UART_GET_MR(port) & ~(AT91_US_CHRL | AT91_US_NBSTOP | AT91_US_PAR);
 485
 486         /* byte size */
 487         switch (termios->c_cflag & CSIZE) {
 488         case CS5:
 489                 mode |= AT91_US_CHRL_5;
 490                 break;
 491         case CS6:
 492                 mode |= AT91_US_CHRL_6;
 493                 break;
 494         case CS7:
 495                 mode |= AT91_US_CHRL_7;
 496                 break;
 497         default:
 498                 mode |= AT91_US_CHRL_8;
 499                 break;
 500         }
 501
 502         /* stop bits */
 503         if (termios->c_cflag & CSTOPB)
 504                 mode |= AT91_US_NBSTOP_2;
 505
 506         /* parity */
 507         if (termios->c_cflag & PARENB) {
 508                 if (termios->c_cflag & CMSPAR) {                        /* Mark or Space parity */
 509                         if (termios->c_cflag & PARODD)
 510                                 mode |= AT91_US_PAR_MARK;
 511                         else
 512                                 mode |= AT91_US_PAR_SPACE;
 513                 }
 514                 else if (termios->c_cflag & PARODD)
 515                         mode |= AT91_US_PAR_ODD;
 516                 else
 517                         mode |= AT91_US_PAR_EVEN;
 518         }
 519         else
 520                 mode |= AT91_US_PAR_NONE;
 521
 522         spin_lock_irqsave(&port->lock, flags);
 523
 524         port->read_status_mask = AT91_US_OVRE;
 525         if (termios->c_iflag & INPCK)
 526                 port->read_status_mask |= (AT91_US_FRAME | AT91_US_PARE);
 527         if (termios->c_iflag & (BRKINT | PARMRK))
 528                 port->read_status_mask |= AT91_US_RXBRK;
 529
 530         /*
 531          * Characters to ignore
 532          */
 533         port->ignore_status_mask = 0;
 534         if (termios->c_iflag & IGNPAR)
 535                 port->ignore_status_mask |= (AT91_US_FRAME | AT91_US_PARE);
 536         if (termios->c_iflag & IGNBRK) {
 537                 port->ignore_status_mask |= AT91_US_RXBRK;
 538                 /*
 539                  * If we're ignoring parity and break indicators,
 540                  * ignore overruns too (for real raw support).
 541                  */
 542                 if (termios->c_iflag & IGNPAR)
 543                         port->ignore_status_mask |= AT91_US_OVRE;
 544         }
 545
 546         // TODO: Ignore all characters if CREAD is set.
 547
 548         /* update the per-port timeout */
 549         uart_update_timeout(port, termios->c_cflag, baud);
 550
 551         /* disable interrupts and drain transmitter */
 552         imr = UART_GET_IMR(port);       /* get interrupt mask */
 553         UART_PUT_IDR(port, -1);         /* disable all interrupts */
 554         while (!(UART_GET_CSR(port) & AT91_US_TXEMPTY)) { barrier(); }
 555
 556         /* disable receiver and transmitter */
 557         UART_PUT_CR(port, AT91_US_TXDIS | AT91_US_RXDIS);
 558
 559         /* set the parity, stop bits and data size */
 560         UART_PUT_MR(port, mode);
 561
 562         /* set the baud rate */
 563         UART_PUT_BRGR(port, quot);
 564         UART_PUT_CR(port, AT91_US_RSTSTA | AT91_US_RSTRX);
 565         UART_PUT_CR(port, AT91_US_TXEN | AT91_US_RXEN);
 566
 567         /* restore interrupts */
 568         UART_PUT_IER(port, imr);
 569
 570         /* CTS flow-control and modem-status interrupts */
 571         if (UART_ENABLE_MS(port, termios->c_cflag))
 572                 port->ops->enable_ms(port);
 573
 574         spin_unlock_irqrestore(&port->lock, flags);
 575 }
 576
 577 /*
 578  * Return string describing the specified port
 579  */
 580 static const char *at91_type(struct uart_port *port)
 581 {
 582         return (port->type == PORT_AT91) ? "AT91_SERIAL" : NULL;
 583 }
 584
 585 /*
 586  * Release the memory region(s) being used by 'port'.
 587  */
 588 static void at91_release_port(struct uart_port *port)
 589 {
 590         struct platform_device *pdev = to_platform_device(port->dev);
 591         int size = pdev->resource[0].end - pdev->resource[0].start + 1;
 592
 593         release_mem_region(port->mapbase, size);
 594
 595         if (port->flags & UPF_IOREMAP) {
 596                 iounmap(port->membase);
 597                 port->membase = NULL;
 598         }
 599 }
 600
 601 /*
 602  * Request the memory region(s) being used by 'port'.
 603  */
 604 static int at91_request_port(struct uart_port *port)
 605 {
 606         struct platform_device *pdev = to_platform_device(port->dev);
 607         int size = pdev->resource[0].end - pdev->resource[0].start + 1;
 608
 609         if (!request_mem_region(port->mapbase, size, "at91_serial"))
 610                 return -EBUSY;
 611
 612         if (port->flags & UPF_IOREMAP) {
 613                 port->membase = ioremap(port->mapbase, size);
 614                 if (port->membase == NULL) {
 615                         release_mem_region(port->mapbase, size);
 616                         return -ENOMEM;
 617                 }
 618         }
 619
 620         return 0;
 621 }
 622
 623 /*
 624  * Configure/autoconfigure the port.
 625  */
 626 static void at91_config_port(struct uart_port *port, int flags)
 627 {
 628         if (flags & UART_CONFIG_TYPE) {
 629                 port->type = PORT_AT91;
 630                 at91_request_port(port);
 631         }
 632 }
 633
 634 /*
 635  * Verify the new serial_struct (for TIOCSSERIAL).
 636  */
 637 static int at91_verify_port(struct uart_port *port, struct serial_struct *ser)
 638 {
 639         int ret = 0;
 640         if (ser->type != PORT_UNKNOWN && ser->type != PORT_AT91)
 641                 ret = -EINVAL;
 642         if (port->irq != ser->irq)
 643                 ret = -EINVAL;
 644         if (ser->io_type != SERIAL_IO_MEM)
 645                 ret = -EINVAL;
 646         if (port->uartclk / 16 != ser->baud_base)
 647                 ret = -EINVAL;
 648         if ((void *)port->mapbase != ser->iomem_base)
 649                 ret = -EINVAL;
 650         if (port->iobase != ser->port)
 651                 ret = -EINVAL;
 652         if (ser->hub6 != 0)
 653                 ret = -EINVAL;
 654         return ret;
 655 }
 656
 657 static struct uart_ops at91_pops = {
 658         .tx_empty       = at91_tx_empty,
 659         .set_mctrl      = at91_set_mctrl,
 660         .get_mctrl      = at91_get_mctrl,
 661         .stop_tx        = at91_stop_tx,
 662         .start_tx       = at91_start_tx,
 663         .stop_rx        = at91_stop_rx,
 664         .enable_ms      = at91_enable_ms,
 665         .break_ctl      = at91_break_ctl,
 666         .startup        = at91_startup,
 667         .shutdown       = at91_shutdown,
 668         .set_termios    = at91_set_termios,
 669         .type           = at91_type,
 670         .release_port   = at91_release_port,
 671         .request_port   = at91_request_port,
 672         .config_port    = at91_config_port,
 673         .verify_port    = at91_verify_port,
 674         .pm             = at91_serial_pm,
 675 };
 676
 677 /*
 678  * Configure the port from the platform device resource info.
 679  */
 680 static void __devinit at91_init_port(struct at91_uart_port *at91_port, struct platform_device *pdev)
 681 {
 682         struct uart_port *port = &at91_port->uart;
 683         struct at91_uart_data *data = pdev->dev.platform_data;
 684
 685         port->iotype    = UPIO_MEM;
 686         port->flags     = UPF_BOOT_AUTOCONF;
 687         port->ops       = &at91_pops;
 688         port->fifosize  = 1;
 689         port->line      = pdev->id;
 690         port->dev       = &pdev->dev;
 691
 692         port->mapbase   = pdev->resource[0].start;
 693         port->irq       = pdev->resource[1].start;
 694
 695         if (port->mapbase == AT91_VA_BASE_SYS + AT91_DBGU)              /* Part of system perpherals - already mapped */
 696                 port->membase = (void __iomem *) port->mapbase;
 697         else {
 698                 port->flags     |= UPF_IOREMAP;
 699                 port->membase   = NULL;
 700         }
 701
 702         if (!at91_port->clk) {          /* for console, the clock could already be configured */
 703                 at91_port->clk = clk_get(&pdev->dev, "usart");
 704                 clk_enable(at91_port->clk);
 705                 port->uartclk = clk_get_rate(at91_port->clk);
 706         }
 707 }
 708
 709 /*
 710  * Register board-specific modem-control line handlers.
 711  */
 712 void __init at91_register_uart_fns(struct at91_port_fns *fns)
 713 {
 714         if (fns->enable_ms)
 715                 at91_pops.enable_ms = fns->enable_ms;
 716         if (fns->get_mctrl)
 717                 at91_pops.get_mctrl = fns->get_mctrl;
 718         if (fns->set_mctrl)
 719                 at91_pops.set_mctrl = fns->set_mctrl;
 720         at91_open          = fns->open;
 721         at91_close         = fns->close;
 722         at91_pops.pm       = fns->pm;
 723         at91_pops.set_wake = fns->set_wake;
 724 }
 725
 726
 727 #ifdef CONFIG_SERIAL_AT91_CONSOLE
 728 static void at91_console_putchar(struct uart_port *port, int ch)
 729 {
 730         while (!(UART_GET_CSR(port) & AT91_US_TXRDY))
 731                 barrier();
 732         UART_PUT_CHAR(port, ch);
 733 }
 734
 735 /*
 736  * Interrupts are disabled on entering
 737  */
 738 static void at91_console_write(struct console *co, const char *s, u_int count)
 739 {
 740         struct uart_port *port = &at91_ports[co->index].uart;
 741         unsigned int status, imr;
 742
 743         /*
 744          *      First, save IMR and then disable interrupts
 745          */
 746         imr = UART_GET_IMR(port);       /* get interrupt mask */
 747         UART_PUT_IDR(port, AT91_US_RXRDY | AT91_US_TXRDY);
 748
 749         uart_console_write(port, s, count, at91_console_putchar);
 750
 751         /*
 752          *      Finally, wait for transmitter to become empty
 753          *      and restore IMR
 754          */
 755         do {
 756                 status = UART_GET_CSR(port);
 757         } while (!(status & AT91_US_TXRDY));
 758         UART_PUT_IER(port, imr);        /* set interrupts back the way they were */
 759 }
 760
 761 /*
 762  * If the port was already initialised (eg, by a boot loader), try to determine
 763  * the current setup.
 764  */
 765 static void __init at91_console_get_options(struct uart_port *port, int *baud, int *parity, int *bits)
 766 {
 767         unsigned int mr, quot;
 768
 769 // TODO: CR is a write-only register
 770 //      unsigned int cr;
 771 //
 772 //      cr = UART_GET_CR(port) & (AT91_US_RXEN | AT91_US_TXEN);
 773 //      if (cr == (AT91_US_RXEN | AT91_US_TXEN)) {
 774 //              /* ok, the port was enabled */
 775 //      }
 776
 777         mr = UART_GET_MR(port) & AT91_US_CHRL;
 778         if (mr == AT91_US_CHRL_8)
 779                 *bits = 8;
 780         else
 781                 *bits = 7;
 782
 783         mr = UART_GET_MR(port) & AT91_US_PAR;
 784         if (mr == AT91_US_PAR_EVEN)
 785                 *parity = 'e';
 786         else if (mr == AT91_US_PAR_ODD)
 787                 *parity = 'o';
 788
 789         quot = UART_GET_BRGR(port);
 790         *baud = port->uartclk / (16 * (quot));
 791 }
 792
 793 static int __init at91_console_setup(struct console *co, char *options)
 794 {
 795         struct uart_port *port = &at91_ports[co->index].uart;
 796         int baud = 115200;
 797         int bits = 8;
 798         int parity = 'n';
 799         int flow = 'n';
 800
 801         if (port->membase == 0)         /* Port not initialized yet - delay setup */
 802                 return -ENODEV;
 803
 804         UART_PUT_IDR(port, -1);                         /* disable interrupts */
 805         UART_PUT_CR(port, AT91_US_RSTSTA | AT91_US_RSTRX);
 806         UART_PUT_CR(port, AT91_US_TXEN | AT91_US_RXEN);
 807
 808         if (options)
 809                 uart_parse_options(options, &baud, &parity, &bits, &flow);
 810         else
 811                 at91_console_get_options(port, &baud, &parity, &bits);
 812
 813         return uart_set_options(port, co, baud, parity, bits, flow);
 814 }
 815
 816 static struct uart_driver at91_uart;
 817
 818 static struct console at91_console = {
 819         .name           = AT91_DEVICENAME,
 820         .write          = at91_console_write,
 821         .device         = uart_console_device,
 822         .setup          = at91_console_setup,
 823         .flags          = CON_PRINTBUFFER,
 824         .index          = -1,
 825         .data           = &at91_uart,
 826 };
 827
 828 #define AT91_CONSOLE_DEVICE     &at91_console
 829
 830 /*
 831  * Early console initialization (before VM subsystem initialized).
 832  */
 833 static int __init at91_console_init(void)
 834 {
 835         if (at91_default_console_device) {
 836                 add_preferred_console(AT91_DEVICENAME, at91_default_console_device->id, NULL);
 837                 at91_init_port(&(at91_ports[at91_default_console_device->id]), at91_default_console_device);
 838                 register_console(&at91_console);
 839         }
 840
 841         return 0;
 842 }
 843 console_initcall(at91_console_init);
 844
 845 /*
 846  * Late console initialization.
 847  */
 848 static int __init at91_late_console_init(void)
 849 {
 850         if (at91_default_console_device && !(at91_console.flags & CON_ENABLED))
 851                 register_console(&at91_console);
 852
 853         return 0;
 854 }
 855 core_initcall(at91_late_console_init);
 856
 857 #else
 858 #define AT91_CONSOLE_DEVICE     NULL
 859 #endif
 860
 861 static struct uart_driver at91_uart = {
 862         .owner                  = THIS_MODULE,
 863         .driver_name            = "at91_serial",
 864         .dev_name               = AT91_DEVICENAME,
 865         .major                  = SERIAL_AT91_MAJOR,
 866         .minor                  = MINOR_START,
 867         .nr                     = AT91_NR_UART,
 868         .cons                   = AT91_CONSOLE_DEVICE,
 869 };
 870
 871 #ifdef CONFIG_PM
 872 static int at91_serial_suspend(struct platform_device *pdev, pm_message_t state)
 873 {
 874         struct uart_port *port = platform_get_drvdata(pdev);
 875         struct at91_uart_port *at91_port = (struct at91_uart_port *) port;
 876
 877         if (device_may_wakeup(&pdev->dev) && !at91_suspend_entering_slow_clock())
 878                 enable_irq_wake(port->irq);
 879         else {
 880                 disable_irq_wake(port->irq);
 881                 uart_suspend_port(&at91_uart, port);
 882                 at91_port->suspended = 1;
 883         }
 884
 885         return 0;
 886 }
 887
 888 static int at91_serial_resume(struct platform_device *pdev)
 889 {
 890         struct uart_port *port = platform_get_drvdata(pdev);
 891         struct at91_uart_port *at91_port = (struct at91_uart_port *) port;
 892
 893         if (at91_port->suspended) {
 894                 uart_resume_port(&at91_uart, port);
 895                 at91_port->suspended = 0;
 896         }
 897
 898         return 0;
 899 }
 900 #else
 901 #define at91_serial_suspend NULL
 902 #define at91_serial_resume NULL
 903 #endif
 904
 905 static int __devinit at91_serial_probe(struct platform_device *pdev)
 906 {
 907         struct at91_uart_port *port;
 908         int ret;
 909
 910         port = &at91_ports[pdev->id];
 911         at91_init_port(port, pdev);
 912
 913         ret = uart_add_one_port(&at91_uart, &port->uart);
 914         if (!ret) {
 915                 device_init_wakeup(&pdev->dev, 1);
 916                 platform_set_drvdata(pdev, port);
 917         }
 918
 919         return ret;
 920 }
 921
 922 static int __devexit at91_serial_remove(struct platform_device *pdev)
 923 {
 924         struct uart_port *port = platform_get_drvdata(pdev);
 925         struct at91_uart_port *at91_port = (struct at91_uart_port *) port;
 926         int ret = 0;
 927
 928         clk_disable(at91_port->clk);
 929         clk_put(at91_port->clk);
 930
 931         device_init_wakeup(&pdev->dev, 0);
 932         platform_set_drvdata(pdev, NULL);
 933
 934         if (port) {
 935                 ret = uart_remove_one_port(&at91_uart, port);
 936                 kfree(port);
 937         }
 938
 939         return ret;
 940 }
 941
 942 static struct platform_driver at91_serial_driver = {
 943         .probe          = at91_serial_probe,
 944         .remove         = __devexit_p(at91_serial_remove),
 945         .suspend        = at91_serial_suspend,
 946         .resume         = at91_serial_resume,
 947         .driver         = {
 948                 .name   = "at91_usart",
 949                 .owner  = THIS_MODULE,
 950         },
 951 };
 952
 953 static int __init at91_serial_init(void)
 954 {
 955         int ret;
 956
 957         ret = uart_register_driver(&at91_uart);
 958         if (ret)
 959                 return ret;
 960
 961         ret = platform_driver_register(&at91_serial_driver);
 962         if (ret)
 963                 uart_unregister_driver(&at91_uart);
 964
 965         return ret;
 966 }
 967
 968 static void __exit at91_serial_exit(void)
 969 {
 970         platform_driver_unregister(&at91_serial_driver);
 971         uart_unregister_driver(&at91_uart);
 972 }
 973
 974 module_init(at91_serial_init);
 975 module_exit(at91_serial_exit);
 976
 977 MODULE_AUTHOR("Rick Bronson");
 978 MODULE_DESCRIPTION("AT91 generic serial port driver");
 979 MODULE_LICENSE("GPL");