2 * linux/drivers/serial/imx.c
4 * Driver for Motorola IMX serial ports
6 * Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
8 * Author: Sascha Hauer <sascha@saschahauer.de>
9 * Copyright (C) 2004 Pengutronix
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 * [29-Mar-2005] Mike Lee
26 * Added hardware handshake
28 #include <linux/config.h>
30 #if defined(CONFIG_SERIAL_IMX_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
34 #include <linux/module.h>
35 #include <linux/ioport.h>
36 #include <linux/init.h>
37 #include <linux/console.h>
38 #include <linux/sysrq.h>
39 #include <linux/device.h>
40 #include <linux/tty.h>
41 #include <linux/tty_flip.h>
42 #include <linux/serial_core.h>
43 #include <linux/serial.h>
47 #include <asm/hardware.h>
49 /* We've been assigned a range on the "Low-density serial ports" major */
50 #define SERIAL_IMX_MAJOR 204
51 #define MINOR_START 41
55 #define IMX_ISR_PASS_LIMIT 256
58 * This is the size of our serial port register set.
60 #define UART_PORT_SIZE 0x100
63 * This determines how often we check the modem status signals
64 * for any change. They generally aren't connected to an IRQ
65 * so we have to poll them. We also check immediately before
66 * filling the TX fifo incase CTS has been dropped.
68 #define MCTRL_TIMEOUT (250*HZ/1000)
70 #define DRIVER_NAME "IMX-uart"
73 struct uart_port port
;
74 struct timer_list timer
;
75 unsigned int old_status
;
80 * Handle any change of modem status signal since we were last called.
82 static void imx_mctrl_check(struct imx_port
*sport
)
84 unsigned int status
, changed
;
86 status
= sport
->port
.ops
->get_mctrl(&sport
->port
);
87 changed
= status
^ sport
->old_status
;
92 sport
->old_status
= status
;
94 if (changed
& TIOCM_RI
)
95 sport
->port
.icount
.rng
++;
96 if (changed
& TIOCM_DSR
)
97 sport
->port
.icount
.dsr
++;
98 if (changed
& TIOCM_CAR
)
99 uart_handle_dcd_change(&sport
->port
, status
& TIOCM_CAR
);
100 if (changed
& TIOCM_CTS
)
101 uart_handle_cts_change(&sport
->port
, status
& TIOCM_CTS
);
103 wake_up_interruptible(&sport
->port
.info
->delta_msr_wait
);
107 * This is our per-port timeout handler, for checking the
108 * modem status signals.
110 static void imx_timeout(unsigned long data
)
112 struct imx_port
*sport
= (struct imx_port
*)data
;
115 if (sport
->port
.info
) {
116 spin_lock_irqsave(&sport
->port
.lock
, flags
);
117 imx_mctrl_check(sport
);
118 spin_unlock_irqrestore(&sport
->port
.lock
, flags
);
120 mod_timer(&sport
->timer
, jiffies
+ MCTRL_TIMEOUT
);
125 * interrupts disabled on entry
127 static void imx_stop_tx(struct uart_port
*port
)
129 struct imx_port
*sport
= (struct imx_port
*)port
;
130 UCR1((u32
)sport
->port
.membase
) &= ~UCR1_TXMPTYEN
;
134 * interrupts disabled on entry
136 static void imx_stop_rx(struct uart_port
*port
)
138 struct imx_port
*sport
= (struct imx_port
*)port
;
139 UCR2((u32
)sport
->port
.membase
) &= ~UCR2_RXEN
;
143 * Set the modem control timer to fire immediately.
145 static void imx_enable_ms(struct uart_port
*port
)
147 struct imx_port
*sport
= (struct imx_port
*)port
;
149 mod_timer(&sport
->timer
, jiffies
);
152 static inline void imx_transmit_buffer(struct imx_port
*sport
)
154 struct circ_buf
*xmit
= &sport
->port
.info
->xmit
;
157 /* send xmit->buf[xmit->tail]
158 * out the port here */
159 URTX0((u32
)sport
->port
.membase
) = xmit
->buf
[xmit
->tail
];
160 xmit
->tail
= (xmit
->tail
+ 1) &
161 (UART_XMIT_SIZE
- 1);
162 sport
->port
.icount
.tx
++;
163 if (uart_circ_empty(xmit
))
165 } while (!(UTS((u32
)sport
->port
.membase
) & UTS_TXFULL
));
167 if (uart_circ_empty(xmit
))
168 imx_stop_tx(&sport
->port
);
172 * interrupts disabled on entry
174 static void imx_start_tx(struct uart_port
*port
)
176 struct imx_port
*sport
= (struct imx_port
*)port
;
178 UCR1((u32
)sport
->port
.membase
) |= UCR1_TXMPTYEN
;
180 if(UTS((u32
)sport
->port
.membase
) & UTS_TXEMPTY
)
181 imx_transmit_buffer(sport
);
184 static irqreturn_t
imx_txint(int irq
, void *dev_id
, struct pt_regs
*regs
)
186 struct imx_port
*sport
= (struct imx_port
*)dev_id
;
187 struct circ_buf
*xmit
= &sport
->port
.info
->xmit
;
190 spin_lock_irqsave(&sport
->port
.lock
,flags
);
191 if (sport
->port
.x_char
)
194 URTX0((u32
)sport
->port
.membase
) = sport
->port
.x_char
;
198 if (uart_circ_empty(xmit
) || uart_tx_stopped(&sport
->port
)) {
199 imx_stop_tx(&sport
->port
);
203 imx_transmit_buffer(sport
);
205 if (uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
206 uart_write_wakeup(&sport
->port
);
209 spin_unlock_irqrestore(&sport
->port
.lock
,flags
);
213 static irqreturn_t
imx_rxint(int irq
, void *dev_id
, struct pt_regs
*regs
)
215 struct imx_port
*sport
= dev_id
;
216 unsigned int rx
,flg
,ignored
= 0;
217 struct tty_struct
*tty
= sport
->port
.info
->tty
;
220 rx
= URXD0((u32
)sport
->port
.membase
);
221 spin_lock_irqsave(&sport
->port
.lock
,flags
);
225 sport
->port
.icount
.rx
++;
227 if( USR2((u32
)sport
->port
.membase
) & USR2_BRCD
) {
228 USR2((u32
)sport
->port
.membase
) |= USR2_BRCD
;
229 if(uart_handle_break(&sport
->port
))
233 if (uart_handle_sysrq_char
234 (&sport
->port
, (unsigned char)rx
, regs
))
237 if( rx
& (URXD_PRERR
| URXD_OVRRUN
| URXD_FRMERR
) )
241 tty_insert_flip_char(tty
, rx
, flg
);
243 if (tty
->flip
.count
>= TTY_FLIPBUF_SIZE
)
247 rx
= URXD0((u32
)sport
->port
.membase
);
248 } while(rx
& URXD_CHARRDY
);
251 spin_unlock_irqrestore(&sport
->port
.lock
,flags
);
252 tty_flip_buffer_push(tty
);
257 sport
->port
.icount
.parity
++;
258 else if (rx
& URXD_FRMERR
)
259 sport
->port
.icount
.frame
++;
260 if (rx
& URXD_OVRRUN
)
261 sport
->port
.icount
.overrun
++;
263 if (rx
& sport
->port
.ignore_status_mask
) {
269 rx
&= sport
->port
.read_status_mask
;
273 else if (rx
& URXD_FRMERR
)
275 if (rx
& URXD_OVRRUN
)
279 sport
->port
.sysrq
= 0;
285 * Return TIOCSER_TEMT when transmitter is not busy.
287 static unsigned int imx_tx_empty(struct uart_port
*port
)
289 struct imx_port
*sport
= (struct imx_port
*)port
;
291 return USR2((u32
)sport
->port
.membase
) & USR2_TXDC
? TIOCSER_TEMT
: 0;
295 * We have a modem side uart, so the meanings of RTS and CTS are inverted.
297 static unsigned int imx_get_mctrl(struct uart_port
*port
)
299 struct imx_port
*sport
= (struct imx_port
*)port
;
300 unsigned int tmp
= TIOCM_DSR
| TIOCM_CAR
;
302 if (USR1((u32
)sport
->port
.membase
) & USR1_RTSS
)
305 if (UCR2((u32
)sport
->port
.membase
) & UCR2_CTS
)
311 static void imx_set_mctrl(struct uart_port
*port
, unsigned int mctrl
)
313 struct imx_port
*sport
= (struct imx_port
*)port
;
315 if (mctrl
& TIOCM_RTS
)
316 UCR2((u32
)sport
->port
.membase
) |= UCR2_CTS
;
318 UCR2((u32
)sport
->port
.membase
) &= ~UCR2_CTS
;
322 * Interrupts always disabled.
324 static void imx_break_ctl(struct uart_port
*port
, int break_state
)
326 struct imx_port
*sport
= (struct imx_port
*)port
;
329 spin_lock_irqsave(&sport
->port
.lock
, flags
);
331 if ( break_state
!= 0 )
332 UCR1((u32
)sport
->port
.membase
) |= UCR1_SNDBRK
;
334 UCR1((u32
)sport
->port
.membase
) &= ~UCR1_SNDBRK
;
336 spin_unlock_irqrestore(&sport
->port
.lock
, flags
);
339 #define TXTL 2 /* reset default */
340 #define RXTL 1 /* reset default */
342 static int imx_setup_ufcr(struct imx_port
*sport
, unsigned int mode
)
345 unsigned int ufcr_rfdiv
;
347 /* set receiver / transmitter trigger level.
348 * RFDIV is set such way to satisfy requested uartclk value
350 val
= TXTL
<<10 | RXTL
;
351 ufcr_rfdiv
= (imx_get_perclk1() + sport
->port
.uartclk
/ 2) / sport
->port
.uartclk
;
359 ufcr_rfdiv
= 6 - ufcr_rfdiv
;
361 val
|= UFCR_RFDIV
& (ufcr_rfdiv
<< 7);
363 UFCR((u32
)sport
->port
.membase
) = val
;
368 static int imx_startup(struct uart_port
*port
)
370 struct imx_port
*sport
= (struct imx_port
*)port
;
374 imx_setup_ufcr(sport
, 0);
376 /* disable the DREN bit (Data Ready interrupt enable) before
379 UCR4((u32
)sport
->port
.membase
) &= ~UCR4_DREN
;
384 retval
= request_irq(sport
->rxirq
, imx_rxint
, 0,
386 if (retval
) goto error_out1
;
388 retval
= request_irq(sport
->txirq
, imx_txint
, 0,
390 if (retval
) goto error_out2
;
393 * Finally, clear and enable interrupts
396 UCR1((u32
)sport
->port
.membase
) |=
397 (UCR1_TXMPTYEN
| UCR1_RRDYEN
| UCR1_UARTEN
);
399 UCR2((u32
)sport
->port
.membase
) |= (UCR2_RXEN
| UCR2_TXEN
);
401 * Enable modem status interrupts
403 spin_lock_irqsave(&sport
->port
.lock
,flags
);
404 imx_enable_ms(&sport
->port
);
405 spin_unlock_irqrestore(&sport
->port
.lock
,flags
);
410 free_irq(sport
->rxirq
, sport
);
415 static void imx_shutdown(struct uart_port
*port
)
417 struct imx_port
*sport
= (struct imx_port
*)port
;
422 del_timer_sync(&sport
->timer
);
425 * Free the interrupts
427 free_irq(sport
->txirq
, sport
);
428 free_irq(sport
->rxirq
, sport
);
431 * Disable all interrupts, port and break condition.
434 UCR1((u32
)sport
->port
.membase
) &=
435 ~(UCR1_TXMPTYEN
| UCR1_RRDYEN
| UCR1_UARTEN
);
439 imx_set_termios(struct uart_port
*port
, struct termios
*termios
,
442 struct imx_port
*sport
= (struct imx_port
*)port
;
444 unsigned int ucr2
, old_ucr1
, old_txrxen
, baud
, quot
;
445 unsigned int old_csize
= old
? old
->c_cflag
& CSIZE
: CS8
;
448 * If we don't support modem control lines, don't allow
452 termios
->c_cflag
&= ~(HUPCL
| CRTSCTS
| CMSPAR
);
453 termios
->c_cflag
|= CLOCAL
;
457 * We only support CS7 and CS8.
459 while ((termios
->c_cflag
& CSIZE
) != CS7
&&
460 (termios
->c_cflag
& CSIZE
) != CS8
) {
461 termios
->c_cflag
&= ~CSIZE
;
462 termios
->c_cflag
|= old_csize
;
466 if ((termios
->c_cflag
& CSIZE
) == CS8
)
467 ucr2
= UCR2_WS
| UCR2_SRST
| UCR2_IRTS
;
469 ucr2
= UCR2_SRST
| UCR2_IRTS
;
471 if (termios
->c_cflag
& CRTSCTS
) {
476 if (termios
->c_cflag
& CSTOPB
)
478 if (termios
->c_cflag
& PARENB
) {
480 if (!(termios
->c_cflag
& PARODD
))
485 * Ask the core to calculate the divisor for us.
487 baud
= uart_get_baud_rate(port
, termios
, old
, 0, port
->uartclk
/16);
488 quot
= uart_get_divisor(port
, baud
);
490 spin_lock_irqsave(&sport
->port
.lock
, flags
);
492 sport
->port
.read_status_mask
= 0;
493 if (termios
->c_iflag
& INPCK
)
494 sport
->port
.read_status_mask
|= (URXD_FRMERR
| URXD_PRERR
);
495 if (termios
->c_iflag
& (BRKINT
| PARMRK
))
496 sport
->port
.read_status_mask
|= URXD_BRK
;
499 * Characters to ignore
501 sport
->port
.ignore_status_mask
= 0;
502 if (termios
->c_iflag
& IGNPAR
)
503 sport
->port
.ignore_status_mask
|= URXD_PRERR
;
504 if (termios
->c_iflag
& IGNBRK
) {
505 sport
->port
.ignore_status_mask
|= URXD_BRK
;
507 * If we're ignoring parity and break indicators,
508 * ignore overruns too (for real raw support).
510 if (termios
->c_iflag
& IGNPAR
)
511 sport
->port
.ignore_status_mask
|= URXD_OVRRUN
;
514 del_timer_sync(&sport
->timer
);
517 * Update the per-port timeout.
519 uart_update_timeout(port
, termios
->c_cflag
, baud
);
522 * disable interrupts and drain transmitter
524 old_ucr1
= UCR1((u32
)sport
->port
.membase
);
525 UCR1((u32
)sport
->port
.membase
) &= ~(UCR1_TXMPTYEN
| UCR1_RRDYEN
);
527 while ( !(USR2((u32
)sport
->port
.membase
) & USR2_TXDC
))
530 /* then, disable everything */
531 old_txrxen
= UCR2((u32
)sport
->port
.membase
) & ( UCR2_TXEN
| UCR2_RXEN
);
532 UCR2((u32
)sport
->port
.membase
) &= ~( UCR2_TXEN
| UCR2_RXEN
);
534 /* set the parity, stop bits and data size */
535 UCR2((u32
)sport
->port
.membase
) = ucr2
;
537 /* set the baud rate. We assume uartclk = 16 MHz
540 * --------- = --------
543 UBIR((u32
)sport
->port
.membase
) = (baud
/ 100) - 1;
544 UBMR((u32
)sport
->port
.membase
) = 10000 - 1;
546 UCR1((u32
)sport
->port
.membase
) = old_ucr1
;
547 UCR2((u32
)sport
->port
.membase
) |= old_txrxen
;
549 if (UART_ENABLE_MS(&sport
->port
, termios
->c_cflag
))
550 imx_enable_ms(&sport
->port
);
552 spin_unlock_irqrestore(&sport
->port
.lock
, flags
);
555 static const char *imx_type(struct uart_port
*port
)
557 struct imx_port
*sport
= (struct imx_port
*)port
;
559 return sport
->port
.type
== PORT_IMX
? "IMX" : NULL
;
563 * Release the memory region(s) being used by 'port'.
565 static void imx_release_port(struct uart_port
*port
)
567 struct imx_port
*sport
= (struct imx_port
*)port
;
569 release_mem_region(sport
->port
.mapbase
, UART_PORT_SIZE
);
573 * Request the memory region(s) being used by 'port'.
575 static int imx_request_port(struct uart_port
*port
)
577 struct imx_port
*sport
= (struct imx_port
*)port
;
579 return request_mem_region(sport
->port
.mapbase
, UART_PORT_SIZE
,
580 "imx-uart") != NULL
? 0 : -EBUSY
;
584 * Configure/autoconfigure the port.
586 static void imx_config_port(struct uart_port
*port
, int flags
)
588 struct imx_port
*sport
= (struct imx_port
*)port
;
590 if (flags
& UART_CONFIG_TYPE
&&
591 imx_request_port(&sport
->port
) == 0)
592 sport
->port
.type
= PORT_IMX
;
596 * Verify the new serial_struct (for TIOCSSERIAL).
597 * The only change we allow are to the flags and type, and
598 * even then only between PORT_IMX and PORT_UNKNOWN
601 imx_verify_port(struct uart_port
*port
, struct serial_struct
*ser
)
603 struct imx_port
*sport
= (struct imx_port
*)port
;
606 if (ser
->type
!= PORT_UNKNOWN
&& ser
->type
!= PORT_IMX
)
608 if (sport
->port
.irq
!= ser
->irq
)
610 if (ser
->io_type
!= UPIO_MEM
)
612 if (sport
->port
.uartclk
/ 16 != ser
->baud_base
)
614 if ((void *)sport
->port
.mapbase
!= ser
->iomem_base
)
616 if (sport
->port
.iobase
!= ser
->port
)
623 static struct uart_ops imx_pops
= {
624 .tx_empty
= imx_tx_empty
,
625 .set_mctrl
= imx_set_mctrl
,
626 .get_mctrl
= imx_get_mctrl
,
627 .stop_tx
= imx_stop_tx
,
628 .start_tx
= imx_start_tx
,
629 .stop_rx
= imx_stop_rx
,
630 .enable_ms
= imx_enable_ms
,
631 .break_ctl
= imx_break_ctl
,
632 .startup
= imx_startup
,
633 .shutdown
= imx_shutdown
,
634 .set_termios
= imx_set_termios
,
636 .release_port
= imx_release_port
,
637 .request_port
= imx_request_port
,
638 .config_port
= imx_config_port
,
639 .verify_port
= imx_verify_port
,
642 static struct imx_port imx_ports
[] = {
644 .txirq
= UART1_MINT_TX
,
645 .rxirq
= UART1_MINT_RX
,
648 .iotype
= SERIAL_IO_MEM
,
649 .membase
= (void *)IMX_UART1_BASE
,
650 .mapbase
= IMX_UART1_BASE
, /* FIXME */
651 .irq
= UART1_MINT_RX
,
654 .flags
= ASYNC_BOOT_AUTOCONF
,
659 .txirq
= UART2_MINT_TX
,
660 .rxirq
= UART2_MINT_RX
,
663 .iotype
= SERIAL_IO_MEM
,
664 .membase
= (void *)IMX_UART2_BASE
,
665 .mapbase
= IMX_UART2_BASE
, /* FIXME */
666 .irq
= UART2_MINT_RX
,
669 .flags
= ASYNC_BOOT_AUTOCONF
,
677 * Setup the IMX serial ports.
678 * Note also that we support "console=ttySMXx" where "x" is either 0 or 1.
679 * Which serial port this ends up being depends on the machine you're
680 * running this kernel on. I'm not convinced that this is a good idea,
681 * but that's the way it traditionally works.
684 static void __init
imx_init_ports(void)
686 static int first
= 1;
693 for (i
= 0; i
< ARRAY_SIZE(imx_ports
); i
++) {
694 init_timer(&imx_ports
[i
].timer
);
695 imx_ports
[i
].timer
.function
= imx_timeout
;
696 imx_ports
[i
].timer
.data
= (unsigned long)&imx_ports
[i
];
699 imx_gpio_mode(PC9_PF_UART1_CTS
);
700 imx_gpio_mode(PC10_PF_UART1_RTS
);
701 imx_gpio_mode(PC11_PF_UART1_TXD
);
702 imx_gpio_mode(PC12_PF_UART1_RXD
);
703 imx_gpio_mode(PB28_PF_UART2_CTS
);
704 imx_gpio_mode(PB29_PF_UART2_RTS
);
706 imx_gpio_mode(PB30_PF_UART2_TXD
);
707 imx_gpio_mode(PB31_PF_UART2_RXD
);
709 #if 0 /* We don't need these, on the mx1 the _modem_ side of the uart
712 imx_gpio_mode(PD7_AF_UART2_DTR
);
713 imx_gpio_mode(PD8_AF_UART2_DCD
);
714 imx_gpio_mode(PD9_AF_UART2_RI
);
715 imx_gpio_mode(PD10_AF_UART2_DSR
);
721 #ifdef CONFIG_SERIAL_IMX_CONSOLE
724 * Interrupts are disabled on entering
727 imx_console_write(struct console
*co
, const char *s
, unsigned int count
)
729 struct imx_port
*sport
= &imx_ports
[co
->index
];
730 unsigned int old_ucr1
, old_ucr2
, i
;
733 * First, save UCR1/2 and then disable interrupts
735 old_ucr1
= UCR1((u32
)sport
->port
.membase
);
736 old_ucr2
= UCR2((u32
)sport
->port
.membase
);
738 UCR1((u32
)sport
->port
.membase
) =
739 (old_ucr1
| UCR1_UARTCLKEN
| UCR1_UARTEN
)
740 & ~(UCR1_TXMPTYEN
| UCR1_RRDYEN
);
741 UCR2((u32
)sport
->port
.membase
) = old_ucr2
| UCR2_TXEN
;
744 * Now, do each character
746 for (i
= 0; i
< count
; i
++) {
748 while ((UTS((u32
)sport
->port
.membase
) & UTS_TXFULL
))
751 URTX0((u32
)sport
->port
.membase
) = s
[i
];
754 while ((UTS((u32
)sport
->port
.membase
) & UTS_TXFULL
))
756 URTX0((u32
)sport
->port
.membase
) = '\r';
761 * Finally, wait for transmitter to become empty
764 while (!(USR2((u32
)sport
->port
.membase
) & USR2_TXDC
));
766 UCR1((u32
)sport
->port
.membase
) = old_ucr1
;
767 UCR2((u32
)sport
->port
.membase
) = old_ucr2
;
771 * If the port was already initialised (eg, by a boot loader),
772 * try to determine the current setup.
775 imx_console_get_options(struct imx_port
*sport
, int *baud
,
776 int *parity
, int *bits
)
779 if ( UCR1((u32
)sport
->port
.membase
) | UCR1_UARTEN
) {
780 /* ok, the port was enabled */
781 unsigned int ucr2
, ubir
,ubmr
, uartclk
;
782 unsigned int baud_raw
;
783 unsigned int ucfr_rfdiv
;
785 ucr2
= UCR2((u32
)sport
->port
.membase
);
788 if (ucr2
& UCR2_PREN
) {
789 if (ucr2
& UCR2_PROE
)
800 ubir
= UBIR((u32
)sport
->port
.membase
) & 0xffff;
801 ubmr
= UBMR((u32
)sport
->port
.membase
) & 0xffff;
804 ucfr_rfdiv
= (UFCR((u32
)sport
->port
.membase
) & UFCR_RFDIV
) >> 7;
808 ucfr_rfdiv
= 6 - ucfr_rfdiv
;
810 uartclk
= imx_get_perclk1();
811 uartclk
/= ucfr_rfdiv
;
814 * The next code provides exact computation of
815 * baud_raw = round(((uartclk/16) * (ubir + 1)) / (ubmr + 1))
816 * without need of float support or long long division,
817 * which would be required to prevent 32bit arithmetic overflow
819 unsigned int mul
= ubir
+ 1;
820 unsigned int div
= 16 * (ubmr
+ 1);
821 unsigned int rem
= uartclk
% div
;
823 baud_raw
= (uartclk
/ div
) * mul
;
824 baud_raw
+= (rem
* mul
+ div
/ 2) / div
;
825 *baud
= (baud_raw
+ 50) / 100 * 100;
828 if(*baud
!= baud_raw
)
829 printk(KERN_INFO
"Serial: Console IMX rounded baud rate from %d to %d\n",
835 imx_console_setup(struct console
*co
, char *options
)
837 struct imx_port
*sport
;
844 * Check whether an invalid uart number has been specified, and
845 * if so, search for the first available port that does have
848 if (co
->index
== -1 || co
->index
>= ARRAY_SIZE(imx_ports
))
850 sport
= &imx_ports
[co
->index
];
853 uart_parse_options(options
, &baud
, &parity
, &bits
, &flow
);
855 imx_console_get_options(sport
, &baud
, &parity
, &bits
);
857 imx_setup_ufcr(sport
, 0);
859 return uart_set_options(&sport
->port
, co
, baud
, parity
, bits
, flow
);
862 static struct uart_driver imx_reg
;
863 static struct console imx_console
= {
865 .write
= imx_console_write
,
866 .device
= uart_console_device
,
867 .setup
= imx_console_setup
,
868 .flags
= CON_PRINTBUFFER
,
873 static int __init
imx_rs_console_init(void)
876 register_console(&imx_console
);
879 console_initcall(imx_rs_console_init
);
881 #define IMX_CONSOLE &imx_console
883 #define IMX_CONSOLE NULL
886 static struct uart_driver imx_reg
= {
887 .owner
= THIS_MODULE
,
888 .driver_name
= DRIVER_NAME
,
889 .dev_name
= "ttySMX",
890 .devfs_name
= "ttsmx/",
891 .major
= SERIAL_IMX_MAJOR
,
892 .minor
= MINOR_START
,
893 .nr
= ARRAY_SIZE(imx_ports
),
897 static int serial_imx_suspend(struct device
*_dev
, pm_message_t state
, u32 level
)
899 struct imx_port
*sport
= dev_get_drvdata(_dev
);
901 if (sport
&& level
== SUSPEND_DISABLE
)
902 uart_suspend_port(&imx_reg
, &sport
->port
);
907 static int serial_imx_resume(struct device
*_dev
, u32 level
)
909 struct imx_port
*sport
= dev_get_drvdata(_dev
);
911 if (sport
&& level
== RESUME_ENABLE
)
912 uart_resume_port(&imx_reg
, &sport
->port
);
917 static int serial_imx_probe(struct device
*_dev
)
919 struct platform_device
*dev
= to_platform_device(_dev
);
921 imx_ports
[dev
->id
].port
.dev
= _dev
;
922 uart_add_one_port(&imx_reg
, &imx_ports
[dev
->id
].port
);
923 dev_set_drvdata(_dev
, &imx_ports
[dev
->id
]);
927 static int serial_imx_remove(struct device
*_dev
)
929 struct imx_port
*sport
= dev_get_drvdata(_dev
);
931 dev_set_drvdata(_dev
, NULL
);
934 uart_remove_one_port(&imx_reg
, &sport
->port
);
939 static struct device_driver serial_imx_driver
= {
941 .bus
= &platform_bus_type
,
942 .probe
= serial_imx_probe
,
943 .remove
= serial_imx_remove
,
945 .suspend
= serial_imx_suspend
,
946 .resume
= serial_imx_resume
,
949 static int __init
imx_serial_init(void)
953 printk(KERN_INFO
"Serial: IMX driver\n");
957 ret
= uart_register_driver(&imx_reg
);
961 ret
= driver_register(&serial_imx_driver
);
963 uart_unregister_driver(&imx_reg
);
968 static void __exit
imx_serial_exit(void)
970 uart_unregister_driver(&imx_reg
);
973 module_init(imx_serial_init
);
974 module_exit(imx_serial_exit
);
976 MODULE_AUTHOR("Sascha Hauer");
977 MODULE_DESCRIPTION("IMX generic serial port driver");
978 MODULE_LICENSE("GPL");