2 * C-Brick Serial Port (and console) driver for SGI Altix machines.
4 * This driver is NOT suitable for talking to the l1-controller for
5 * anything other than 'console activities' --- please use the l1
9 * Copyright (c) 2004-2006 Silicon Graphics, Inc. All Rights Reserved.
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of version 2 of the GNU General Public License
13 * as published by the Free Software Foundation.
15 * This program is distributed in the hope that it would be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
19 * Further, this software is distributed without any warranty that it is
20 * free of the rightful claim of any third person regarding infringement
21 * or the like. Any license provided herein, whether implied or
22 * otherwise, applies only to this software file. Patent licenses, if
23 * any, provided herein do not apply to combinations of this program with
24 * other software, or any other product whatsoever.
26 * You should have received a copy of the GNU General Public
27 * License along with this program; if not, write the Free Software
28 * Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
30 * Contact information: Silicon Graphics, Inc., 1500 Crittenden Lane,
31 * Mountain View, CA 94043, or:
35 * For further information regarding this notice, see:
37 * http://oss.sgi.com/projects/GenInfo/NoticeExplan
40 #include <linux/interrupt.h>
41 #include <linux/tty.h>
42 #include <linux/serial.h>
43 #include <linux/console.h>
44 #include <linux/module.h>
45 #include <linux/sysrq.h>
46 #include <linux/circ_buf.h>
47 #include <linux/serial_reg.h>
48 #include <linux/delay.h> /* for mdelay */
49 #include <linux/miscdevice.h>
50 #include <linux/serial_core.h>
53 #include <asm/sn/simulator.h>
54 #include <asm/sn/sn_sal.h>
56 /* number of characters we can transmit to the SAL console at a time */
57 #define SN_SAL_MAX_CHARS 120
59 /* 64K, when we're asynch, it must be at least printk's LOG_BUF_LEN to
60 * avoid losing chars, (always has to be a power of 2) */
61 #define SN_SAL_BUFFER_SIZE (64 * (1 << 10))
63 #define SN_SAL_UART_FIFO_DEPTH 16
64 #define SN_SAL_UART_FIFO_SPEED_CPS (9600/10)
66 /* sn_transmit_chars() calling args */
67 #define TRANSMIT_BUFFERED 0
68 #define TRANSMIT_RAW 1
70 /* To use dynamic numbers only and not use the assigned major and minor,
71 * define the following.. */
72 /* #define USE_DYNAMIC_MINOR 1 *//* use dynamic minor number */
73 #define USE_DYNAMIC_MINOR 0 /* Don't rely on misc_register dynamic minor */
75 /* Device name we're using */
76 #define DEVICE_NAME "ttySG"
77 #define DEVICE_NAME_DYNAMIC "ttySG0" /* need full name for misc_register */
78 /* The major/minor we are using, ignored for USE_DYNAMIC_MINOR */
79 #define DEVICE_MAJOR 204
80 #define DEVICE_MINOR 40
82 #ifdef CONFIG_MAGIC_SYSRQ
83 static char sysrq_serial_str
[] = "\eSYS";
84 static char *sysrq_serial_ptr
= sysrq_serial_str
;
85 static unsigned long sysrq_requested
;
86 #endif /* CONFIG_MAGIC_SYSRQ */
89 * Port definition - this kinda drives it all
92 struct timer_list sc_timer
;
93 struct uart_port sc_port
;
95 int (*sal_puts_raw
) (const char *s
, int len
);
96 int (*sal_puts
) (const char *s
, int len
);
97 int (*sal_getc
) (void);
98 int (*sal_input_pending
) (void);
99 void (*sal_wakeup_transmit
) (struct sn_cons_port
*, int);
101 unsigned long sc_interrupt_timeout
;
105 static struct sn_cons_port sal_console_port
;
106 static int sn_process_input
;
108 /* Only used if USE_DYNAMIC_MINOR is set to 1 */
109 static struct miscdevice misc
; /* used with misc_register for dynamic */
111 extern void early_sn_setup(void);
115 static int sn_debug_printf(const char *fmt
, ...);
116 #define DPRINTF(x...) sn_debug_printf(x)
118 #define DPRINTF(x...) do { } while (0)
122 static int snt_hw_puts_raw(const char *, int);
123 static int snt_hw_puts_buffered(const char *, int);
124 static int snt_poll_getc(void);
125 static int snt_poll_input_pending(void);
126 static int snt_intr_getc(void);
127 static int snt_intr_input_pending(void);
128 static void sn_transmit_chars(struct sn_cons_port
*, int);
130 /* A table for polling:
132 static struct sn_sal_ops poll_ops
= {
133 .sal_puts_raw
= snt_hw_puts_raw
,
134 .sal_puts
= snt_hw_puts_raw
,
135 .sal_getc
= snt_poll_getc
,
136 .sal_input_pending
= snt_poll_input_pending
139 /* A table for interrupts enabled */
140 static struct sn_sal_ops intr_ops
= {
141 .sal_puts_raw
= snt_hw_puts_raw
,
142 .sal_puts
= snt_hw_puts_buffered
,
143 .sal_getc
= snt_intr_getc
,
144 .sal_input_pending
= snt_intr_input_pending
,
145 .sal_wakeup_transmit
= sn_transmit_chars
148 /* the console does output in two distinctly different ways:
149 * synchronous (raw) and asynchronous (buffered). initially, early_printk
150 * does synchronous output. any data written goes directly to the SAL
151 * to be output (incidentally, it is internally buffered by the SAL)
152 * after interrupts and timers are initialized and available for use,
153 * the console init code switches to asynchronous output. this is
154 * also the earliest opportunity to begin polling for console input.
155 * after console initialization, console output and tty (serial port)
156 * output is buffered and sent to the SAL asynchronously (either by
157 * timer callback or by UART interrupt) */
159 /* routines for running the console in polling mode */
162 * snt_poll_getc - Get a character from the console in polling mode
165 static int snt_poll_getc(void)
169 ia64_sn_console_getc(&ch
);
174 * snt_poll_input_pending - Check if any input is waiting - polling mode.
177 static int snt_poll_input_pending(void)
181 status
= ia64_sn_console_check(&input
);
182 return !status
&& input
;
185 /* routines for an interrupt driven console (normal) */
188 * snt_intr_getc - Get a character from the console, interrupt mode
191 static int snt_intr_getc(void)
193 return ia64_sn_console_readc();
197 * snt_intr_input_pending - Check if input is pending, interrupt mode
200 static int snt_intr_input_pending(void)
202 return ia64_sn_console_intr_status() & SAL_CONSOLE_INTR_RECV
;
205 /* these functions are polled and interrupt */
208 * snt_hw_puts_raw - Send raw string to the console, polled or interrupt mode
213 static int snt_hw_puts_raw(const char *s
, int len
)
215 /* this will call the PROM and not return until this is done */
216 return ia64_sn_console_putb(s
, len
);
220 * snt_hw_puts_buffered - Send string to console, polled or interrupt mode
225 static int snt_hw_puts_buffered(const char *s
, int len
)
227 /* queue data to the PROM */
228 return ia64_sn_console_xmit_chars((char *)s
, len
);
231 /* uart interface structs
232 * These functions are associated with the uart_port that the serial core
233 * infrastructure calls.
235 * Note: Due to how the console works, many routines are no-ops.
239 * snp_type - What type of console are we?
240 * @port: Port to operate with (we ignore since we only have one port)
243 static const char *snp_type(struct uart_port
*port
)
245 return ("SGI SN L1");
249 * snp_tx_empty - Is the transmitter empty? We pretend we're always empty
250 * @port: Port to operate on (we ignore since we only have one port)
253 static unsigned int snp_tx_empty(struct uart_port
*port
)
259 * snp_stop_tx - stop the transmitter - no-op for us
260 * @port: Port to operat eon - we ignore - no-op function
263 static void snp_stop_tx(struct uart_port
*port
)
268 * snp_release_port - Free i/o and resources for port - no-op for us
269 * @port: Port to operate on - we ignore - no-op function
272 static void snp_release_port(struct uart_port
*port
)
277 * snp_enable_ms - Force modem status interrupts on - no-op for us
278 * @port: Port to operate on - we ignore - no-op function
281 static void snp_enable_ms(struct uart_port
*port
)
286 * snp_shutdown - shut down the port - free irq and disable - no-op for us
287 * @port: Port to shut down - we ignore
290 static void snp_shutdown(struct uart_port
*port
)
295 * snp_set_mctrl - set control lines (dtr, rts, etc) - no-op for our console
296 * @port: Port to operate on - we ignore
297 * @mctrl: Lines to set/unset - we ignore
300 static void snp_set_mctrl(struct uart_port
*port
, unsigned int mctrl
)
305 * snp_get_mctrl - get contorl line info, we just return a static value
306 * @port: port to operate on - we only have one port so we ignore this
309 static unsigned int snp_get_mctrl(struct uart_port
*port
)
311 return TIOCM_CAR
| TIOCM_RNG
| TIOCM_DSR
| TIOCM_CTS
;
315 * snp_stop_rx - Stop the receiver - we ignor ethis
316 * @port: Port to operate on - we ignore
319 static void snp_stop_rx(struct uart_port
*port
)
324 * snp_start_tx - Start transmitter
325 * @port: Port to operate on
328 static void snp_start_tx(struct uart_port
*port
)
330 if (sal_console_port
.sc_ops
->sal_wakeup_transmit
)
331 sal_console_port
.sc_ops
->sal_wakeup_transmit(&sal_console_port
,
337 * snp_break_ctl - handle breaks - ignored by us
338 * @port: Port to operate on
339 * @break_state: Break state
342 static void snp_break_ctl(struct uart_port
*port
, int break_state
)
347 * snp_startup - Start up the serial port - always return 0 (We're always on)
348 * @port: Port to operate on
351 static int snp_startup(struct uart_port
*port
)
357 * snp_set_termios - set termios stuff - we ignore these
358 * @port: port to operate on
359 * @termios: New settings
364 snp_set_termios(struct uart_port
*port
, struct ktermios
*termios
,
365 struct ktermios
*old
)
370 * snp_request_port - allocate resources for port - ignored by us
371 * @port: port to operate on
374 static int snp_request_port(struct uart_port
*port
)
380 * snp_config_port - allocate resources, set up - we ignore, we're always on
381 * @port: Port to operate on
382 * @flags: flags used for port setup
385 static void snp_config_port(struct uart_port
*port
, int flags
)
389 /* Associate the uart functions above - given to serial core */
391 static struct uart_ops sn_console_ops
= {
392 .tx_empty
= snp_tx_empty
,
393 .set_mctrl
= snp_set_mctrl
,
394 .get_mctrl
= snp_get_mctrl
,
395 .stop_tx
= snp_stop_tx
,
396 .start_tx
= snp_start_tx
,
397 .stop_rx
= snp_stop_rx
,
398 .enable_ms
= snp_enable_ms
,
399 .break_ctl
= snp_break_ctl
,
400 .startup
= snp_startup
,
401 .shutdown
= snp_shutdown
,
402 .set_termios
= snp_set_termios
,
405 .release_port
= snp_release_port
,
406 .request_port
= snp_request_port
,
407 .config_port
= snp_config_port
,
411 /* End of uart struct functions and defines */
416 * sn_debug_printf - close to hardware debugging printf
417 * @fmt: printf format
419 * This is as "close to the metal" as we can get, used when the driver
420 * itself may be broken.
423 static int sn_debug_printf(const char *fmt
, ...)
425 static char printk_buf
[1024];
430 printed_len
= vsnprintf(printk_buf
, sizeof(printk_buf
), fmt
, args
);
432 if (!sal_console_port
.sc_ops
) {
433 sal_console_port
.sc_ops
= &poll_ops
;
436 sal_console_port
.sc_ops
->sal_puts_raw(printk_buf
, printed_len
);
444 * Interrupt handling routines.
448 * sn_receive_chars - Grab characters, pass them to tty layer
449 * @port: Port to operate on
452 * Note: If we're not registered with the serial core infrastructure yet,
453 * we don't try to send characters to it...
457 sn_receive_chars(struct sn_cons_port
*port
, unsigned long flags
)
460 struct tty_struct
*tty
;
463 printk(KERN_ERR
"sn_receive_chars - port NULL so can't receieve\n");
468 printk(KERN_ERR
"sn_receive_chars - port->sc_ops NULL so can't receieve\n");
472 if (port
->sc_port
.state
) {
473 /* The serial_core stuffs are initialized, use them */
474 tty
= port
->sc_port
.state
->port
.tty
;
477 /* Not registered yet - can't pass to tty layer. */
481 while (port
->sc_ops
->sal_input_pending()) {
482 ch
= port
->sc_ops
->sal_getc();
484 printk(KERN_ERR
"sn_console: An error occurred while "
485 "obtaining data from the console (0x%0x)\n", ch
);
488 #ifdef CONFIG_MAGIC_SYSRQ
489 if (sysrq_requested
) {
490 unsigned long sysrq_timeout
= sysrq_requested
+ HZ
*5;
493 if (ch
&& time_before(jiffies
, sysrq_timeout
)) {
494 spin_unlock_irqrestore(&port
->sc_port
.lock
, flags
);
496 spin_lock_irqsave(&port
->sc_port
.lock
, flags
);
497 /* ignore actual sysrq command char */
501 if (ch
== *sysrq_serial_ptr
) {
502 if (!(*++sysrq_serial_ptr
)) {
503 sysrq_requested
= jiffies
;
504 sysrq_serial_ptr
= sysrq_serial_str
;
507 * ignore the whole sysrq string except for the
514 sysrq_serial_ptr
= sysrq_serial_str
;
515 #endif /* CONFIG_MAGIC_SYSRQ */
517 /* record the character to pass up to the tty layer */
519 if(tty_insert_flip_char(tty
, ch
, TTY_NORMAL
) == 0)
522 port
->sc_port
.icount
.rx
++;
526 tty_flip_buffer_push(tty
);
530 * sn_transmit_chars - grab characters from serial core, send off
531 * @port: Port to operate on
532 * @raw: Transmit raw or buffered
534 * Note: If we're early, before we're registered with serial core, the
535 * writes are going through sn_sal_console_write because that's how
536 * register_console has been set up. We currently could have asynch
537 * polls calling this function due to sn_sal_switch_to_asynch but we can
538 * ignore them until we register with the serial core stuffs.
541 static void sn_transmit_chars(struct sn_cons_port
*port
, int raw
)
543 int xmit_count
, tail
, head
, loops
, ii
;
546 struct circ_buf
*xmit
;
551 BUG_ON(!port
->sc_is_asynch
);
553 if (port
->sc_port
.state
) {
554 /* We're initialized, using serial core infrastructure */
555 xmit
= &port
->sc_port
.state
->xmit
;
557 /* Probably sn_sal_switch_to_asynch has been run but serial core isn't
558 * initialized yet. Just return. Writes are going through
559 * sn_sal_console_write (due to register_console) at this time.
564 if (uart_circ_empty(xmit
) || uart_tx_stopped(&port
->sc_port
)) {
566 ia64_sn_console_intr_disable(SAL_CONSOLE_INTR_XMIT
);
572 start
= &xmit
->buf
[tail
];
574 /* twice around gets the tail to the end of the buffer and
575 * then to the head, if needed */
576 loops
= (head
< tail
) ? 2 : 1;
578 for (ii
= 0; ii
< loops
; ii
++) {
579 xmit_count
= (head
< tail
) ?
580 (UART_XMIT_SIZE
- tail
) : (head
- tail
);
582 if (xmit_count
> 0) {
583 if (raw
== TRANSMIT_RAW
)
585 port
->sc_ops
->sal_puts_raw(start
,
589 port
->sc_ops
->sal_puts(start
, xmit_count
);
595 xmit_count
-= result
;
596 port
->sc_port
.icount
.tx
+= result
;
598 tail
&= UART_XMIT_SIZE
- 1;
600 start
= &xmit
->buf
[tail
];
605 if (uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
606 uart_write_wakeup(&port
->sc_port
);
608 if (uart_circ_empty(xmit
))
609 snp_stop_tx(&port
->sc_port
); /* no-op for us */
613 * sn_sal_interrupt - Handle console interrupts
614 * @irq: irq #, useful for debug statements
615 * @dev_id: our pointer to our port (sn_cons_port which contains the uart port)
618 static irqreturn_t
sn_sal_interrupt(int irq
, void *dev_id
)
620 struct sn_cons_port
*port
= (struct sn_cons_port
*)dev_id
;
622 int status
= ia64_sn_console_intr_status();
627 spin_lock_irqsave(&port
->sc_port
.lock
, flags
);
628 if (status
& SAL_CONSOLE_INTR_RECV
) {
629 sn_receive_chars(port
, flags
);
631 if (status
& SAL_CONSOLE_INTR_XMIT
) {
632 sn_transmit_chars(port
, TRANSMIT_BUFFERED
);
634 spin_unlock_irqrestore(&port
->sc_port
.lock
, flags
);
639 * sn_sal_timer_poll - this function handles polled console mode
640 * @data: A pointer to our sn_cons_port (which contains the uart port)
642 * data is the pointer that init_timer will store for us. This function is
643 * associated with init_timer to see if there is any console traffic.
644 * Obviously not used in interrupt mode
647 static void sn_sal_timer_poll(unsigned long data
)
649 struct sn_cons_port
*port
= (struct sn_cons_port
*)data
;
655 if (!port
->sc_port
.irq
) {
656 spin_lock_irqsave(&port
->sc_port
.lock
, flags
);
657 if (sn_process_input
)
658 sn_receive_chars(port
, flags
);
659 sn_transmit_chars(port
, TRANSMIT_RAW
);
660 spin_unlock_irqrestore(&port
->sc_port
.lock
, flags
);
661 mod_timer(&port
->sc_timer
,
662 jiffies
+ port
->sc_interrupt_timeout
);
667 * Boot-time initialization code
671 * sn_sal_switch_to_asynch - Switch to async mode (as opposed to synch)
672 * @port: Our sn_cons_port (which contains the uart port)
674 * So this is used by sn_sal_serial_console_init (early on, before we're
675 * registered with serial core). It's also used by sn_sal_module_init
676 * right after we've registered with serial core. The later only happens
677 * if we didn't already come through here via sn_sal_serial_console_init.
680 static void __init
sn_sal_switch_to_asynch(struct sn_cons_port
*port
)
687 DPRINTF("sn_console: about to switch to asynchronous console\n");
689 /* without early_printk, we may be invoked late enough to race
690 * with other cpus doing console IO at this point, however
691 * console interrupts will never be enabled */
692 spin_lock_irqsave(&port
->sc_port
.lock
, flags
);
694 /* early_printk invocation may have done this for us */
696 port
->sc_ops
= &poll_ops
;
698 /* we can't turn on the console interrupt (as request_irq
699 * calls kmalloc, which isn't set up yet), so we rely on a
700 * timer to poll for input and push data from the console
703 init_timer(&port
->sc_timer
);
704 port
->sc_timer
.function
= sn_sal_timer_poll
;
705 port
->sc_timer
.data
= (unsigned long)port
;
707 if (IS_RUNNING_ON_SIMULATOR())
708 port
->sc_interrupt_timeout
= 6;
710 /* 960cps / 16 char FIFO = 60HZ
711 * HZ / (SN_SAL_FIFO_SPEED_CPS / SN_SAL_FIFO_DEPTH) */
712 port
->sc_interrupt_timeout
=
713 HZ
* SN_SAL_UART_FIFO_DEPTH
/ SN_SAL_UART_FIFO_SPEED_CPS
;
715 mod_timer(&port
->sc_timer
, jiffies
+ port
->sc_interrupt_timeout
);
717 port
->sc_is_asynch
= 1;
718 spin_unlock_irqrestore(&port
->sc_port
.lock
, flags
);
722 * sn_sal_switch_to_interrupts - Switch to interrupt driven mode
723 * @port: Our sn_cons_port (which contains the uart port)
725 * In sn_sal_module_init, after we're registered with serial core and
726 * the port is added, this function is called to switch us to interrupt
727 * mode. We were previously in asynch/polling mode (using init_timer).
729 * We attempt to switch to interrupt mode here by calling
730 * request_irq. If that works out, we enable receive interrupts.
732 static void __init
sn_sal_switch_to_interrupts(struct sn_cons_port
*port
)
737 DPRINTF("sn_console: switching to interrupt driven console\n");
739 if (request_irq(SGI_UART_VECTOR
, sn_sal_interrupt
,
740 IRQF_DISABLED
| IRQF_SHARED
,
741 "SAL console driver", port
) >= 0) {
742 spin_lock_irqsave(&port
->sc_port
.lock
, flags
);
743 port
->sc_port
.irq
= SGI_UART_VECTOR
;
744 port
->sc_ops
= &intr_ops
;
746 /* turn on receive interrupts */
747 ia64_sn_console_intr_enable(SAL_CONSOLE_INTR_RECV
);
748 spin_unlock_irqrestore(&port
->sc_port
.lock
, flags
);
752 "sn_console: console proceeding in polled mode\n");
758 * Kernel console definitions
761 static void sn_sal_console_write(struct console
*, const char *, unsigned);
762 static int sn_sal_console_setup(struct console
*, char *);
763 static struct uart_driver sal_console_uart
;
764 extern struct tty_driver
*uart_console_device(struct console
*, int *);
766 static struct console sal_console
= {
768 .write
= sn_sal_console_write
,
769 .device
= uart_console_device
,
770 .setup
= sn_sal_console_setup
,
771 .index
= -1, /* unspecified */
772 .data
= &sal_console_uart
,
775 #define SAL_CONSOLE &sal_console
777 static struct uart_driver sal_console_uart
= {
778 .owner
= THIS_MODULE
,
779 .driver_name
= "sn_console",
780 .dev_name
= DEVICE_NAME
,
781 .major
= 0, /* major/minor set at registration time per USE_DYNAMIC_MINOR */
783 .nr
= 1, /* one port */
788 * sn_sal_module_init - When the kernel loads us, get us rolling w/ serial core
790 * Before this is called, we've been printing kernel messages in a special
791 * early mode not making use of the serial core infrastructure. When our
792 * driver is loaded for real, we register the driver and port with serial
793 * core and try to enable interrupt driven mode.
796 static int __init
sn_sal_module_init(void)
800 if (!ia64_platform_is("sn2"))
803 printk(KERN_INFO
"sn_console: Console driver init\n");
805 if (USE_DYNAMIC_MINOR
== 1) {
806 misc
.minor
= MISC_DYNAMIC_MINOR
;
807 misc
.name
= DEVICE_NAME_DYNAMIC
;
808 retval
= misc_register(&misc
);
810 printk(KERN_WARNING
"Failed to register console "
811 "device using misc_register.\n");
814 sal_console_uart
.major
= MISC_MAJOR
;
815 sal_console_uart
.minor
= misc
.minor
;
817 sal_console_uart
.major
= DEVICE_MAJOR
;
818 sal_console_uart
.minor
= DEVICE_MINOR
;
821 /* We register the driver and the port before switching to interrupts
822 * or async above so the proper uart structures are populated */
824 if (uart_register_driver(&sal_console_uart
) < 0) {
826 ("ERROR sn_sal_module_init failed uart_register_driver, line %d\n",
831 spin_lock_init(&sal_console_port
.sc_port
.lock
);
833 /* Setup the port struct with the minimum needed */
834 sal_console_port
.sc_port
.membase
= (char *)1; /* just needs to be non-zero */
835 sal_console_port
.sc_port
.type
= PORT_16550A
;
836 sal_console_port
.sc_port
.fifosize
= SN_SAL_MAX_CHARS
;
837 sal_console_port
.sc_port
.ops
= &sn_console_ops
;
838 sal_console_port
.sc_port
.line
= 0;
840 if (uart_add_one_port(&sal_console_uart
, &sal_console_port
.sc_port
) < 0) {
841 /* error - not sure what I'd do - so I'll do nothing */
842 printk(KERN_ERR
"%s: unable to add port\n", __func__
);
845 /* when this driver is compiled in, the console initialization
846 * will have already switched us into asynchronous operation
847 * before we get here through the module initcalls */
848 if (!sal_console_port
.sc_is_asynch
) {
849 sn_sal_switch_to_asynch(&sal_console_port
);
852 /* at this point (module_init) we can try to turn on interrupts */
853 if (!IS_RUNNING_ON_SIMULATOR()) {
854 sn_sal_switch_to_interrupts(&sal_console_port
);
856 sn_process_input
= 1;
861 * sn_sal_module_exit - When we're unloaded, remove the driver/port
864 static void __exit
sn_sal_module_exit(void)
866 del_timer_sync(&sal_console_port
.sc_timer
);
867 uart_remove_one_port(&sal_console_uart
, &sal_console_port
.sc_port
);
868 uart_unregister_driver(&sal_console_uart
);
869 misc_deregister(&misc
);
872 module_init(sn_sal_module_init
);
873 module_exit(sn_sal_module_exit
);
876 * puts_raw_fixed - sn_sal_console_write helper for adding \r's as required
877 * @puts_raw : puts function to do the writing
881 * We need a \r ahead of every \n for direct writes through
882 * ia64_sn_console_putb (what sal_puts_raw below actually does).
886 static void puts_raw_fixed(int (*puts_raw
) (const char *s
, int len
),
887 const char *s
, int count
)
891 /* Output '\r' before each '\n' */
892 while ((s1
= memchr(s
, '\n', count
)) != NULL
) {
902 * sn_sal_console_write - Print statements before serial core available
903 * @console: Console to operate on - we ignore since we have just one
907 * This is referenced in the console struct. It is used for early
908 * console printing before we register with serial core and for things
909 * such as kdb. The console_lock must be held when we get here.
911 * This function has some code for trying to print output even if the lock
912 * is held. We try to cover the case where a lock holder could have died.
913 * We don't use this special case code if we're not registered with serial
914 * core yet. After we're registered with serial core, the only time this
915 * function would be used is for high level kernel output like magic sys req,
919 sn_sal_console_write(struct console
*co
, const char *s
, unsigned count
)
921 unsigned long flags
= 0;
922 struct sn_cons_port
*port
= &sal_console_port
;
923 static int stole_lock
= 0;
925 BUG_ON(!port
->sc_is_asynch
);
927 /* We can't look at the xmit buffer if we're not registered with serial core
928 * yet. So only do the fancy recovery after registering
930 if (!port
->sc_port
.state
) {
931 /* Not yet registered with serial core - simple case */
932 puts_raw_fixed(port
->sc_ops
->sal_puts_raw
, s
, count
);
936 /* somebody really wants this output, might be an
937 * oops, kdb, panic, etc. make sure they get it. */
938 if (spin_is_locked(&port
->sc_port
.lock
)) {
939 int lhead
= port
->sc_port
.state
->xmit
.head
;
940 int ltail
= port
->sc_port
.state
->xmit
.tail
;
941 int counter
, got_lock
= 0;
944 * We attempt to determine if someone has died with the
945 * lock. We wait ~20 secs after the head and tail ptrs
946 * stop moving and assume the lock holder is not functional
947 * and plow ahead. If the lock is freed within the time out
948 * period we re-get the lock and go ahead normally. We also
949 * remember if we have plowed ahead so that we don't have
950 * to wait out the time out period again - the asumption
951 * is that we will time out again.
954 for (counter
= 0; counter
< 150; mdelay(125), counter
++) {
955 if (!spin_is_locked(&port
->sc_port
.lock
)
958 spin_lock_irqsave(&port
->sc_port
.lock
,
965 if ((lhead
!= port
->sc_port
.state
->xmit
.head
)
967 port
->sc_port
.state
->xmit
.tail
)) {
969 port
->sc_port
.state
->xmit
.head
;
971 port
->sc_port
.state
->xmit
.tail
;
976 /* flush anything in the serial core xmit buffer, raw */
977 sn_transmit_chars(port
, 1);
979 spin_unlock_irqrestore(&port
->sc_port
.lock
, flags
);
985 puts_raw_fixed(port
->sc_ops
->sal_puts_raw
, s
, count
);
988 spin_lock_irqsave(&port
->sc_port
.lock
, flags
);
989 sn_transmit_chars(port
, 1);
990 spin_unlock_irqrestore(&port
->sc_port
.lock
, flags
);
992 puts_raw_fixed(port
->sc_ops
->sal_puts_raw
, s
, count
);
998 * sn_sal_console_setup - Set up console for early printing
999 * @co: Console to work with
1000 * @options: Options to set
1002 * Altix console doesn't do anything with baud rates, etc, anyway.
1004 * This isn't required since not providing the setup function in the
1005 * console struct is ok. However, other patches like KDB plop something
1006 * here so providing it is easier.
1009 static int sn_sal_console_setup(struct console
*co
, char *options
)
1015 * sn_sal_console_write_early - simple early output routine
1016 * @co - console struct
1017 * @s - string to print
1020 * Simple function to provide early output, before even
1021 * sn_sal_serial_console_init is called. Referenced in the
1022 * console struct registerd in sn_serial_console_early_setup.
1026 sn_sal_console_write_early(struct console
*co
, const char *s
, unsigned count
)
1028 puts_raw_fixed(sal_console_port
.sc_ops
->sal_puts_raw
, s
, count
);
1031 /* Used for very early console printing - again, before
1032 * sn_sal_serial_console_init is run */
1033 static struct console sal_console_early __initdata
= {
1035 .write
= sn_sal_console_write_early
,
1036 .flags
= CON_PRINTBUFFER
,
1041 * sn_serial_console_early_setup - Sets up early console output support
1043 * Register a console early on... This is for output before even
1044 * sn_sal_serial_cosnole_init is called. This function is called from
1045 * setup.c. This allows us to do really early polled writes. When
1046 * sn_sal_serial_console_init is called, this console is unregistered
1047 * and a new one registered.
1049 int __init
sn_serial_console_early_setup(void)
1051 if (!ia64_platform_is("sn2"))
1054 sal_console_port
.sc_ops
= &poll_ops
;
1055 spin_lock_init(&sal_console_port
.sc_port
.lock
);
1056 early_sn_setup(); /* Find SAL entry points */
1057 register_console(&sal_console_early
);
1063 * sn_sal_serial_console_init - Early console output - set up for register
1065 * This function is called when regular console init happens. Because we
1066 * support even earlier console output with sn_serial_console_early_setup
1067 * (called from setup.c directly), this function unregisters the really
1070 * Note: Even if setup.c doesn't register sal_console_early, unregistering
1071 * it here doesn't hurt anything.
1074 static int __init
sn_sal_serial_console_init(void)
1076 if (ia64_platform_is("sn2")) {
1077 sn_sal_switch_to_asynch(&sal_console_port
);
1078 DPRINTF("sn_sal_serial_console_init : register console\n");
1079 register_console(&sal_console
);
1080 unregister_console(&sal_console_early
);
1085 console_initcall(sn_sal_serial_console_init
);