floppy: fix hibernation
[linux-2.6.git] / drivers / serial / sn_console.c
1 /*
2  * C-Brick Serial Port (and console) driver for SGI Altix machines.
3  *
4  * This driver is NOT suitable for talking to the l1-controller for
5  * anything other than 'console activities' --- please use the l1
6  * driver for that.
7  *
8  *
9  * Copyright (c) 2004-2006 Silicon Graphics, Inc.  All Rights Reserved.
10  *
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.
14  *
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.
18  *
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.
25  *
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.
29  *
30  * Contact information:  Silicon Graphics, Inc., 1500 Crittenden Lane,
31  * Mountain View, CA  94043, or:
32  *
33  * http://www.sgi.com
34  *
35  * For further information regarding this notice, see:
36  *
37  * http://oss.sgi.com/projects/GenInfo/NoticeExplan
38  */
39
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>
51
52 #include <asm/io.h>
53 #include <asm/sn/simulator.h>
54 #include <asm/sn/sn_sal.h>
55
56 /* number of characters we can transmit to the SAL console at a time */
57 #define SN_SAL_MAX_CHARS 120
58
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))
62
63 #define SN_SAL_UART_FIFO_DEPTH 16
64 #define SN_SAL_UART_FIFO_SPEED_CPS (9600/10)
65
66 /* sn_transmit_chars() calling args */
67 #define TRANSMIT_BUFFERED       0
68 #define TRANSMIT_RAW            1
69
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 */
74
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
81
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 */
87
88 /*
89  * Port definition - this kinda drives it all
90  */
91 struct sn_cons_port {
92         struct timer_list sc_timer;
93         struct uart_port sc_port;
94         struct sn_sal_ops {
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);
100         } *sc_ops;
101         unsigned long sc_interrupt_timeout;
102         int sc_is_asynch;
103 };
104
105 static struct sn_cons_port sal_console_port;
106 static int sn_process_input;
107
108 /* Only used if USE_DYNAMIC_MINOR is set to 1 */
109 static struct miscdevice misc;  /* used with misc_register for dynamic */
110
111 extern void early_sn_setup(void);
112
113 #undef DEBUG
114 #ifdef DEBUG
115 static int sn_debug_printf(const char *fmt, ...);
116 #define DPRINTF(x...) sn_debug_printf(x)
117 #else
118 #define DPRINTF(x...) do { } while (0)
119 #endif
120
121 /* Prototypes */
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);
129
130 /* A table for polling:
131  */
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
137 };
138
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
146 };
147
148 /* the console does output in two distinctly different ways:
149  * synchronous (raw) and asynchronous (buffered).  initally, 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) */
158
159 /* routines for running the console in polling mode */
160
161 /**
162  * snt_poll_getc - Get a character from the console in polling mode
163  *
164  */
165 static int snt_poll_getc(void)
166 {
167         int ch;
168
169         ia64_sn_console_getc(&ch);
170         return ch;
171 }
172
173 /**
174  * snt_poll_input_pending - Check if any input is waiting - polling mode.
175  *
176  */
177 static int snt_poll_input_pending(void)
178 {
179         int status, input;
180
181         status = ia64_sn_console_check(&input);
182         return !status && input;
183 }
184
185 /* routines for an interrupt driven console (normal) */
186
187 /**
188  * snt_intr_getc - Get a character from the console, interrupt mode
189  *
190  */
191 static int snt_intr_getc(void)
192 {
193         return ia64_sn_console_readc();
194 }
195
196 /**
197  * snt_intr_input_pending - Check if input is pending, interrupt mode
198  *
199  */
200 static int snt_intr_input_pending(void)
201 {
202         return ia64_sn_console_intr_status() & SAL_CONSOLE_INTR_RECV;
203 }
204
205 /* these functions are polled and interrupt */
206
207 /**
208  * snt_hw_puts_raw - Send raw string to the console, polled or interrupt mode
209  * @s: String
210  * @len: Length
211  *
212  */
213 static int snt_hw_puts_raw(const char *s, int len)
214 {
215         /* this will call the PROM and not return until this is done */
216         return ia64_sn_console_putb(s, len);
217 }
218
219 /**
220  * snt_hw_puts_buffered - Send string to console, polled or interrupt mode
221  * @s: String
222  * @len: Length
223  *
224  */
225 static int snt_hw_puts_buffered(const char *s, int len)
226 {
227         /* queue data to the PROM */
228         return ia64_sn_console_xmit_chars((char *)s, len);
229 }
230
231 /* uart interface structs
232  * These functions are associated with the uart_port that the serial core
233  * infrastructure calls.
234  *
235  * Note: Due to how the console works, many routines are no-ops.
236  */
237
238 /**
239  * snp_type - What type of console are we?
240  * @port: Port to operate with (we ignore since we only have one port)
241  *
242  */
243 static const char *snp_type(struct uart_port *port)
244 {
245         return ("SGI SN L1");
246 }
247
248 /**
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)
251  *
252  */
253 static unsigned int snp_tx_empty(struct uart_port *port)
254 {
255         return 1;
256 }
257
258 /**
259  * snp_stop_tx - stop the transmitter - no-op for us
260  * @port: Port to operat eon - we ignore - no-op function
261  *
262  */
263 static void snp_stop_tx(struct uart_port *port)
264 {
265 }
266
267 /**
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
270  *
271  */
272 static void snp_release_port(struct uart_port *port)
273 {
274 }
275
276 /**
277  * snp_enable_ms - Force modem status interrupts on - no-op for us
278  * @port: Port to operate on - we ignore - no-op function
279  *
280  */
281 static void snp_enable_ms(struct uart_port *port)
282 {
283 }
284
285 /**
286  * snp_shutdown - shut down the port - free irq and disable - no-op for us
287  * @port: Port to shut down - we ignore
288  *
289  */
290 static void snp_shutdown(struct uart_port *port)
291 {
292 }
293
294 /**
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
298  *
299  */
300 static void snp_set_mctrl(struct uart_port *port, unsigned int mctrl)
301 {
302 }
303
304 /**
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
307  *
308  */
309 static unsigned int snp_get_mctrl(struct uart_port *port)
310 {
311         return TIOCM_CAR | TIOCM_RNG | TIOCM_DSR | TIOCM_CTS;
312 }
313
314 /**
315  * snp_stop_rx - Stop the receiver - we ignor ethis
316  * @port: Port to operate on - we ignore
317  *
318  */
319 static void snp_stop_rx(struct uart_port *port)
320 {
321 }
322
323 /**
324  * snp_start_tx - Start transmitter
325  * @port: Port to operate on
326  *
327  */
328 static void snp_start_tx(struct uart_port *port)
329 {
330         if (sal_console_port.sc_ops->sal_wakeup_transmit)
331                 sal_console_port.sc_ops->sal_wakeup_transmit(&sal_console_port,
332                                                              TRANSMIT_BUFFERED);
333
334 }
335
336 /**
337  * snp_break_ctl - handle breaks - ignored by us
338  * @port: Port to operate on
339  * @break_state: Break state
340  *
341  */
342 static void snp_break_ctl(struct uart_port *port, int break_state)
343 {
344 }
345
346 /**
347  * snp_startup - Start up the serial port - always return 0 (We're always on)
348  * @port: Port to operate on
349  *
350  */
351 static int snp_startup(struct uart_port *port)
352 {
353         return 0;
354 }
355
356 /**
357  * snp_set_termios - set termios stuff - we ignore these
358  * @port: port to operate on
359  * @termios: New settings
360  * @termios: Old
361  *
362  */
363 static void
364 snp_set_termios(struct uart_port *port, struct ktermios *termios,
365                 struct ktermios *old)
366 {
367 }
368
369 /**
370  * snp_request_port - allocate resources for port - ignored by us
371  * @port: port to operate on
372  *
373  */
374 static int snp_request_port(struct uart_port *port)
375 {
376         return 0;
377 }
378
379 /**
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
383  *
384  */
385 static void snp_config_port(struct uart_port *port, int flags)
386 {
387 }
388
389 /* Associate the uart functions above - given to serial core */
390
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,
403         .pm = NULL,
404         .type = snp_type,
405         .release_port = snp_release_port,
406         .request_port = snp_request_port,
407         .config_port = snp_config_port,
408         .verify_port = NULL,
409 };
410
411 /* End of uart struct functions and defines */
412
413 #ifdef DEBUG
414
415 /**
416  * sn_debug_printf - close to hardware debugging printf
417  * @fmt: printf format
418  *
419  * This is as "close to the metal" as we can get, used when the driver
420  * itself may be broken.
421  *
422  */
423 static int sn_debug_printf(const char *fmt, ...)
424 {
425         static char printk_buf[1024];
426         int printed_len;
427         va_list args;
428
429         va_start(args, fmt);
430         printed_len = vsnprintf(printk_buf, sizeof(printk_buf), fmt, args);
431
432         if (!sal_console_port.sc_ops) {
433                 sal_console_port.sc_ops = &poll_ops;
434                 early_sn_setup();
435         }
436         sal_console_port.sc_ops->sal_puts_raw(printk_buf, printed_len);
437
438         va_end(args);
439         return printed_len;
440 }
441 #endif                          /* DEBUG */
442
443 /*
444  * Interrupt handling routines.
445  */
446
447 /**
448  * sn_receive_chars - Grab characters, pass them to tty layer
449  * @port: Port to operate on
450  * @flags: irq flags
451  *
452  * Note: If we're not registered with the serial core infrastructure yet,
453  * we don't try to send characters to it...
454  *
455  */
456 static void
457 sn_receive_chars(struct sn_cons_port *port, unsigned long flags)
458 {
459         int ch;
460         struct tty_struct *tty;
461
462         if (!port) {
463                 printk(KERN_ERR "sn_receive_chars - port NULL so can't receieve\n");
464                 return;
465         }
466
467         if (!port->sc_ops) {
468                 printk(KERN_ERR "sn_receive_chars - port->sc_ops  NULL so can't receieve\n");
469                 return;
470         }
471
472         if (port->sc_port.info) {
473                 /* The serial_core stuffs are initilized, use them */
474                 tty = port->sc_port.info->port.tty;
475         }
476         else {
477                 /* Not registered yet - can't pass to tty layer.  */
478                 tty = NULL;
479         }
480
481         while (port->sc_ops->sal_input_pending()) {
482                 ch = port->sc_ops->sal_getc();
483                 if (ch < 0) {
484                         printk(KERN_ERR "sn_console: An error occured while "
485                                "obtaining data from the console (0x%0x)\n", ch);
486                         break;
487                 }
488 #ifdef CONFIG_MAGIC_SYSRQ
489                 if (sysrq_requested) {
490                         unsigned long sysrq_timeout = sysrq_requested + HZ*5;
491
492                         sysrq_requested = 0;
493                         if (ch && time_before(jiffies, sysrq_timeout)) {
494                                 spin_unlock_irqrestore(&port->sc_port.lock, flags);
495                                 handle_sysrq(ch, NULL);
496                                 spin_lock_irqsave(&port->sc_port.lock, flags);
497                                 /* ignore actual sysrq command char */
498                                 continue;
499                         }
500                 }
501                 if (ch == *sysrq_serial_ptr) {
502                         if (!(*++sysrq_serial_ptr)) {
503                                 sysrq_requested = jiffies;
504                                 sysrq_serial_ptr = sysrq_serial_str;
505                         }
506                         /*
507                          * ignore the whole sysrq string except for the
508                          * leading escape
509                          */
510                         if (ch != '\e')
511                                 continue;
512                 }
513                 else
514                         sysrq_serial_ptr = sysrq_serial_str;
515 #endif /* CONFIG_MAGIC_SYSRQ */
516
517                 /* record the character to pass up to the tty layer */
518                 if (tty) {
519                         if(tty_insert_flip_char(tty, ch, TTY_NORMAL) == 0)
520                                 break;
521                 }
522                 port->sc_port.icount.rx++;
523         }
524
525         if (tty)
526                 tty_flip_buffer_push(tty);
527 }
528
529 /**
530  * sn_transmit_chars - grab characters from serial core, send off
531  * @port: Port to operate on
532  * @raw: Transmit raw or buffered
533  *
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.
539  *
540  */
541 static void sn_transmit_chars(struct sn_cons_port *port, int raw)
542 {
543         int xmit_count, tail, head, loops, ii;
544         int result;
545         char *start;
546         struct circ_buf *xmit;
547
548         if (!port)
549                 return;
550
551         BUG_ON(!port->sc_is_asynch);
552
553         if (port->sc_port.info) {
554                 /* We're initilized, using serial core infrastructure */
555                 xmit = &port->sc_port.info->xmit;
556         } else {
557                 /* Probably sn_sal_switch_to_asynch has been run but serial core isn't
558                  * initilized yet.  Just return.  Writes are going through
559                  * sn_sal_console_write (due to register_console) at this time.
560                  */
561                 return;
562         }
563
564         if (uart_circ_empty(xmit) || uart_tx_stopped(&port->sc_port)) {
565                 /* Nothing to do. */
566                 ia64_sn_console_intr_disable(SAL_CONSOLE_INTR_XMIT);
567                 return;
568         }
569
570         head = xmit->head;
571         tail = xmit->tail;
572         start = &xmit->buf[tail];
573
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;
577
578         for (ii = 0; ii < loops; ii++) {
579                 xmit_count = (head < tail) ?
580                     (UART_XMIT_SIZE - tail) : (head - tail);
581
582                 if (xmit_count > 0) {
583                         if (raw == TRANSMIT_RAW)
584                                 result =
585                                     port->sc_ops->sal_puts_raw(start,
586                                                                xmit_count);
587                         else
588                                 result =
589                                     port->sc_ops->sal_puts(start, xmit_count);
590 #ifdef DEBUG
591                         if (!result)
592                                 DPRINTF("`");
593 #endif
594                         if (result > 0) {
595                                 xmit_count -= result;
596                                 port->sc_port.icount.tx += result;
597                                 tail += result;
598                                 tail &= UART_XMIT_SIZE - 1;
599                                 xmit->tail = tail;
600                                 start = &xmit->buf[tail];
601                         }
602                 }
603         }
604
605         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
606                 uart_write_wakeup(&port->sc_port);
607
608         if (uart_circ_empty(xmit))
609                 snp_stop_tx(&port->sc_port);    /* no-op for us */
610 }
611
612 /**
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)
616  *
617  */
618 static irqreturn_t sn_sal_interrupt(int irq, void *dev_id)
619 {
620         struct sn_cons_port *port = (struct sn_cons_port *)dev_id;
621         unsigned long flags;
622         int status = ia64_sn_console_intr_status();
623
624         if (!port)
625                 return IRQ_NONE;
626
627         spin_lock_irqsave(&port->sc_port.lock, flags);
628         if (status & SAL_CONSOLE_INTR_RECV) {
629                 sn_receive_chars(port, flags);
630         }
631         if (status & SAL_CONSOLE_INTR_XMIT) {
632                 sn_transmit_chars(port, TRANSMIT_BUFFERED);
633         }
634         spin_unlock_irqrestore(&port->sc_port.lock, flags);
635         return IRQ_HANDLED;
636 }
637
638 /**
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)
641  *
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
645  *
646  */
647 static void sn_sal_timer_poll(unsigned long data)
648 {
649         struct sn_cons_port *port = (struct sn_cons_port *)data;
650         unsigned long flags;
651
652         if (!port)
653                 return;
654
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);
663         }
664 }
665
666 /*
667  * Boot-time initialization code
668  */
669
670 /**
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)
673  *
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.
678  *
679  */
680 static void __init sn_sal_switch_to_asynch(struct sn_cons_port *port)
681 {
682         unsigned long flags;
683
684         if (!port)
685                 return;
686
687         DPRINTF("sn_console: about to switch to asynchronous console\n");
688
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);
693
694         /* early_printk invocation may have done this for us */
695         if (!port->sc_ops)
696                 port->sc_ops = &poll_ops;
697
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
701          * buffer.
702          */
703         init_timer(&port->sc_timer);
704         port->sc_timer.function = sn_sal_timer_poll;
705         port->sc_timer.data = (unsigned long)port;
706
707         if (IS_RUNNING_ON_SIMULATOR())
708                 port->sc_interrupt_timeout = 6;
709         else {
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;
714         }
715         mod_timer(&port->sc_timer, jiffies + port->sc_interrupt_timeout);
716
717         port->sc_is_asynch = 1;
718         spin_unlock_irqrestore(&port->sc_port.lock, flags);
719 }
720
721 /**
722  * sn_sal_switch_to_interrupts - Switch to interrupt driven mode
723  * @port: Our sn_cons_port (which contains the uart port)
724  *
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).
728  *
729  * We attempt to switch to interrupt mode here by calling
730  * request_irq.  If that works out, we enable receive interrupts.
731  */
732 static void __init sn_sal_switch_to_interrupts(struct sn_cons_port *port)
733 {
734         unsigned long flags;
735
736         if (port) {
737                 DPRINTF("sn_console: switching to interrupt driven console\n");
738
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;
745
746                         /* turn on receive interrupts */
747                         ia64_sn_console_intr_enable(SAL_CONSOLE_INTR_RECV);
748                         spin_unlock_irqrestore(&port->sc_port.lock, flags);
749                 }
750                 else {
751                         printk(KERN_INFO
752                             "sn_console: console proceeding in polled mode\n");
753                 }
754         }
755 }
756
757 /*
758  * Kernel console definitions
759  */
760
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 *);
765
766 static struct console sal_console = {
767         .name = DEVICE_NAME,
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,
773 };
774
775 #define SAL_CONSOLE     &sal_console
776
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 */
782         .minor = 0,
783         .nr = 1,                /* one port */
784         .cons = SAL_CONSOLE,
785 };
786
787 /**
788  * sn_sal_module_init - When the kernel loads us, get us rolling w/ serial core
789  *
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.
794  *
795  */
796 static int __init sn_sal_module_init(void)
797 {
798         int retval;
799
800         if (!ia64_platform_is("sn2"))
801                 return 0;
802
803         printk(KERN_INFO "sn_console: Console driver init\n");
804
805         if (USE_DYNAMIC_MINOR == 1) {
806                 misc.minor = MISC_DYNAMIC_MINOR;
807                 misc.name = DEVICE_NAME_DYNAMIC;
808                 retval = misc_register(&misc);
809                 if (retval != 0) {
810                         printk(KERN_WARNING "Failed to register console "
811                                "device using misc_register.\n");
812                         return -ENODEV;
813                 }
814                 sal_console_uart.major = MISC_MAJOR;
815                 sal_console_uart.minor = misc.minor;
816         } else {
817                 sal_console_uart.major = DEVICE_MAJOR;
818                 sal_console_uart.minor = DEVICE_MINOR;
819         }
820
821         /* We register the driver and the port before switching to interrupts
822          * or async above so the proper uart structures are populated */
823
824         if (uart_register_driver(&sal_console_uart) < 0) {
825                 printk
826                     ("ERROR sn_sal_module_init failed uart_register_driver, line %d\n",
827                      __LINE__);
828                 return -ENODEV;
829         }
830
831         spin_lock_init(&sal_console_port.sc_port.lock);
832
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;
839
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__);
843         }
844
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);
850         }
851
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);
855         }
856         sn_process_input = 1;
857         return 0;
858 }
859
860 /**
861  * sn_sal_module_exit - When we're unloaded, remove the driver/port
862  *
863  */
864 static void __exit sn_sal_module_exit(void)
865 {
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);
870 }
871
872 module_init(sn_sal_module_init);
873 module_exit(sn_sal_module_exit);
874
875 /**
876  * puts_raw_fixed - sn_sal_console_write helper for adding \r's as required
877  * @puts_raw : puts function to do the writing
878  * @s: input string
879  * @count: length
880  *
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).
883  *
884  */
885
886 static void puts_raw_fixed(int (*puts_raw) (const char *s, int len),
887                            const char *s, int count)
888 {
889         const char *s1;
890
891         /* Output '\r' before each '\n' */
892         while ((s1 = memchr(s, '\n', count)) != NULL) {
893                 puts_raw(s, s1 - s);
894                 puts_raw("\r\n", 2);
895                 count -= s1 + 1 - s;
896                 s = s1 + 1;
897         }
898         puts_raw(s, count);
899 }
900
901 /**
902  * sn_sal_console_write - Print statements before serial core available
903  * @console: Console to operate on - we ignore since we have just one
904  * @s: String to send
905  * @count: length
906  *
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.
910  *
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,
916  * kdb, and printk's.
917  */
918 static void
919 sn_sal_console_write(struct console *co, const char *s, unsigned count)
920 {
921         unsigned long flags = 0;
922         struct sn_cons_port *port = &sal_console_port;
923         static int stole_lock = 0;
924
925         BUG_ON(!port->sc_is_asynch);
926
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
929          */
930         if (!port->sc_port.info) {
931                 /* Not yet registered with serial core - simple case */
932                 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
933                 return;
934         }
935
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.info->xmit.head;
940                 int ltail = port->sc_port.info->xmit.tail;
941                 int counter, got_lock = 0;
942
943                 /*
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.
952                  */
953
954                 for (counter = 0; counter < 150; mdelay(125), counter++) {
955                         if (!spin_is_locked(&port->sc_port.lock)
956                             || stole_lock) {
957                                 if (!stole_lock) {
958                                         spin_lock_irqsave(&port->sc_port.lock,
959                                                           flags);
960                                         got_lock = 1;
961                                 }
962                                 break;
963                         } else {
964                                 /* still locked */
965                                 if ((lhead != port->sc_port.info->xmit.head)
966                                     || (ltail !=
967                                         port->sc_port.info->xmit.tail)) {
968                                         lhead =
969                                                 port->sc_port.info->xmit.head;
970                                         ltail =
971                                                 port->sc_port.info->xmit.tail;
972                                         counter = 0;
973                                 }
974                         }
975                 }
976                 /* flush anything in the serial core xmit buffer, raw */
977                 sn_transmit_chars(port, 1);
978                 if (got_lock) {
979                         spin_unlock_irqrestore(&port->sc_port.lock, flags);
980                         stole_lock = 0;
981                 } else {
982                         /* fell thru */
983                         stole_lock = 1;
984                 }
985                 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
986         } else {
987                 stole_lock = 0;
988                 spin_lock_irqsave(&port->sc_port.lock, flags);
989                 sn_transmit_chars(port, 1);
990                 spin_unlock_irqrestore(&port->sc_port.lock, flags);
991
992                 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
993         }
994 }
995
996
997 /**
998  * sn_sal_console_setup - Set up console for early printing
999  * @co: Console to work with
1000  * @options: Options to set
1001  *
1002  * Altix console doesn't do anything with baud rates, etc, anyway.
1003  *
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.
1007  *
1008  */
1009 static int sn_sal_console_setup(struct console *co, char *options)
1010 {
1011         return 0;
1012 }
1013
1014 /**
1015  * sn_sal_console_write_early - simple early output routine
1016  * @co - console struct
1017  * @s - string to print
1018  * @count - count
1019  *
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.
1023  *
1024  */
1025 static void __init
1026 sn_sal_console_write_early(struct console *co, const char *s, unsigned count)
1027 {
1028         puts_raw_fixed(sal_console_port.sc_ops->sal_puts_raw, s, count);
1029 }
1030
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 = {
1034         .name = "sn_sal",
1035         .write = sn_sal_console_write_early,
1036         .flags = CON_PRINTBUFFER,
1037         .index = -1,
1038 };
1039
1040 /**
1041  * sn_serial_console_early_setup - Sets up early console output support
1042  *
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.
1048  */
1049 int __init sn_serial_console_early_setup(void)
1050 {
1051         if (!ia64_platform_is("sn2"))
1052                 return -1;
1053
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);
1058
1059         return 0;
1060 }
1061
1062 /**
1063  * sn_sal_serial_console_init - Early console output - set up for register
1064  *
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
1068  * early console.
1069  *
1070  * Note: Even if setup.c doesn't register sal_console_early, unregistering
1071  * it here doesn't hurt anything.
1072  *
1073  */
1074 static int __init sn_sal_serial_console_init(void)
1075 {
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);
1081         }
1082         return 0;
1083 }
1084
1085 console_initcall(sn_sal_serial_console_init);