SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/serial/atmel_serial.c

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