2 * linux/drivers/char/sa1100.c
4 * Driver for SA11x0 serial ports
6 * Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
8 * Copyright (C) 2000 Deep Blue Solutions Ltd.
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 * 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.
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
24 * $Id: sa1100.c,v 1.50 2002/07/29 14:41:04 rmk Exp $
27 #include <linux/config.h>
29 #if defined(CONFIG_SERIAL_SA1100_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/device.h>
39 #include <linux/tty.h>
40 #include <linux/tty_flip.h>
41 #include <linux/serial_core.h>
42 #include <linux/serial.h>
46 #include <asm/hardware.h>
47 #include <asm/mach/serial_sa1100.h>
49 /* We've been assigned a range on the "Low-density serial ports" major */
50 #define SERIAL_SA1100_MAJOR 204
55 #define SA1100_ISR_PASS_LIMIT 256
58 * Convert from ignore_status_mask or read_status_mask to UTSR[01]
60 #define SM_TO_UTSR0(x) ((x) & 0xff)
61 #define SM_TO_UTSR1(x) ((x) >> 8)
62 #define UTSR0_TO_SM(x) ((x))
63 #define UTSR1_TO_SM(x) ((x) << 8)
65 #define UART_GET_UTCR0(sport) __raw_readl((sport)->port.membase + UTCR0)
66 #define UART_GET_UTCR1(sport) __raw_readl((sport)->port.membase + UTCR1)
67 #define UART_GET_UTCR2(sport) __raw_readl((sport)->port.membase + UTCR2)
68 #define UART_GET_UTCR3(sport) __raw_readl((sport)->port.membase + UTCR3)
69 #define UART_GET_UTSR0(sport) __raw_readl((sport)->port.membase + UTSR0)
70 #define UART_GET_UTSR1(sport) __raw_readl((sport)->port.membase + UTSR1)
71 #define UART_GET_CHAR(sport) __raw_readl((sport)->port.membase + UTDR)
73 #define UART_PUT_UTCR0(sport,v) __raw_writel((v),(sport)->port.membase + UTCR0)
74 #define UART_PUT_UTCR1(sport,v) __raw_writel((v),(sport)->port.membase + UTCR1)
75 #define UART_PUT_UTCR2(sport,v) __raw_writel((v),(sport)->port.membase + UTCR2)
76 #define UART_PUT_UTCR3(sport,v) __raw_writel((v),(sport)->port.membase + UTCR3)
77 #define UART_PUT_UTSR0(sport,v) __raw_writel((v),(sport)->port.membase + UTSR0)
78 #define UART_PUT_UTSR1(sport,v) __raw_writel((v),(sport)->port.membase + UTSR1)
79 #define UART_PUT_CHAR(sport,v) __raw_writel((v),(sport)->port.membase + UTDR)
82 * This is the size of our serial port register set.
84 #define UART_PORT_SIZE 0x24
87 * This determines how often we check the modem status signals
88 * for any change. They generally aren't connected to an IRQ
89 * so we have to poll them. We also check immediately before
90 * filling the TX fifo incase CTS has been dropped.
92 #define MCTRL_TIMEOUT (250*HZ/1000)
95 struct uart_port port
;
96 struct timer_list timer
;
97 unsigned int old_status
;
101 * Handle any change of modem status signal since we were last called.
103 static void sa1100_mctrl_check(struct sa1100_port
*sport
)
105 unsigned int status
, changed
;
107 status
= sport
->port
.ops
->get_mctrl(&sport
->port
);
108 changed
= status
^ sport
->old_status
;
113 sport
->old_status
= status
;
115 if (changed
& TIOCM_RI
)
116 sport
->port
.icount
.rng
++;
117 if (changed
& TIOCM_DSR
)
118 sport
->port
.icount
.dsr
++;
119 if (changed
& TIOCM_CAR
)
120 uart_handle_dcd_change(&sport
->port
, status
& TIOCM_CAR
);
121 if (changed
& TIOCM_CTS
)
122 uart_handle_cts_change(&sport
->port
, status
& TIOCM_CTS
);
124 wake_up_interruptible(&sport
->port
.info
->delta_msr_wait
);
128 * This is our per-port timeout handler, for checking the
129 * modem status signals.
131 static void sa1100_timeout(unsigned long data
)
133 struct sa1100_port
*sport
= (struct sa1100_port
*)data
;
136 if (sport
->port
.info
) {
137 spin_lock_irqsave(&sport
->port
.lock
, flags
);
138 sa1100_mctrl_check(sport
);
139 spin_unlock_irqrestore(&sport
->port
.lock
, flags
);
141 mod_timer(&sport
->timer
, jiffies
+ MCTRL_TIMEOUT
);
146 * interrupts disabled on entry
148 static void sa1100_stop_tx(struct uart_port
*port
, unsigned int tty_stop
)
150 struct sa1100_port
*sport
= (struct sa1100_port
*)port
;
153 utcr3
= UART_GET_UTCR3(sport
);
154 UART_PUT_UTCR3(sport
, utcr3
& ~UTCR3_TIE
);
155 sport
->port
.read_status_mask
&= ~UTSR0_TO_SM(UTSR0_TFS
);
159 * interrupts may not be disabled on entry
161 static void sa1100_start_tx(struct uart_port
*port
, unsigned int tty_start
)
163 struct sa1100_port
*sport
= (struct sa1100_port
*)port
;
167 spin_lock_irqsave(&sport
->port
.lock
, flags
);
168 utcr3
= UART_GET_UTCR3(sport
);
169 sport
->port
.read_status_mask
|= UTSR0_TO_SM(UTSR0_TFS
);
170 UART_PUT_UTCR3(sport
, utcr3
| UTCR3_TIE
);
171 spin_unlock_irqrestore(&sport
->port
.lock
, flags
);
177 static void sa1100_stop_rx(struct uart_port
*port
)
179 struct sa1100_port
*sport
= (struct sa1100_port
*)port
;
182 utcr3
= UART_GET_UTCR3(sport
);
183 UART_PUT_UTCR3(sport
, utcr3
& ~UTCR3_RIE
);
187 * Set the modem control timer to fire immediately.
189 static void sa1100_enable_ms(struct uart_port
*port
)
191 struct sa1100_port
*sport
= (struct sa1100_port
*)port
;
193 mod_timer(&sport
->timer
, jiffies
);
197 sa1100_rx_chars(struct sa1100_port
*sport
, struct pt_regs
*regs
)
199 struct tty_struct
*tty
= sport
->port
.info
->tty
;
200 unsigned int status
, ch
, flg
, ignored
= 0;
202 status
= UTSR1_TO_SM(UART_GET_UTSR1(sport
)) |
203 UTSR0_TO_SM(UART_GET_UTSR0(sport
));
204 while (status
& UTSR1_TO_SM(UTSR1_RNE
)) {
205 ch
= UART_GET_CHAR(sport
);
207 if (tty
->flip
.count
>= TTY_FLIPBUF_SIZE
)
209 sport
->port
.icount
.rx
++;
214 * note that the error handling code is
215 * out of the main execution path
217 if (status
& UTSR1_TO_SM(UTSR1_PRE
| UTSR1_FRE
| UTSR1_ROR
))
220 if (uart_handle_sysrq_char(&sport
->port
, ch
, regs
))
224 tty_insert_flip_char(tty
, ch
, flg
);
226 status
= UTSR1_TO_SM(UART_GET_UTSR1(sport
)) |
227 UTSR0_TO_SM(UART_GET_UTSR0(sport
));
230 tty_flip_buffer_push(tty
);
234 if (status
& UTSR1_TO_SM(UTSR1_PRE
))
235 sport
->port
.icount
.parity
++;
236 else if (status
& UTSR1_TO_SM(UTSR1_FRE
))
237 sport
->port
.icount
.frame
++;
238 if (status
& UTSR1_TO_SM(UTSR1_ROR
))
239 sport
->port
.icount
.overrun
++;
241 if (status
& sport
->port
.ignore_status_mask
) {
247 status
&= sport
->port
.read_status_mask
;
249 if (status
& UTSR1_TO_SM(UTSR1_PRE
))
251 else if (status
& UTSR1_TO_SM(UTSR1_FRE
))
254 if (status
& UTSR1_TO_SM(UTSR1_ROR
)) {
256 * overrun does *not* affect the character
257 * we read from the FIFO
259 tty_insert_flip_char(tty
, ch
, flg
);
264 sport
->port
.sysrq
= 0;
269 static void sa1100_tx_chars(struct sa1100_port
*sport
)
271 struct circ_buf
*xmit
= &sport
->port
.info
->xmit
;
273 if (sport
->port
.x_char
) {
274 UART_PUT_CHAR(sport
, sport
->port
.x_char
);
275 sport
->port
.icount
.tx
++;
276 sport
->port
.x_char
= 0;
281 * Check the modem control lines before
282 * transmitting anything.
284 sa1100_mctrl_check(sport
);
286 if (uart_circ_empty(xmit
) || uart_tx_stopped(&sport
->port
)) {
287 sa1100_stop_tx(&sport
->port
, 0);
292 * Tried using FIFO (not checking TNF) for fifo fill:
293 * still had the '4 bytes repeated' problem.
295 while (UART_GET_UTSR1(sport
) & UTSR1_TNF
) {
296 UART_PUT_CHAR(sport
, xmit
->buf
[xmit
->tail
]);
297 xmit
->tail
= (xmit
->tail
+ 1) & (UART_XMIT_SIZE
- 1);
298 sport
->port
.icount
.tx
++;
299 if (uart_circ_empty(xmit
))
303 if (uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
304 uart_write_wakeup(&sport
->port
);
306 if (uart_circ_empty(xmit
))
307 sa1100_stop_tx(&sport
->port
, 0);
310 static irqreturn_t
sa1100_int(int irq
, void *dev_id
, struct pt_regs
*regs
)
312 struct sa1100_port
*sport
= dev_id
;
313 unsigned int status
, pass_counter
= 0;
315 spin_lock(&sport
->port
.lock
);
316 status
= UART_GET_UTSR0(sport
);
317 status
&= SM_TO_UTSR0(sport
->port
.read_status_mask
) | ~UTSR0_TFS
;
319 if (status
& (UTSR0_RFS
| UTSR0_RID
)) {
320 /* Clear the receiver idle bit, if set */
321 if (status
& UTSR0_RID
)
322 UART_PUT_UTSR0(sport
, UTSR0_RID
);
323 sa1100_rx_chars(sport
, regs
);
326 /* Clear the relevant break bits */
327 if (status
& (UTSR0_RBB
| UTSR0_REB
))
328 UART_PUT_UTSR0(sport
, status
& (UTSR0_RBB
| UTSR0_REB
));
330 if (status
& UTSR0_RBB
)
331 sport
->port
.icount
.brk
++;
333 if (status
& UTSR0_REB
)
334 uart_handle_break(&sport
->port
);
336 if (status
& UTSR0_TFS
)
337 sa1100_tx_chars(sport
);
338 if (pass_counter
++ > SA1100_ISR_PASS_LIMIT
)
340 status
= UART_GET_UTSR0(sport
);
341 status
&= SM_TO_UTSR0(sport
->port
.read_status_mask
) |
343 } while (status
& (UTSR0_TFS
| UTSR0_RFS
| UTSR0_RID
));
344 spin_unlock(&sport
->port
.lock
);
350 * Return TIOCSER_TEMT when transmitter is not busy.
352 static unsigned int sa1100_tx_empty(struct uart_port
*port
)
354 struct sa1100_port
*sport
= (struct sa1100_port
*)port
;
356 return UART_GET_UTSR1(sport
) & UTSR1_TBY
? 0 : TIOCSER_TEMT
;
359 static unsigned int sa1100_get_mctrl(struct uart_port
*port
)
361 return TIOCM_CTS
| TIOCM_DSR
| TIOCM_CAR
;
364 static void sa1100_set_mctrl(struct uart_port
*port
, unsigned int mctrl
)
369 * Interrupts always disabled.
371 static void sa1100_break_ctl(struct uart_port
*port
, int break_state
)
373 struct sa1100_port
*sport
= (struct sa1100_port
*)port
;
377 spin_lock_irqsave(&sport
->port
.lock
, flags
);
378 utcr3
= UART_GET_UTCR3(sport
);
379 if (break_state
== -1)
383 UART_PUT_UTCR3(sport
, utcr3
);
384 spin_unlock_irqrestore(&sport
->port
.lock
, flags
);
387 static int sa1100_startup(struct uart_port
*port
)
389 struct sa1100_port
*sport
= (struct sa1100_port
*)port
;
395 retval
= request_irq(sport
->port
.irq
, sa1100_int
, 0,
396 "sa11x0-uart", sport
);
401 * Finally, clear and enable interrupts
403 UART_PUT_UTSR0(sport
, -1);
404 UART_PUT_UTCR3(sport
, UTCR3_RXE
| UTCR3_TXE
| UTCR3_RIE
);
407 * Enable modem status interrupts
409 spin_lock_irq(&sport
->port
.lock
);
410 sa1100_enable_ms(&sport
->port
);
411 spin_unlock_irq(&sport
->port
.lock
);
416 static void sa1100_shutdown(struct uart_port
*port
)
418 struct sa1100_port
*sport
= (struct sa1100_port
*)port
;
423 del_timer_sync(&sport
->timer
);
428 free_irq(sport
->port
.irq
, sport
);
431 * Disable all interrupts, port and break condition.
433 UART_PUT_UTCR3(sport
, 0);
437 sa1100_set_termios(struct uart_port
*port
, struct termios
*termios
,
440 struct sa1100_port
*sport
= (struct sa1100_port
*)port
;
442 unsigned int utcr0
, old_utcr3
, baud
, quot
;
443 unsigned int old_csize
= old
? old
->c_cflag
& CSIZE
: CS8
;
446 * We only support CS7 and CS8.
448 while ((termios
->c_cflag
& CSIZE
) != CS7
&&
449 (termios
->c_cflag
& CSIZE
) != CS8
) {
450 termios
->c_cflag
&= ~CSIZE
;
451 termios
->c_cflag
|= old_csize
;
455 if ((termios
->c_cflag
& CSIZE
) == CS8
)
460 if (termios
->c_cflag
& CSTOPB
)
462 if (termios
->c_cflag
& PARENB
) {
464 if (!(termios
->c_cflag
& PARODD
))
469 * Ask the core to calculate the divisor for us.
471 baud
= uart_get_baud_rate(port
, termios
, old
, 0, port
->uartclk
/16);
472 quot
= uart_get_divisor(port
, baud
);
474 spin_lock_irqsave(&sport
->port
.lock
, flags
);
476 sport
->port
.read_status_mask
&= UTSR0_TO_SM(UTSR0_TFS
);
477 sport
->port
.read_status_mask
|= UTSR1_TO_SM(UTSR1_ROR
);
478 if (termios
->c_iflag
& INPCK
)
479 sport
->port
.read_status_mask
|=
480 UTSR1_TO_SM(UTSR1_FRE
| UTSR1_PRE
);
481 if (termios
->c_iflag
& (BRKINT
| PARMRK
))
482 sport
->port
.read_status_mask
|=
483 UTSR0_TO_SM(UTSR0_RBB
| UTSR0_REB
);
486 * Characters to ignore
488 sport
->port
.ignore_status_mask
= 0;
489 if (termios
->c_iflag
& IGNPAR
)
490 sport
->port
.ignore_status_mask
|=
491 UTSR1_TO_SM(UTSR1_FRE
| UTSR1_PRE
);
492 if (termios
->c_iflag
& IGNBRK
) {
493 sport
->port
.ignore_status_mask
|=
494 UTSR0_TO_SM(UTSR0_RBB
| UTSR0_REB
);
496 * If we're ignoring parity and break indicators,
497 * ignore overruns too (for real raw support).
499 if (termios
->c_iflag
& IGNPAR
)
500 sport
->port
.ignore_status_mask
|=
501 UTSR1_TO_SM(UTSR1_ROR
);
504 del_timer_sync(&sport
->timer
);
507 * Update the per-port timeout.
509 uart_update_timeout(port
, termios
->c_cflag
, baud
);
512 * disable interrupts and drain transmitter
514 old_utcr3
= UART_GET_UTCR3(sport
);
515 UART_PUT_UTCR3(sport
, old_utcr3
& ~(UTCR3_RIE
| UTCR3_TIE
));
517 while (UART_GET_UTSR1(sport
) & UTSR1_TBY
)
520 /* then, disable everything */
521 UART_PUT_UTCR3(sport
, 0);
523 /* set the parity, stop bits and data size */
524 UART_PUT_UTCR0(sport
, utcr0
);
526 /* set the baud rate */
528 UART_PUT_UTCR1(sport
, ((quot
& 0xf00) >> 8));
529 UART_PUT_UTCR2(sport
, (quot
& 0xff));
531 UART_PUT_UTSR0(sport
, -1);
533 UART_PUT_UTCR3(sport
, old_utcr3
);
535 if (UART_ENABLE_MS(&sport
->port
, termios
->c_cflag
))
536 sa1100_enable_ms(&sport
->port
);
538 spin_unlock_irqrestore(&sport
->port
.lock
, flags
);
541 static const char *sa1100_type(struct uart_port
*port
)
543 struct sa1100_port
*sport
= (struct sa1100_port
*)port
;
545 return sport
->port
.type
== PORT_SA1100
? "SA1100" : NULL
;
549 * Release the memory region(s) being used by 'port'.
551 static void sa1100_release_port(struct uart_port
*port
)
553 struct sa1100_port
*sport
= (struct sa1100_port
*)port
;
555 release_mem_region(sport
->port
.mapbase
, UART_PORT_SIZE
);
559 * Request the memory region(s) being used by 'port'.
561 static int sa1100_request_port(struct uart_port
*port
)
563 struct sa1100_port
*sport
= (struct sa1100_port
*)port
;
565 return request_mem_region(sport
->port
.mapbase
, UART_PORT_SIZE
,
566 "sa11x0-uart") != NULL
? 0 : -EBUSY
;
570 * Configure/autoconfigure the port.
572 static void sa1100_config_port(struct uart_port
*port
, int flags
)
574 struct sa1100_port
*sport
= (struct sa1100_port
*)port
;
576 if (flags
& UART_CONFIG_TYPE
&&
577 sa1100_request_port(&sport
->port
) == 0)
578 sport
->port
.type
= PORT_SA1100
;
582 * Verify the new serial_struct (for TIOCSSERIAL).
583 * The only change we allow are to the flags and type, and
584 * even then only between PORT_SA1100 and PORT_UNKNOWN
587 sa1100_verify_port(struct uart_port
*port
, struct serial_struct
*ser
)
589 struct sa1100_port
*sport
= (struct sa1100_port
*)port
;
592 if (ser
->type
!= PORT_UNKNOWN
&& ser
->type
!= PORT_SA1100
)
594 if (sport
->port
.irq
!= ser
->irq
)
596 if (ser
->io_type
!= SERIAL_IO_MEM
)
598 if (sport
->port
.uartclk
/ 16 != ser
->baud_base
)
600 if ((void *)sport
->port
.mapbase
!= ser
->iomem_base
)
602 if (sport
->port
.iobase
!= ser
->port
)
609 static struct uart_ops sa1100_pops
= {
610 .tx_empty
= sa1100_tx_empty
,
611 .set_mctrl
= sa1100_set_mctrl
,
612 .get_mctrl
= sa1100_get_mctrl
,
613 .stop_tx
= sa1100_stop_tx
,
614 .start_tx
= sa1100_start_tx
,
615 .stop_rx
= sa1100_stop_rx
,
616 .enable_ms
= sa1100_enable_ms
,
617 .break_ctl
= sa1100_break_ctl
,
618 .startup
= sa1100_startup
,
619 .shutdown
= sa1100_shutdown
,
620 .set_termios
= sa1100_set_termios
,
622 .release_port
= sa1100_release_port
,
623 .request_port
= sa1100_request_port
,
624 .config_port
= sa1100_config_port
,
625 .verify_port
= sa1100_verify_port
,
628 static struct sa1100_port sa1100_ports
[NR_PORTS
];
631 * Setup the SA1100 serial ports. Note that we don't include the IrDA
632 * port here since we have our own SIR/FIR driver (see drivers/net/irda)
634 * Note also that we support "console=ttySAx" where "x" is either 0 or 1.
635 * Which serial port this ends up being depends on the machine you're
636 * running this kernel on. I'm not convinced that this is a good idea,
637 * but that's the way it traditionally works.
639 * Note that NanoEngine UART3 becomes UART2, and UART2 is no longer
642 static void __init
sa1100_init_ports(void)
644 static int first
= 1;
651 for (i
= 0; i
< NR_PORTS
; i
++) {
652 sa1100_ports
[i
].port
.uartclk
= 3686400;
653 sa1100_ports
[i
].port
.ops
= &sa1100_pops
;
654 sa1100_ports
[i
].port
.fifosize
= 8;
655 sa1100_ports
[i
].port
.line
= i
;
656 sa1100_ports
[i
].port
.iotype
= SERIAL_IO_MEM
;
657 init_timer(&sa1100_ports
[i
].timer
);
658 sa1100_ports
[i
].timer
.function
= sa1100_timeout
;
659 sa1100_ports
[i
].timer
.data
= (unsigned long)&sa1100_ports
[i
];
663 * make transmit lines outputs, so that when the port
664 * is closed, the output is in the MARK state.
666 PPDR
|= PPC_TXD1
| PPC_TXD3
;
667 PPSR
|= PPC_TXD1
| PPC_TXD3
;
670 void __init
sa1100_register_uart_fns(struct sa1100_port_fns
*fns
)
673 sa1100_pops
.get_mctrl
= fns
->get_mctrl
;
675 sa1100_pops
.set_mctrl
= fns
->set_mctrl
;
677 sa1100_pops
.pm
= fns
->pm
;
678 sa1100_pops
.set_wake
= fns
->set_wake
;
681 void __init
sa1100_register_uart(int idx
, int port
)
683 if (idx
>= NR_PORTS
) {
684 printk(KERN_ERR
"%s: bad index number %d\n", __FUNCTION__
, idx
);
690 sa1100_ports
[idx
].port
.membase
= (void __iomem
*)&Ser1UTCR0
;
691 sa1100_ports
[idx
].port
.mapbase
= _Ser1UTCR0
;
692 sa1100_ports
[idx
].port
.irq
= IRQ_Ser1UART
;
693 sa1100_ports
[idx
].port
.flags
= ASYNC_BOOT_AUTOCONF
;
697 sa1100_ports
[idx
].port
.membase
= (void __iomem
*)&Ser2UTCR0
;
698 sa1100_ports
[idx
].port
.mapbase
= _Ser2UTCR0
;
699 sa1100_ports
[idx
].port
.irq
= IRQ_Ser2ICP
;
700 sa1100_ports
[idx
].port
.flags
= ASYNC_BOOT_AUTOCONF
;
704 sa1100_ports
[idx
].port
.membase
= (void __iomem
*)&Ser3UTCR0
;
705 sa1100_ports
[idx
].port
.mapbase
= _Ser3UTCR0
;
706 sa1100_ports
[idx
].port
.irq
= IRQ_Ser3UART
;
707 sa1100_ports
[idx
].port
.flags
= ASYNC_BOOT_AUTOCONF
;
711 printk(KERN_ERR
"%s: bad port number %d\n", __FUNCTION__
, port
);
716 #ifdef CONFIG_SERIAL_SA1100_CONSOLE
719 * Interrupts are disabled on entering
722 sa1100_console_write(struct console
*co
, const char *s
, unsigned int count
)
724 struct sa1100_port
*sport
= &sa1100_ports
[co
->index
];
725 unsigned int old_utcr3
, status
, i
;
728 * First, save UTCR3 and then disable interrupts
730 old_utcr3
= UART_GET_UTCR3(sport
);
731 UART_PUT_UTCR3(sport
, (old_utcr3
& ~(UTCR3_RIE
| UTCR3_TIE
)) |
735 * Now, do each character
737 for (i
= 0; i
< count
; i
++) {
739 status
= UART_GET_UTSR1(sport
);
740 } while (!(status
& UTSR1_TNF
));
741 UART_PUT_CHAR(sport
, s
[i
]);
744 status
= UART_GET_UTSR1(sport
);
745 } while (!(status
& UTSR1_TNF
));
746 UART_PUT_CHAR(sport
, '\r');
751 * Finally, wait for transmitter to become empty
755 status
= UART_GET_UTSR1(sport
);
756 } while (status
& UTSR1_TBY
);
757 UART_PUT_UTCR3(sport
, old_utcr3
);
761 * If the port was already initialised (eg, by a boot loader),
762 * try to determine the current setup.
765 sa1100_console_get_options(struct sa1100_port
*sport
, int *baud
,
766 int *parity
, int *bits
)
770 utcr3
= UART_GET_UTCR3(sport
) & (UTCR3_RXE
| UTCR3_TXE
);
771 if (utcr3
== (UTCR3_RXE
| UTCR3_TXE
)) {
772 /* ok, the port was enabled */
773 unsigned int utcr0
, quot
;
775 utcr0
= UART_GET_UTCR0(sport
);
778 if (utcr0
& UTCR0_PE
) {
779 if (utcr0
& UTCR0_OES
)
785 if (utcr0
& UTCR0_DSS
)
790 quot
= UART_GET_UTCR2(sport
) | UART_GET_UTCR1(sport
) << 8;
792 *baud
= sport
->port
.uartclk
/ (16 * (quot
+ 1));
797 sa1100_console_setup(struct console
*co
, char *options
)
799 struct sa1100_port
*sport
;
806 * Check whether an invalid uart number has been specified, and
807 * if so, search for the first available port that does have
810 if (co
->index
== -1 || co
->index
>= NR_PORTS
)
812 sport
= &sa1100_ports
[co
->index
];
815 uart_parse_options(options
, &baud
, &parity
, &bits
, &flow
);
817 sa1100_console_get_options(sport
, &baud
, &parity
, &bits
);
819 return uart_set_options(&sport
->port
, co
, baud
, parity
, bits
, flow
);
822 extern struct uart_driver sa1100_reg
;
823 static struct console sa1100_console
= {
825 .write
= sa1100_console_write
,
826 .device
= uart_console_device
,
827 .setup
= sa1100_console_setup
,
828 .flags
= CON_PRINTBUFFER
,
833 static int __init
sa1100_rs_console_init(void)
836 register_console(&sa1100_console
);
839 console_initcall(sa1100_rs_console_init
);
841 #define SA1100_CONSOLE &sa1100_console
843 #define SA1100_CONSOLE NULL
846 static struct uart_driver sa1100_reg
= {
847 .owner
= THIS_MODULE
,
848 .driver_name
= "ttySA",
850 .devfs_name
= "ttySA",
851 .major
= SERIAL_SA1100_MAJOR
,
852 .minor
= MINOR_START
,
854 .cons
= SA1100_CONSOLE
,
857 static int sa1100_serial_suspend(struct device
*_dev
, u32 state
, u32 level
)
859 struct sa1100_port
*sport
= dev_get_drvdata(_dev
);
861 if (sport
&& level
== SUSPEND_DISABLE
)
862 uart_suspend_port(&sa1100_reg
, &sport
->port
);
867 static int sa1100_serial_resume(struct device
*_dev
, u32 level
)
869 struct sa1100_port
*sport
= dev_get_drvdata(_dev
);
871 if (sport
&& level
== RESUME_ENABLE
)
872 uart_resume_port(&sa1100_reg
, &sport
->port
);
877 static int sa1100_serial_probe(struct device
*_dev
)
879 struct platform_device
*dev
= to_platform_device(_dev
);
880 struct resource
*res
= dev
->resource
;
883 for (i
= 0; i
< dev
->num_resources
; i
++, res
++)
884 if (res
->flags
& IORESOURCE_MEM
)
887 if (i
< dev
->num_resources
) {
888 for (i
= 0; i
< NR_PORTS
; i
++) {
889 if (sa1100_ports
[i
].port
.mapbase
!= res
->start
)
892 sa1100_ports
[i
].port
.dev
= _dev
;
893 uart_add_one_port(&sa1100_reg
, &sa1100_ports
[i
].port
);
894 dev_set_drvdata(_dev
, &sa1100_ports
[i
]);
902 static int sa1100_serial_remove(struct device
*_dev
)
904 struct sa1100_port
*sport
= dev_get_drvdata(_dev
);
906 dev_set_drvdata(_dev
, NULL
);
909 uart_remove_one_port(&sa1100_reg
, &sport
->port
);
914 static struct device_driver sa11x0_serial_driver
= {
915 .name
= "sa11x0-uart",
916 .bus
= &platform_bus_type
,
917 .probe
= sa1100_serial_probe
,
918 .remove
= sa1100_serial_remove
,
919 .suspend
= sa1100_serial_suspend
,
920 .resume
= sa1100_serial_resume
,
923 static int __init
sa1100_serial_init(void)
927 printk(KERN_INFO
"Serial: SA11x0 driver $Revision: 1.50 $\n");
931 ret
= uart_register_driver(&sa1100_reg
);
933 ret
= driver_register(&sa11x0_serial_driver
);
935 uart_unregister_driver(&sa1100_reg
);
940 static void __exit
sa1100_serial_exit(void)
942 driver_unregister(&sa11x0_serial_driver
);
943 uart_unregister_driver(&sa1100_reg
);
946 module_init(sa1100_serial_init
);
947 module_exit(sa1100_serial_exit
);
949 MODULE_AUTHOR("Deep Blue Solutions Ltd");
950 MODULE_DESCRIPTION("SA1100 generic serial port driver $Revision: 1.50 $");
951 MODULE_LICENSE("GPL");
952 MODULE_ALIAS_CHARDEV_MAJOR(SERIAL_SA1100_MAJOR
);