blob: fee6418e84c42abd04b7293e0f47e4caaf307cbe [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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-2005 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/config.h>
41#include <linux/interrupt.h>
42#include <linux/tty.h>
43#include <linux/serial.h>
44#include <linux/console.h>
45#include <linux/module.h>
46#include <linux/sysrq.h>
47#include <linux/circ_buf.h>
48#include <linux/serial_reg.h>
49#include <linux/delay.h> /* for mdelay */
50#include <linux/miscdevice.h>
51#include <linux/serial_core.h>
52
53#include <asm/io.h>
54#include <asm/sn/simulator.h>
55#include <asm/sn/sn_sal.h>
56
57/* number of characters we can transmit to the SAL console at a time */
58#define SN_SAL_MAX_CHARS 120
59
60/* 64K, when we're asynch, it must be at least printk's LOG_BUF_LEN to
61 * avoid losing chars, (always has to be a power of 2) */
62#define SN_SAL_BUFFER_SIZE (64 * (1 << 10))
63
64#define SN_SAL_UART_FIFO_DEPTH 16
65#define SN_SAL_UART_FIFO_SPEED_CPS 9600/10
66
67/* sn_transmit_chars() calling args */
68#define TRANSMIT_BUFFERED 0
69#define TRANSMIT_RAW 1
70
71/* To use dynamic numbers only and not use the assigned major and minor,
72 * define the following.. */
73 /* #define USE_DYNAMIC_MINOR 1 *//* use dynamic minor number */
74#define USE_DYNAMIC_MINOR 0 /* Don't rely on misc_register dynamic minor */
75
76/* Device name we're using */
77#define DEVICE_NAME "ttySG"
78#define DEVICE_NAME_DYNAMIC "ttySG0" /* need full name for misc_register */
79/* The major/minor we are using, ignored for USE_DYNAMIC_MINOR */
80#define DEVICE_MAJOR 204
81#define DEVICE_MINOR 40
82
83#ifdef CONFIG_MAGIC_SYSRQ
84static char sysrq_serial_str[] = "\eSYS";
85static char *sysrq_serial_ptr = sysrq_serial_str;
86static unsigned long sysrq_requested;
87#endif /* CONFIG_MAGIC_SYSRQ */
88
89/*
90 * Port definition - this kinda drives it all
91 */
92struct sn_cons_port {
93 struct timer_list sc_timer;
94 struct uart_port sc_port;
95 struct sn_sal_ops {
96 int (*sal_puts_raw) (const char *s, int len);
97 int (*sal_puts) (const char *s, int len);
98 int (*sal_getc) (void);
99 int (*sal_input_pending) (void);
100 void (*sal_wakeup_transmit) (struct sn_cons_port *, int);
101 } *sc_ops;
102 unsigned long sc_interrupt_timeout;
103 int sc_is_asynch;
104};
105
106static struct sn_cons_port sal_console_port;
107static int sn_process_input;
108
109/* Only used if USE_DYNAMIC_MINOR is set to 1 */
110static struct miscdevice misc; /* used with misc_register for dynamic */
111
112extern void early_sn_setup(void);
113
114#undef DEBUG
115#ifdef DEBUG
116static int sn_debug_printf(const char *fmt, ...);
117#define DPRINTF(x...) sn_debug_printf(x)
118#else
119#define DPRINTF(x...) do { } while (0)
120#endif
121
122/* Prototypes */
123static int snt_hw_puts_raw(const char *, int);
124static int snt_hw_puts_buffered(const char *, int);
125static int snt_poll_getc(void);
126static int snt_poll_input_pending(void);
127static int snt_intr_getc(void);
128static int snt_intr_input_pending(void);
129static void sn_transmit_chars(struct sn_cons_port *, int);
130
131/* A table for polling:
132 */
133static struct sn_sal_ops poll_ops = {
134 .sal_puts_raw = snt_hw_puts_raw,
135 .sal_puts = snt_hw_puts_raw,
136 .sal_getc = snt_poll_getc,
137 .sal_input_pending = snt_poll_input_pending
138};
139
140/* A table for interrupts enabled */
141static struct sn_sal_ops intr_ops = {
142 .sal_puts_raw = snt_hw_puts_raw,
143 .sal_puts = snt_hw_puts_buffered,
144 .sal_getc = snt_intr_getc,
145 .sal_input_pending = snt_intr_input_pending,
146 .sal_wakeup_transmit = sn_transmit_chars
147};
148
149/* the console does output in two distinctly different ways:
150 * synchronous (raw) and asynchronous (buffered). initally, early_printk
151 * does synchronous output. any data written goes directly to the SAL
152 * to be output (incidentally, it is internally buffered by the SAL)
153 * after interrupts and timers are initialized and available for use,
154 * the console init code switches to asynchronous output. this is
155 * also the earliest opportunity to begin polling for console input.
156 * after console initialization, console output and tty (serial port)
157 * output is buffered and sent to the SAL asynchronously (either by
158 * timer callback or by UART interrupt) */
159
160/* routines for running the console in polling mode */
161
162/**
163 * snt_poll_getc - Get a character from the console in polling mode
164 *
165 */
166static int snt_poll_getc(void)
167{
168 int ch;
169
170 ia64_sn_console_getc(&ch);
171 return ch;
172}
173
174/**
175 * snt_poll_input_pending - Check if any input is waiting - polling mode.
176 *
177 */
178static int snt_poll_input_pending(void)
179{
180 int status, input;
181
182 status = ia64_sn_console_check(&input);
183 return !status && input;
184}
185
186/* routines for an interrupt driven console (normal) */
187
188/**
189 * snt_intr_getc - Get a character from the console, interrupt mode
190 *
191 */
192static int snt_intr_getc(void)
193{
194 return ia64_sn_console_readc();
195}
196
197/**
198 * snt_intr_input_pending - Check if input is pending, interrupt mode
199 *
200 */
201static int snt_intr_input_pending(void)
202{
203 return ia64_sn_console_intr_status() & SAL_CONSOLE_INTR_RECV;
204}
205
206/* these functions are polled and interrupt */
207
208/**
209 * snt_hw_puts_raw - Send raw string to the console, polled or interrupt mode
210 * @s: String
211 * @len: Length
212 *
213 */
214static int snt_hw_puts_raw(const char *s, int len)
215{
216 /* this will call the PROM and not return until this is done */
217 return ia64_sn_console_putb(s, len);
218}
219
220/**
221 * snt_hw_puts_buffered - Send string to console, polled or interrupt mode
222 * @s: String
223 * @len: Length
224 *
225 */
226static int snt_hw_puts_buffered(const char *s, int len)
227{
228 /* queue data to the PROM */
229 return ia64_sn_console_xmit_chars((char *)s, len);
230}
231
232/* uart interface structs
233 * These functions are associated with the uart_port that the serial core
234 * infrastructure calls.
235 *
236 * Note: Due to how the console works, many routines are no-ops.
237 */
238
239/**
240 * snp_type - What type of console are we?
241 * @port: Port to operate with (we ignore since we only have one port)
242 *
243 */
244static const char *snp_type(struct uart_port *port)
245{
246 return ("SGI SN L1");
247}
248
249/**
250 * snp_tx_empty - Is the transmitter empty? We pretend we're always empty
251 * @port: Port to operate on (we ignore since we only have one port)
252 *
253 */
254static unsigned int snp_tx_empty(struct uart_port *port)
255{
256 return 1;
257}
258
259/**
260 * snp_stop_tx - stop the transmitter - no-op for us
261 * @port: Port to operat eon - we ignore - no-op function
262 * @tty_stop: Set to 1 if called via uart_stop
263 *
264 */
265static void snp_stop_tx(struct uart_port *port, unsigned int tty_stop)
266{
267}
268
269/**
270 * snp_release_port - Free i/o and resources for port - no-op for us
271 * @port: Port to operate on - we ignore - no-op function
272 *
273 */
274static void snp_release_port(struct uart_port *port)
275{
276}
277
278/**
279 * snp_enable_ms - Force modem status interrupts on - no-op for us
280 * @port: Port to operate on - we ignore - no-op function
281 *
282 */
283static void snp_enable_ms(struct uart_port *port)
284{
285}
286
287/**
288 * snp_shutdown - shut down the port - free irq and disable - no-op for us
289 * @port: Port to shut down - we ignore
290 *
291 */
292static void snp_shutdown(struct uart_port *port)
293{
294}
295
296/**
297 * snp_set_mctrl - set control lines (dtr, rts, etc) - no-op for our console
298 * @port: Port to operate on - we ignore
299 * @mctrl: Lines to set/unset - we ignore
300 *
301 */
302static void snp_set_mctrl(struct uart_port *port, unsigned int mctrl)
303{
304}
305
306/**
307 * snp_get_mctrl - get contorl line info, we just return a static value
308 * @port: port to operate on - we only have one port so we ignore this
309 *
310 */
311static unsigned int snp_get_mctrl(struct uart_port *port)
312{
313 return TIOCM_CAR | TIOCM_RNG | TIOCM_DSR | TIOCM_CTS;
314}
315
316/**
317 * snp_stop_rx - Stop the receiver - we ignor ethis
318 * @port: Port to operate on - we ignore
319 *
320 */
321static void snp_stop_rx(struct uart_port *port)
322{
323}
324
325/**
326 * snp_start_tx - Start transmitter
327 * @port: Port to operate on
328 * @tty_stop: Set to 1 if called via uart_start
329 *
330 */
331static void snp_start_tx(struct uart_port *port, unsigned int tty_stop)
332{
333 if (sal_console_port.sc_ops->sal_wakeup_transmit)
334 sal_console_port.sc_ops->sal_wakeup_transmit(&sal_console_port,
335 TRANSMIT_BUFFERED);
336
337}
338
339/**
340 * snp_break_ctl - handle breaks - ignored by us
341 * @port: Port to operate on
342 * @break_state: Break state
343 *
344 */
345static void snp_break_ctl(struct uart_port *port, int break_state)
346{
347}
348
349/**
350 * snp_startup - Start up the serial port - always return 0 (We're always on)
351 * @port: Port to operate on
352 *
353 */
354static int snp_startup(struct uart_port *port)
355{
356 return 0;
357}
358
359/**
360 * snp_set_termios - set termios stuff - we ignore these
361 * @port: port to operate on
362 * @termios: New settings
363 * @termios: Old
364 *
365 */
366static void
367snp_set_termios(struct uart_port *port, struct termios *termios,
368 struct termios *old)
369{
370}
371
372/**
373 * snp_request_port - allocate resources for port - ignored by us
374 * @port: port to operate on
375 *
376 */
377static int snp_request_port(struct uart_port *port)
378{
379 return 0;
380}
381
382/**
383 * snp_config_port - allocate resources, set up - we ignore, we're always on
384 * @port: Port to operate on
385 * @flags: flags used for port setup
386 *
387 */
388static void snp_config_port(struct uart_port *port, int flags)
389{
390}
391
392/* Associate the uart functions above - given to serial core */
393
394static struct uart_ops sn_console_ops = {
395 .tx_empty = snp_tx_empty,
396 .set_mctrl = snp_set_mctrl,
397 .get_mctrl = snp_get_mctrl,
398 .stop_tx = snp_stop_tx,
399 .start_tx = snp_start_tx,
400 .stop_rx = snp_stop_rx,
401 .enable_ms = snp_enable_ms,
402 .break_ctl = snp_break_ctl,
403 .startup = snp_startup,
404 .shutdown = snp_shutdown,
405 .set_termios = snp_set_termios,
406 .pm = NULL,
407 .type = snp_type,
408 .release_port = snp_release_port,
409 .request_port = snp_request_port,
410 .config_port = snp_config_port,
411 .verify_port = NULL,
412};
413
414/* End of uart struct functions and defines */
415
416#ifdef DEBUG
417
418/**
419 * sn_debug_printf - close to hardware debugging printf
420 * @fmt: printf format
421 *
422 * This is as "close to the metal" as we can get, used when the driver
423 * itself may be broken.
424 *
425 */
426static int sn_debug_printf(const char *fmt, ...)
427{
428 static char printk_buf[1024];
429 int printed_len;
430 va_list args;
431
432 va_start(args, fmt);
433 printed_len = vsnprintf(printk_buf, sizeof(printk_buf), fmt, args);
434
435 if (!sal_console_port.sc_ops) {
436 sal_console_port.sc_ops = &poll_ops;
437 early_sn_setup();
438 }
439 sal_console_port.sc_ops->sal_puts_raw(printk_buf, printed_len);
440
441 va_end(args);
442 return printed_len;
443}
444#endif /* DEBUG */
445
446/*
447 * Interrupt handling routines.
448 */
449
450/**
451 * sn_receive_chars - Grab characters, pass them to tty layer
452 * @port: Port to operate on
453 * @regs: Saved registers (needed by uart_handle_sysrq_char)
454 * @flags: irq flags
455 *
456 * Note: If we're not registered with the serial core infrastructure yet,
457 * we don't try to send characters to it...
458 *
459 */
460static void
461sn_receive_chars(struct sn_cons_port *port, struct pt_regs *regs,
462 unsigned long flags)
463{
464 int ch;
465 struct tty_struct *tty;
466
467 if (!port) {
468 printk(KERN_ERR "sn_receive_chars - port NULL so can't receieve\n");
469 return;
470 }
471
472 if (!port->sc_ops) {
473 printk(KERN_ERR "sn_receive_chars - port->sc_ops NULL so can't receieve\n");
474 return;
475 }
476
477 if (port->sc_port.info) {
478 /* The serial_core stuffs are initilized, use them */
479 tty = port->sc_port.info->tty;
480 }
481 else {
482 /* Not registered yet - can't pass to tty layer. */
483 tty = NULL;
484 }
485
486 while (port->sc_ops->sal_input_pending()) {
487 ch = port->sc_ops->sal_getc();
488 if (ch < 0) {
489 printk(KERN_ERR "sn_console: An error occured while "
490 "obtaining data from the console (0x%0x)\n", ch);
491 break;
492 }
493#ifdef CONFIG_MAGIC_SYSRQ
494 if (sysrq_requested) {
495 unsigned long sysrq_timeout = sysrq_requested + HZ*5;
496
497 sysrq_requested = 0;
498 if (ch && time_before(jiffies, sysrq_timeout)) {
499 spin_unlock_irqrestore(&port->sc_port.lock, flags);
500 handle_sysrq(ch, regs, NULL);
501 spin_lock_irqsave(&port->sc_port.lock, flags);
502 /* ignore actual sysrq command char */
503 continue;
504 }
505 }
506 if (ch == *sysrq_serial_ptr) {
507 if (!(*++sysrq_serial_ptr)) {
508 sysrq_requested = jiffies;
509 sysrq_serial_ptr = sysrq_serial_str;
510 }
511 /*
512 * ignore the whole sysrq string except for the
513 * leading escape
514 */
515 if (ch != '\e')
516 continue;
517 }
518 else
519 sysrq_serial_ptr = sysrq_serial_str;
520#endif /* CONFIG_MAGIC_SYSRQ */
521
522 /* record the character to pass up to the tty layer */
523 if (tty) {
524 *tty->flip.char_buf_ptr = ch;
525 *tty->flip.flag_buf_ptr = TTY_NORMAL;
526 tty->flip.char_buf_ptr++;
527 tty->flip.count++;
528 if (tty->flip.count == TTY_FLIPBUF_SIZE)
529 break;
530 }
531 port->sc_port.icount.rx++;
532 }
533
534 if (tty)
535 tty_flip_buffer_push(tty);
536}
537
538/**
539 * sn_transmit_chars - grab characters from serial core, send off
540 * @port: Port to operate on
541 * @raw: Transmit raw or buffered
542 *
543 * Note: If we're early, before we're registered with serial core, the
544 * writes are going through sn_sal_console_write because that's how
545 * register_console has been set up. We currently could have asynch
546 * polls calling this function due to sn_sal_switch_to_asynch but we can
547 * ignore them until we register with the serial core stuffs.
548 *
549 */
550static void sn_transmit_chars(struct sn_cons_port *port, int raw)
551{
552 int xmit_count, tail, head, loops, ii;
553 int result;
554 char *start;
555 struct circ_buf *xmit;
556
557 if (!port)
558 return;
559
560 BUG_ON(!port->sc_is_asynch);
561
562 if (port->sc_port.info) {
563 /* We're initilized, using serial core infrastructure */
564 xmit = &port->sc_port.info->xmit;
565 } else {
566 /* Probably sn_sal_switch_to_asynch has been run but serial core isn't
567 * initilized yet. Just return. Writes are going through
568 * sn_sal_console_write (due to register_console) at this time.
569 */
570 return;
571 }
572
573 if (uart_circ_empty(xmit) || uart_tx_stopped(&port->sc_port)) {
574 /* Nothing to do. */
575 return;
576 }
577
578 head = xmit->head;
579 tail = xmit->tail;
580 start = &xmit->buf[tail];
581
582 /* twice around gets the tail to the end of the buffer and
583 * then to the head, if needed */
584 loops = (head < tail) ? 2 : 1;
585
586 for (ii = 0; ii < loops; ii++) {
587 xmit_count = (head < tail) ?
588 (UART_XMIT_SIZE - tail) : (head - tail);
589
590 if (xmit_count > 0) {
591 if (raw == TRANSMIT_RAW)
592 result =
593 port->sc_ops->sal_puts_raw(start,
594 xmit_count);
595 else
596 result =
597 port->sc_ops->sal_puts(start, xmit_count);
598#ifdef DEBUG
599 if (!result)
600 DPRINTF("`");
601#endif
602 if (result > 0) {
603 xmit_count -= result;
604 port->sc_port.icount.tx += result;
605 tail += result;
606 tail &= UART_XMIT_SIZE - 1;
607 xmit->tail = tail;
608 start = &xmit->buf[tail];
609 }
610 }
611 }
612
613 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
614 uart_write_wakeup(&port->sc_port);
615
616 if (uart_circ_empty(xmit))
617 snp_stop_tx(&port->sc_port, 0); /* no-op for us */
618}
619
620/**
621 * sn_sal_interrupt - Handle console interrupts
622 * @irq: irq #, useful for debug statements
623 * @dev_id: our pointer to our port (sn_cons_port which contains the uart port)
624 * @regs: Saved registers, used by sn_receive_chars for uart_handle_sysrq_char
625 *
626 */
627static irqreturn_t sn_sal_interrupt(int irq, void *dev_id, struct pt_regs *regs)
628{
629 struct sn_cons_port *port = (struct sn_cons_port *)dev_id;
630 unsigned long flags;
631 int status = ia64_sn_console_intr_status();
632
633 if (!port)
634 return IRQ_NONE;
635
636 spin_lock_irqsave(&port->sc_port.lock, flags);
637 if (status & SAL_CONSOLE_INTR_RECV) {
638 sn_receive_chars(port, regs, flags);
639 }
640 if (status & SAL_CONSOLE_INTR_XMIT) {
641 sn_transmit_chars(port, TRANSMIT_BUFFERED);
642 }
643 spin_unlock_irqrestore(&port->sc_port.lock, flags);
644 return IRQ_HANDLED;
645}
646
647/**
648 * sn_sal_connect_interrupt - Request interrupt, handled by sn_sal_interrupt
649 * @port: Our sn_cons_port (which contains the uart port)
650 *
651 * returns the console irq if interrupt is successfully registered, else 0
652 *
653 */
654static int sn_sal_connect_interrupt(struct sn_cons_port *port)
655{
656 if (request_irq(SGI_UART_VECTOR, sn_sal_interrupt,
657 SA_INTERRUPT | SA_SHIRQ,
658 "SAL console driver", port) >= 0) {
659 return SGI_UART_VECTOR;
660 }
661
662 printk(KERN_INFO "sn_console: console proceeding in polled mode\n");
663 return 0;
664}
665
666/**
667 * sn_sal_timer_poll - this function handles polled console mode
668 * @data: A pointer to our sn_cons_port (which contains the uart port)
669 *
670 * data is the pointer that init_timer will store for us. This function is
671 * associated with init_timer to see if there is any console traffic.
672 * Obviously not used in interrupt mode
673 *
674 */
675static void sn_sal_timer_poll(unsigned long data)
676{
677 struct sn_cons_port *port = (struct sn_cons_port *)data;
678 unsigned long flags;
679
680 if (!port)
681 return;
682
683 if (!port->sc_port.irq) {
684 spin_lock_irqsave(&port->sc_port.lock, flags);
685 if (sn_process_input)
686 sn_receive_chars(port, NULL, flags);
687 sn_transmit_chars(port, TRANSMIT_RAW);
688 spin_unlock_irqrestore(&port->sc_port.lock, flags);
689 mod_timer(&port->sc_timer,
690 jiffies + port->sc_interrupt_timeout);
691 }
692}
693
694/*
695 * Boot-time initialization code
696 */
697
698/**
699 * sn_sal_switch_to_asynch - Switch to async mode (as opposed to synch)
700 * @port: Our sn_cons_port (which contains the uart port)
701 *
702 * So this is used by sn_sal_serial_console_init (early on, before we're
703 * registered with serial core). It's also used by sn_sal_module_init
704 * right after we've registered with serial core. The later only happens
705 * if we didn't already come through here via sn_sal_serial_console_init.
706 *
707 */
708static void __init sn_sal_switch_to_asynch(struct sn_cons_port *port)
709{
710 unsigned long flags;
711
712 if (!port)
713 return;
714
715 DPRINTF("sn_console: about to switch to asynchronous console\n");
716
717 /* without early_printk, we may be invoked late enough to race
718 * with other cpus doing console IO at this point, however
719 * console interrupts will never be enabled */
720 spin_lock_irqsave(&port->sc_port.lock, flags);
721
722 /* early_printk invocation may have done this for us */
723 if (!port->sc_ops)
724 port->sc_ops = &poll_ops;
725
726 /* we can't turn on the console interrupt (as request_irq
727 * calls kmalloc, which isn't set up yet), so we rely on a
728 * timer to poll for input and push data from the console
729 * buffer.
730 */
731 init_timer(&port->sc_timer);
732 port->sc_timer.function = sn_sal_timer_poll;
733 port->sc_timer.data = (unsigned long)port;
734
735 if (IS_RUNNING_ON_SIMULATOR())
736 port->sc_interrupt_timeout = 6;
737 else {
738 /* 960cps / 16 char FIFO = 60HZ
739 * HZ / (SN_SAL_FIFO_SPEED_CPS / SN_SAL_FIFO_DEPTH) */
740 port->sc_interrupt_timeout =
741 HZ * SN_SAL_UART_FIFO_DEPTH / SN_SAL_UART_FIFO_SPEED_CPS;
742 }
743 mod_timer(&port->sc_timer, jiffies + port->sc_interrupt_timeout);
744
745 port->sc_is_asynch = 1;
746 spin_unlock_irqrestore(&port->sc_port.lock, flags);
747}
748
749/**
750 * sn_sal_switch_to_interrupts - Switch to interrupt driven mode
751 * @port: Our sn_cons_port (which contains the uart port)
752 *
753 * In sn_sal_module_init, after we're registered with serial core and
754 * the port is added, this function is called to switch us to interrupt
755 * mode. We were previously in asynch/polling mode (using init_timer).
756 *
757 * We attempt to switch to interrupt mode here by calling
758 * sn_sal_connect_interrupt. If that works out, we enable receive interrupts.
759 */
760static void __init sn_sal_switch_to_interrupts(struct sn_cons_port *port)
761{
762 int irq;
763 unsigned long flags;
764
765 if (!port)
766 return;
767
768 DPRINTF("sn_console: switching to interrupt driven console\n");
769
770 spin_lock_irqsave(&port->sc_port.lock, flags);
771
772 irq = sn_sal_connect_interrupt(port);
773
774 if (irq) {
775 port->sc_port.irq = irq;
776 port->sc_ops = &intr_ops;
777
778 /* turn on receive interrupts */
779 ia64_sn_console_intr_enable(SAL_CONSOLE_INTR_RECV);
780 }
781 spin_unlock_irqrestore(&port->sc_port.lock, flags);
782}
783
784/*
785 * Kernel console definitions
786 */
787
788static void sn_sal_console_write(struct console *, const char *, unsigned);
789static int __init sn_sal_console_setup(struct console *, char *);
Andreas Schwab434498d2005-05-01 08:59:12 -0700790static struct uart_driver sal_console_uart;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791extern struct tty_driver *uart_console_device(struct console *, int *);
792
793static struct console sal_console = {
794 .name = DEVICE_NAME,
795 .write = sn_sal_console_write,
796 .device = uart_console_device,
797 .setup = sn_sal_console_setup,
798 .index = -1, /* unspecified */
799 .data = &sal_console_uart,
800};
801
802#define SAL_CONSOLE &sal_console
803
Andreas Schwab434498d2005-05-01 08:59:12 -0700804static struct uart_driver sal_console_uart = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 .owner = THIS_MODULE,
806 .driver_name = "sn_console",
807 .dev_name = DEVICE_NAME,
808 .major = 0, /* major/minor set at registration time per USE_DYNAMIC_MINOR */
809 .minor = 0,
810 .nr = 1, /* one port */
811 .cons = SAL_CONSOLE,
812};
813
814/**
815 * sn_sal_module_init - When the kernel loads us, get us rolling w/ serial core
816 *
817 * Before this is called, we've been printing kernel messages in a special
818 * early mode not making use of the serial core infrastructure. When our
819 * driver is loaded for real, we register the driver and port with serial
820 * core and try to enable interrupt driven mode.
821 *
822 */
823static int __init sn_sal_module_init(void)
824{
825 int retval;
826
827 if (!ia64_platform_is("sn2"))
828 return -ENODEV;
829
830 printk(KERN_INFO "sn_console: Console driver init\n");
831
832 if (USE_DYNAMIC_MINOR == 1) {
833 misc.minor = MISC_DYNAMIC_MINOR;
834 misc.name = DEVICE_NAME_DYNAMIC;
835 retval = misc_register(&misc);
836 if (retval != 0) {
837 printk
838 ("Failed to register console device using misc_register.\n");
839 return -ENODEV;
840 }
841 sal_console_uart.major = MISC_MAJOR;
842 sal_console_uart.minor = misc.minor;
843 } else {
844 sal_console_uart.major = DEVICE_MAJOR;
845 sal_console_uart.minor = DEVICE_MINOR;
846 }
847
848 /* We register the driver and the port before switching to interrupts
849 * or async above so the proper uart structures are populated */
850
851 if (uart_register_driver(&sal_console_uart) < 0) {
852 printk
853 ("ERROR sn_sal_module_init failed uart_register_driver, line %d\n",
854 __LINE__);
855 return -ENODEV;
856 }
857
858 spin_lock_init(&sal_console_port.sc_port.lock);
859
860 /* Setup the port struct with the minimum needed */
861 sal_console_port.sc_port.membase = (char *)1; /* just needs to be non-zero */
862 sal_console_port.sc_port.type = PORT_16550A;
863 sal_console_port.sc_port.fifosize = SN_SAL_MAX_CHARS;
864 sal_console_port.sc_port.ops = &sn_console_ops;
865 sal_console_port.sc_port.line = 0;
866
867 if (uart_add_one_port(&sal_console_uart, &sal_console_port.sc_port) < 0) {
868 /* error - not sure what I'd do - so I'll do nothing */
869 printk(KERN_ERR "%s: unable to add port\n", __FUNCTION__);
870 }
871
872 /* when this driver is compiled in, the console initialization
873 * will have already switched us into asynchronous operation
874 * before we get here through the module initcalls */
875 if (!sal_console_port.sc_is_asynch) {
876 sn_sal_switch_to_asynch(&sal_console_port);
877 }
878
879 /* at this point (module_init) we can try to turn on interrupts */
880 if (!IS_RUNNING_ON_SIMULATOR()) {
881 sn_sal_switch_to_interrupts(&sal_console_port);
882 }
883 sn_process_input = 1;
884 return 0;
885}
886
887/**
888 * sn_sal_module_exit - When we're unloaded, remove the driver/port
889 *
890 */
891static void __exit sn_sal_module_exit(void)
892{
893 del_timer_sync(&sal_console_port.sc_timer);
894 uart_remove_one_port(&sal_console_uart, &sal_console_port.sc_port);
895 uart_unregister_driver(&sal_console_uart);
896 misc_deregister(&misc);
897}
898
899module_init(sn_sal_module_init);
900module_exit(sn_sal_module_exit);
901
902/**
903 * puts_raw_fixed - sn_sal_console_write helper for adding \r's as required
904 * @puts_raw : puts function to do the writing
905 * @s: input string
906 * @count: length
907 *
908 * We need a \r ahead of every \n for direct writes through
909 * ia64_sn_console_putb (what sal_puts_raw below actually does).
910 *
911 */
912
913static void puts_raw_fixed(int (*puts_raw) (const char *s, int len),
914 const char *s, int count)
915{
916 const char *s1;
917
918 /* Output '\r' before each '\n' */
919 while ((s1 = memchr(s, '\n', count)) != NULL) {
920 puts_raw(s, s1 - s);
921 puts_raw("\r\n", 2);
922 count -= s1 + 1 - s;
923 s = s1 + 1;
924 }
925 puts_raw(s, count);
926}
927
928/**
929 * sn_sal_console_write - Print statements before serial core available
930 * @console: Console to operate on - we ignore since we have just one
931 * @s: String to send
932 * @count: length
933 *
934 * This is referenced in the console struct. It is used for early
935 * console printing before we register with serial core and for things
936 * such as kdb. The console_lock must be held when we get here.
937 *
938 * This function has some code for trying to print output even if the lock
939 * is held. We try to cover the case where a lock holder could have died.
940 * We don't use this special case code if we're not registered with serial
941 * core yet. After we're registered with serial core, the only time this
942 * function would be used is for high level kernel output like magic sys req,
943 * kdb, and printk's.
944 */
945static void
946sn_sal_console_write(struct console *co, const char *s, unsigned count)
947{
948 unsigned long flags = 0;
949 struct sn_cons_port *port = &sal_console_port;
950#if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT)
951 static int stole_lock = 0;
952#endif
953
954 BUG_ON(!port->sc_is_asynch);
955
956 /* We can't look at the xmit buffer if we're not registered with serial core
957 * yet. So only do the fancy recovery after registering
958 */
959 if (port->sc_port.info) {
960
961 /* somebody really wants this output, might be an
962 * oops, kdb, panic, etc. make sure they get it. */
963#if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT)
964 if (spin_is_locked(&port->sc_port.lock)) {
965 int lhead = port->sc_port.info->xmit.head;
966 int ltail = port->sc_port.info->xmit.tail;
967 int counter, got_lock = 0;
968
969 /*
970 * We attempt to determine if someone has died with the
971 * lock. We wait ~20 secs after the head and tail ptrs
972 * stop moving and assume the lock holder is not functional
973 * and plow ahead. If the lock is freed within the time out
974 * period we re-get the lock and go ahead normally. We also
975 * remember if we have plowed ahead so that we don't have
976 * to wait out the time out period again - the asumption
977 * is that we will time out again.
978 */
979
980 for (counter = 0; counter < 150; mdelay(125), counter++) {
981 if (!spin_is_locked(&port->sc_port.lock)
982 || stole_lock) {
983 if (!stole_lock) {
984 spin_lock_irqsave(&port->
985 sc_port.lock,
986 flags);
987 got_lock = 1;
988 }
989 break;
990 } else {
991 /* still locked */
992 if ((lhead !=
993 port->sc_port.info->xmit.head)
994 || (ltail !=
995 port->sc_port.info->xmit.
996 tail)) {
997 lhead =
998 port->sc_port.info->xmit.
999 head;
1000 ltail =
1001 port->sc_port.info->xmit.
1002 tail;
1003 counter = 0;
1004 }
1005 }
1006 }
1007 /* flush anything in the serial core xmit buffer, raw */
1008 sn_transmit_chars(port, 1);
1009 if (got_lock) {
1010 spin_unlock_irqrestore(&port->sc_port.lock,
1011 flags);
1012 stole_lock = 0;
1013 } else {
1014 /* fell thru */
1015 stole_lock = 1;
1016 }
1017 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
1018 } else {
1019 stole_lock = 0;
1020#endif
1021 spin_lock_irqsave(&port->sc_port.lock, flags);
1022 sn_transmit_chars(port, 1);
1023 spin_unlock_irqrestore(&port->sc_port.lock, flags);
1024
1025 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
1026#if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT)
1027 }
1028#endif
1029 }
1030 else {
1031 /* Not yet registered with serial core - simple case */
1032 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
1033 }
1034}
1035
1036
1037/**
1038 * sn_sal_console_setup - Set up console for early printing
1039 * @co: Console to work with
1040 * @options: Options to set
1041 *
1042 * Altix console doesn't do anything with baud rates, etc, anyway.
1043 *
1044 * This isn't required since not providing the setup function in the
1045 * console struct is ok. However, other patches like KDB plop something
1046 * here so providing it is easier.
1047 *
1048 */
1049static int __init sn_sal_console_setup(struct console *co, char *options)
1050{
1051 return 0;
1052}
1053
1054/**
1055 * sn_sal_console_write_early - simple early output routine
1056 * @co - console struct
1057 * @s - string to print
1058 * @count - count
1059 *
1060 * Simple function to provide early output, before even
1061 * sn_sal_serial_console_init is called. Referenced in the
1062 * console struct registerd in sn_serial_console_early_setup.
1063 *
1064 */
1065static void __init
1066sn_sal_console_write_early(struct console *co, const char *s, unsigned count)
1067{
1068 puts_raw_fixed(sal_console_port.sc_ops->sal_puts_raw, s, count);
1069}
1070
1071/* Used for very early console printing - again, before
1072 * sn_sal_serial_console_init is run */
1073static struct console sal_console_early __initdata = {
1074 .name = "sn_sal",
1075 .write = sn_sal_console_write_early,
1076 .flags = CON_PRINTBUFFER,
1077 .index = -1,
1078};
1079
1080/**
1081 * sn_serial_console_early_setup - Sets up early console output support
1082 *
1083 * Register a console early on... This is for output before even
1084 * sn_sal_serial_cosnole_init is called. This function is called from
1085 * setup.c. This allows us to do really early polled writes. When
1086 * sn_sal_serial_console_init is called, this console is unregistered
1087 * and a new one registered.
1088 */
1089int __init sn_serial_console_early_setup(void)
1090{
1091 if (!ia64_platform_is("sn2"))
1092 return -1;
1093
1094 sal_console_port.sc_ops = &poll_ops;
1095 early_sn_setup(); /* Find SAL entry points */
1096 register_console(&sal_console_early);
1097
1098 return 0;
1099}
1100
1101/**
1102 * sn_sal_serial_console_init - Early console output - set up for register
1103 *
1104 * This function is called when regular console init happens. Because we
1105 * support even earlier console output with sn_serial_console_early_setup
1106 * (called from setup.c directly), this function unregisters the really
1107 * early console.
1108 *
1109 * Note: Even if setup.c doesn't register sal_console_early, unregistering
1110 * it here doesn't hurt anything.
1111 *
1112 */
1113static int __init sn_sal_serial_console_init(void)
1114{
1115 if (ia64_platform_is("sn2")) {
1116 sn_sal_switch_to_asynch(&sal_console_port);
1117 DPRINTF("sn_sal_serial_console_init : register console\n");
1118 register_console(&sal_console);
1119 unregister_console(&sal_console_early);
1120 }
1121 return 0;
1122}
1123
1124console_initcall(sn_sal_serial_console_init);