2 * linux/drivers/serial/pxa.c
4 * Based on drivers/serial/8250.c by Russell King.
6 * Author: Nicolas Pitre
7 * Created: Feb 20, 2003
8 * Copyright: (C) 2003 Monta Vista Software, Inc.
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.
15 * Note 1: This driver is made separate from the already too overloaded
16 * 8250.c because it needs some kirks of its own and that'll make it
17 * easier to add DMA support.
19 * Note 2: I'm too sick of device allocation policies for serial ports.
20 * If someone else wants to request an "official" allocation of major/minor
21 * for this driver please be my guest. And don't forget that new hardware
22 * to come from Intel might have more than 3 or 4 of those UARTs. Let's
23 * hope for a better port registration and dynamic device allocation scheme
24 * with the serial core maintainer satisfaction to appear soon.
27 #include <linux/config.h>
29 #if defined(CONFIG_SERIAL_PXA_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
33 #include <linux/module.h>
34 #include <linux/ioport.h>
35 #include <linux/init.h>
36 #include <linux/console.h>
37 #include <linux/sysrq.h>
38 #include <linux/serial_reg.h>
39 #include <linux/circ_buf.h>
40 #include <linux/delay.h>
41 #include <linux/interrupt.h>
42 #include <linux/device.h>
43 #include <linux/tty.h>
44 #include <linux/tty_flip.h>
45 #include <linux/serial_core.h>
48 #include <asm/hardware.h>
50 #include <asm/arch/pxa-regs.h>
53 struct uart_pxa_port
{
54 struct uart_port port
;
58 unsigned int lsr_break_flag
;
63 static inline unsigned int serial_in(struct uart_pxa_port
*up
, int offset
)
66 return readl(up
->port
.membase
+ offset
);
69 static inline void serial_out(struct uart_pxa_port
*up
, int offset
, int value
)
72 writel(value
, up
->port
.membase
+ offset
);
75 static void serial_pxa_enable_ms(struct uart_port
*port
)
77 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)port
;
79 up
->ier
|= UART_IER_MSI
;
80 serial_out(up
, UART_IER
, up
->ier
);
83 static void serial_pxa_stop_tx(struct uart_port
*port
, unsigned int tty_stop
)
85 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)port
;
87 if (up
->ier
& UART_IER_THRI
) {
88 up
->ier
&= ~UART_IER_THRI
;
89 serial_out(up
, UART_IER
, up
->ier
);
93 static void serial_pxa_stop_rx(struct uart_port
*port
)
95 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)port
;
97 up
->ier
&= ~UART_IER_RLSI
;
98 up
->port
.read_status_mask
&= ~UART_LSR_DR
;
99 serial_out(up
, UART_IER
, up
->ier
);
103 receive_chars(struct uart_pxa_port
*up
, int *status
, struct pt_regs
*regs
)
105 struct tty_struct
*tty
= up
->port
.info
->tty
;
106 unsigned int ch
, flag
;
110 if (unlikely(tty
->flip
.count
>= TTY_FLIPBUF_SIZE
)) {
111 if (tty
->low_latency
)
112 tty_flip_buffer_push(tty
);
114 * If this failed then we will throw away the
115 * bytes but must do so to clear interrupts
118 ch
= serial_in(up
, UART_RX
);
120 up
->port
.icount
.rx
++;
122 if (unlikely(*status
& (UART_LSR_BI
| UART_LSR_PE
|
123 UART_LSR_FE
| UART_LSR_OE
))) {
125 * For statistics only
127 if (*status
& UART_LSR_BI
) {
128 *status
&= ~(UART_LSR_FE
| UART_LSR_PE
);
129 up
->port
.icount
.brk
++;
131 * We do the SysRQ and SAK checking
132 * here because otherwise the break
133 * may get masked by ignore_status_mask
134 * or read_status_mask.
136 if (uart_handle_break(&up
->port
))
138 } else if (*status
& UART_LSR_PE
)
139 up
->port
.icount
.parity
++;
140 else if (*status
& UART_LSR_FE
)
141 up
->port
.icount
.frame
++;
142 if (*status
& UART_LSR_OE
)
143 up
->port
.icount
.overrun
++;
146 * Mask off conditions which should be ignored.
148 *status
&= up
->port
.read_status_mask
;
150 #ifdef CONFIG_SERIAL_PXA_CONSOLE
151 if (up
->port
.line
== up
->port
.cons
->index
) {
152 /* Recover the break flag from console xmit */
153 *status
|= up
->lsr_break_flag
;
154 up
->lsr_break_flag
= 0;
157 if (*status
& UART_LSR_BI
) {
159 } else if (*status
& UART_LSR_PE
)
161 else if (*status
& UART_LSR_FE
)
164 if (uart_handle_sysrq_char(&up
->port
, ch
, regs
))
166 if ((*status
& up
->port
.ignore_status_mask
) == 0) {
167 tty_insert_flip_char(tty
, ch
, flag
);
169 if ((*status
& UART_LSR_OE
) &&
170 tty
->flip
.count
< TTY_FLIPBUF_SIZE
) {
172 * Overrun is special, since it's reported
173 * immediately, and doesn't affect the current
176 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
179 *status
= serial_in(up
, UART_LSR
);
180 } while ((*status
& UART_LSR_DR
) && (max_count
-- > 0));
181 tty_flip_buffer_push(tty
);
184 static void transmit_chars(struct uart_pxa_port
*up
)
186 struct circ_buf
*xmit
= &up
->port
.info
->xmit
;
189 if (up
->port
.x_char
) {
190 serial_out(up
, UART_TX
, up
->port
.x_char
);
191 up
->port
.icount
.tx
++;
195 if (uart_circ_empty(xmit
) || uart_tx_stopped(&up
->port
)) {
196 serial_pxa_stop_tx(&up
->port
, 0);
200 count
= up
->port
.fifosize
/ 2;
202 serial_out(up
, UART_TX
, xmit
->buf
[xmit
->tail
]);
203 xmit
->tail
= (xmit
->tail
+ 1) & (UART_XMIT_SIZE
- 1);
204 up
->port
.icount
.tx
++;
205 if (uart_circ_empty(xmit
))
207 } while (--count
> 0);
209 if (uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
210 uart_write_wakeup(&up
->port
);
213 if (uart_circ_empty(xmit
))
214 serial_pxa_stop_tx(&up
->port
, 0);
217 static void serial_pxa_start_tx(struct uart_port
*port
, unsigned int tty_start
)
219 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)port
;
221 if (!(up
->ier
& UART_IER_THRI
)) {
222 up
->ier
|= UART_IER_THRI
;
223 serial_out(up
, UART_IER
, up
->ier
);
227 static inline void check_modem_status(struct uart_pxa_port
*up
)
231 status
= serial_in(up
, UART_MSR
);
233 if ((status
& UART_MSR_ANY_DELTA
) == 0)
236 if (status
& UART_MSR_TERI
)
237 up
->port
.icount
.rng
++;
238 if (status
& UART_MSR_DDSR
)
239 up
->port
.icount
.dsr
++;
240 if (status
& UART_MSR_DDCD
)
241 uart_handle_dcd_change(&up
->port
, status
& UART_MSR_DCD
);
242 if (status
& UART_MSR_DCTS
)
243 uart_handle_cts_change(&up
->port
, status
& UART_MSR_CTS
);
245 wake_up_interruptible(&up
->port
.info
->delta_msr_wait
);
249 * This handles the interrupt from one port.
251 static inline irqreturn_t
252 serial_pxa_irq(int irq
, void *dev_id
, struct pt_regs
*regs
)
254 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)dev_id
;
255 unsigned int iir
, lsr
;
257 iir
= serial_in(up
, UART_IIR
);
258 if (iir
& UART_IIR_NO_INT
)
260 lsr
= serial_in(up
, UART_LSR
);
261 if (lsr
& UART_LSR_DR
)
262 receive_chars(up
, &lsr
, regs
);
263 check_modem_status(up
);
264 if (lsr
& UART_LSR_THRE
)
269 static unsigned int serial_pxa_tx_empty(struct uart_port
*port
)
271 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)port
;
275 spin_lock_irqsave(&up
->port
.lock
, flags
);
276 ret
= serial_in(up
, UART_LSR
) & UART_LSR_TEMT
? TIOCSER_TEMT
: 0;
277 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
282 static unsigned int serial_pxa_get_mctrl(struct uart_port
*port
)
284 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)port
;
286 unsigned char status
;
289 return TIOCM_CTS
| TIOCM_DSR
| TIOCM_CAR
;
290 spin_lock_irqsave(&up
->port
.lock
, flags
);
291 status
= serial_in(up
, UART_MSR
);
292 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
295 if (status
& UART_MSR_DCD
)
297 if (status
& UART_MSR_RI
)
299 if (status
& UART_MSR_DSR
)
301 if (status
& UART_MSR_CTS
)
306 static void serial_pxa_set_mctrl(struct uart_port
*port
, unsigned int mctrl
)
308 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)port
;
309 unsigned char mcr
= 0;
311 if (mctrl
& TIOCM_RTS
)
313 if (mctrl
& TIOCM_DTR
)
315 if (mctrl
& TIOCM_OUT1
)
316 mcr
|= UART_MCR_OUT1
;
317 if (mctrl
& TIOCM_OUT2
)
318 mcr
|= UART_MCR_OUT2
;
319 if (mctrl
& TIOCM_LOOP
)
320 mcr
|= UART_MCR_LOOP
;
324 serial_out(up
, UART_MCR
, mcr
);
327 static void serial_pxa_break_ctl(struct uart_port
*port
, int break_state
)
329 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)port
;
332 spin_lock_irqsave(&up
->port
.lock
, flags
);
333 if (break_state
== -1)
334 up
->lcr
|= UART_LCR_SBC
;
336 up
->lcr
&= ~UART_LCR_SBC
;
337 serial_out(up
, UART_LCR
, up
->lcr
);
338 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
342 static void serial_pxa_dma_init(struct pxa_uart
*up
)
345 pxa_request_dma(up
->name
, DMA_PRIO_LOW
, pxa_receive_dma
, up
);
349 pxa_request_dma(up
->name
, DMA_PRIO_LOW
, pxa_transmit_dma
, up
);
352 up
->dmadesc
= kmalloc(4 * sizeof(pxa_dma_desc
), GFP_KERNEL
);
358 pxa_free_dma(up
->txdma
);
360 pxa_free_dma(up
->rxdma
);
366 static int serial_pxa_startup(struct uart_port
*port
)
368 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)port
;
377 retval
= request_irq(up
->port
.irq
, serial_pxa_irq
, 0, up
->name
, up
);
382 * Clear the FIFO buffers and disable them.
383 * (they will be reenabled in set_termios())
385 serial_out(up
, UART_FCR
, UART_FCR_ENABLE_FIFO
);
386 serial_out(up
, UART_FCR
, UART_FCR_ENABLE_FIFO
|
387 UART_FCR_CLEAR_RCVR
| UART_FCR_CLEAR_XMIT
);
388 serial_out(up
, UART_FCR
, 0);
391 * Clear the interrupt registers.
393 (void) serial_in(up
, UART_LSR
);
394 (void) serial_in(up
, UART_RX
);
395 (void) serial_in(up
, UART_IIR
);
396 (void) serial_in(up
, UART_MSR
);
399 * Now, initialize the UART
401 serial_out(up
, UART_LCR
, UART_LCR_WLEN8
);
403 spin_lock_irqsave(&up
->port
.lock
, flags
);
404 up
->port
.mctrl
|= TIOCM_OUT2
;
405 serial_pxa_set_mctrl(&up
->port
, up
->port
.mctrl
);
406 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
409 * Finally, enable interrupts. Note: Modem status interrupts
410 * are set via set_termios(), which will be occuring imminently
411 * anyway, so we don't enable them here.
413 up
->ier
= UART_IER_RLSI
| UART_IER_RDI
| UART_IER_RTOIE
| UART_IER_UUE
;
414 serial_out(up
, UART_IER
, up
->ier
);
417 * And clear the interrupt registers again for luck.
419 (void) serial_in(up
, UART_LSR
);
420 (void) serial_in(up
, UART_RX
);
421 (void) serial_in(up
, UART_IIR
);
422 (void) serial_in(up
, UART_MSR
);
427 static void serial_pxa_shutdown(struct uart_port
*port
)
429 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)port
;
432 free_irq(up
->port
.irq
, up
);
435 * Disable interrupts from this port
438 serial_out(up
, UART_IER
, 0);
440 spin_lock_irqsave(&up
->port
.lock
, flags
);
441 up
->port
.mctrl
&= ~TIOCM_OUT2
;
442 serial_pxa_set_mctrl(&up
->port
, up
->port
.mctrl
);
443 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
446 * Disable break condition and FIFOs
448 serial_out(up
, UART_LCR
, serial_in(up
, UART_LCR
) & ~UART_LCR_SBC
);
449 serial_out(up
, UART_FCR
, UART_FCR_ENABLE_FIFO
|
450 UART_FCR_CLEAR_RCVR
|
451 UART_FCR_CLEAR_XMIT
);
452 serial_out(up
, UART_FCR
, 0);
456 serial_pxa_set_termios(struct uart_port
*port
, struct termios
*termios
,
459 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)port
;
460 unsigned char cval
, fcr
= 0;
462 unsigned int baud
, quot
;
464 switch (termios
->c_cflag
& CSIZE
) {
480 if (termios
->c_cflag
& CSTOPB
)
482 if (termios
->c_cflag
& PARENB
)
483 cval
|= UART_LCR_PARITY
;
484 if (!(termios
->c_cflag
& PARODD
))
485 cval
|= UART_LCR_EPAR
;
488 * Ask the core to calculate the divisor for us.
490 baud
= uart_get_baud_rate(port
, termios
, old
, 0, port
->uartclk
/16);
491 quot
= uart_get_divisor(port
, baud
);
493 if ((up
->port
.uartclk
/ quot
) < (2400 * 16))
494 fcr
= UART_FCR_ENABLE_FIFO
| UART_FCR_PXAR1
;
496 fcr
= UART_FCR_ENABLE_FIFO
| UART_FCR_PXAR8
;
499 * Ok, we're now changing the port state. Do it with
500 * interrupts disabled.
502 spin_lock_irqsave(&up
->port
.lock
, flags
);
505 * Ensure the port will be enabled.
506 * This is required especially for serial console.
511 * Update the per-port timeout.
513 uart_update_timeout(port
, termios
->c_cflag
, quot
);
515 up
->port
.read_status_mask
= UART_LSR_OE
| UART_LSR_THRE
| UART_LSR_DR
;
516 if (termios
->c_iflag
& INPCK
)
517 up
->port
.read_status_mask
|= UART_LSR_FE
| UART_LSR_PE
;
518 if (termios
->c_iflag
& (BRKINT
| PARMRK
))
519 up
->port
.read_status_mask
|= UART_LSR_BI
;
522 * Characters to ignore
524 up
->port
.ignore_status_mask
= 0;
525 if (termios
->c_iflag
& IGNPAR
)
526 up
->port
.ignore_status_mask
|= UART_LSR_PE
| UART_LSR_FE
;
527 if (termios
->c_iflag
& IGNBRK
) {
528 up
->port
.ignore_status_mask
|= UART_LSR_BI
;
530 * If we're ignoring parity and break indicators,
531 * ignore overruns too (for real raw support).
533 if (termios
->c_iflag
& IGNPAR
)
534 up
->port
.ignore_status_mask
|= UART_LSR_OE
;
538 * ignore all characters if CREAD is not set
540 if ((termios
->c_cflag
& CREAD
) == 0)
541 up
->port
.ignore_status_mask
|= UART_LSR_DR
;
544 * CTS flow control flag and modem status interrupts
546 up
->ier
&= ~UART_IER_MSI
;
547 if (UART_ENABLE_MS(&up
->port
, termios
->c_cflag
))
548 up
->ier
|= UART_IER_MSI
;
550 serial_out(up
, UART_IER
, up
->ier
);
552 serial_out(up
, UART_LCR
, cval
| UART_LCR_DLAB
);/* set DLAB */
553 serial_out(up
, UART_DLL
, quot
& 0xff); /* LS of divisor */
554 serial_out(up
, UART_DLM
, quot
>> 8); /* MS of divisor */
555 serial_out(up
, UART_LCR
, cval
); /* reset DLAB */
556 up
->lcr
= cval
; /* Save LCR */
557 serial_pxa_set_mctrl(&up
->port
, up
->port
.mctrl
);
558 serial_out(up
, UART_FCR
, fcr
);
559 spin_unlock_irqrestore(&up
->port
.lock
, flags
);
563 serial_pxa_pm(struct uart_port
*port
, unsigned int state
,
564 unsigned int oldstate
)
566 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)port
;
567 pxa_set_cken(up
->cken
, !state
);
572 static void serial_pxa_release_port(struct uart_port
*port
)
576 static int serial_pxa_request_port(struct uart_port
*port
)
581 static void serial_pxa_config_port(struct uart_port
*port
, int flags
)
583 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)port
;
584 up
->port
.type
= PORT_PXA
;
588 serial_pxa_verify_port(struct uart_port
*port
, struct serial_struct
*ser
)
590 /* we don't want the core code to modify any port params */
595 serial_pxa_type(struct uart_port
*port
)
597 struct uart_pxa_port
*up
= (struct uart_pxa_port
*)port
;
601 #ifdef CONFIG_SERIAL_PXA_CONSOLE
603 extern struct uart_pxa_port serial_pxa_ports
[];
604 extern struct uart_driver serial_pxa_reg
;
606 #define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE)
609 * Wait for transmitter & holding register to empty
611 static inline void wait_for_xmitr(struct uart_pxa_port
*up
)
613 unsigned int status
, tmout
= 10000;
615 /* Wait up to 10ms for the character(s) to be sent. */
617 status
= serial_in(up
, UART_LSR
);
619 if (status
& UART_LSR_BI
)
620 up
->lsr_break_flag
= UART_LSR_BI
;
625 } while ((status
& BOTH_EMPTY
) != BOTH_EMPTY
);
627 /* Wait up to 1s for flow control if necessary */
628 if (up
->port
.flags
& UPF_CONS_FLOW
) {
631 ((serial_in(up
, UART_MSR
) & UART_MSR_CTS
) == 0))
637 * Print a string to the serial port trying not to disturb
638 * any possible real use of the port...
640 * The console_lock must be held when we get here.
643 serial_pxa_console_write(struct console
*co
, const char *s
, unsigned int count
)
645 struct uart_pxa_port
*up
= &serial_pxa_ports
[co
->index
];
650 * First save the UER then disable the interrupts
652 ier
= serial_in(up
, UART_IER
);
653 serial_out(up
, UART_IER
, UART_IER_UUE
);
656 * Now, do each character
658 for (i
= 0; i
< count
; i
++, s
++) {
662 * Send the character out.
663 * If a LF, also do CR...
665 serial_out(up
, UART_TX
, *s
);
668 serial_out(up
, UART_TX
, 13);
673 * Finally, wait for transmitter to become empty
674 * and restore the IER
677 serial_out(up
, UART_IER
, ier
);
681 serial_pxa_console_setup(struct console
*co
, char *options
)
683 struct uart_pxa_port
*up
;
689 if (co
->index
== -1 || co
->index
>= serial_pxa_reg
.nr
)
691 up
= &serial_pxa_ports
[co
->index
];
694 uart_parse_options(options
, &baud
, &parity
, &bits
, &flow
);
696 return uart_set_options(&up
->port
, co
, baud
, parity
, bits
, flow
);
699 static struct console serial_pxa_console
= {
701 .write
= serial_pxa_console_write
,
702 .device
= uart_console_device
,
703 .setup
= serial_pxa_console_setup
,
704 .flags
= CON_PRINTBUFFER
,
706 .data
= &serial_pxa_reg
,
710 serial_pxa_console_init(void)
712 register_console(&serial_pxa_console
);
716 console_initcall(serial_pxa_console_init
);
718 #define PXA_CONSOLE &serial_pxa_console
720 #define PXA_CONSOLE NULL
723 struct uart_ops serial_pxa_pops
= {
724 .tx_empty
= serial_pxa_tx_empty
,
725 .set_mctrl
= serial_pxa_set_mctrl
,
726 .get_mctrl
= serial_pxa_get_mctrl
,
727 .stop_tx
= serial_pxa_stop_tx
,
728 .start_tx
= serial_pxa_start_tx
,
729 .stop_rx
= serial_pxa_stop_rx
,
730 .enable_ms
= serial_pxa_enable_ms
,
731 .break_ctl
= serial_pxa_break_ctl
,
732 .startup
= serial_pxa_startup
,
733 .shutdown
= serial_pxa_shutdown
,
734 .set_termios
= serial_pxa_set_termios
,
736 .type
= serial_pxa_type
,
737 .release_port
= serial_pxa_release_port
,
738 .request_port
= serial_pxa_request_port
,
739 .config_port
= serial_pxa_config_port
,
740 .verify_port
= serial_pxa_verify_port
,
743 static struct uart_pxa_port serial_pxa_ports
[] = {
746 .cken
= CKEN6_FFUART
,
750 .membase
= (void *)&FFUART
,
751 .mapbase
= __PREG(FFUART
),
753 .uartclk
= 921600 * 16,
755 .ops
= &serial_pxa_pops
,
760 .cken
= CKEN7_BTUART
,
764 .membase
= (void *)&BTUART
,
765 .mapbase
= __PREG(BTUART
),
767 .uartclk
= 921600 * 16,
769 .ops
= &serial_pxa_pops
,
774 .cken
= CKEN5_STUART
,
778 .membase
= (void *)&STUART
,
779 .mapbase
= __PREG(STUART
),
781 .uartclk
= 921600 * 16,
783 .ops
= &serial_pxa_pops
,
789 static struct uart_driver serial_pxa_reg
= {
790 .owner
= THIS_MODULE
,
791 .driver_name
= "PXA serial",
792 .devfs_name
= "tts/",
796 .nr
= ARRAY_SIZE(serial_pxa_ports
),
800 static int serial_pxa_suspend(struct device
*_dev
, u32 state
, u32 level
)
802 struct uart_pxa_port
*sport
= dev_get_drvdata(_dev
);
804 if (sport
&& level
== SUSPEND_DISABLE
)
805 uart_suspend_port(&serial_pxa_reg
, &sport
->port
);
810 static int serial_pxa_resume(struct device
*_dev
, u32 level
)
812 struct uart_pxa_port
*sport
= dev_get_drvdata(_dev
);
814 if (sport
&& level
== RESUME_ENABLE
)
815 uart_resume_port(&serial_pxa_reg
, &sport
->port
);
820 static int serial_pxa_probe(struct device
*_dev
)
822 struct platform_device
*dev
= to_platform_device(_dev
);
824 serial_pxa_ports
[dev
->id
].port
.dev
= _dev
;
825 uart_add_one_port(&serial_pxa_reg
, &serial_pxa_ports
[dev
->id
].port
);
826 dev_set_drvdata(_dev
, &serial_pxa_ports
[dev
->id
]);
830 static int serial_pxa_remove(struct device
*_dev
)
832 struct uart_pxa_port
*sport
= dev_get_drvdata(_dev
);
834 dev_set_drvdata(_dev
, NULL
);
837 uart_remove_one_port(&serial_pxa_reg
, &sport
->port
);
842 static struct device_driver serial_pxa_driver
= {
843 .name
= "pxa2xx-uart",
844 .bus
= &platform_bus_type
,
845 .probe
= serial_pxa_probe
,
846 .remove
= serial_pxa_remove
,
848 .suspend
= serial_pxa_suspend
,
849 .resume
= serial_pxa_resume
,
852 int __init
serial_pxa_init(void)
856 ret
= uart_register_driver(&serial_pxa_reg
);
860 ret
= driver_register(&serial_pxa_driver
);
862 uart_unregister_driver(&serial_pxa_reg
);
867 void __exit
serial_pxa_exit(void)
869 driver_unregister(&serial_pxa_driver
);
870 uart_unregister_driver(&serial_pxa_reg
);
873 module_init(serial_pxa_init
);
874 module_exit(serial_pxa_exit
);
876 MODULE_LICENSE("GPL");