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