git.oblomov.eu Git - linux-2.6/blob - drivers/serial/atmel_serial.c

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