ia64/linux-2.6.18-xen.hg

view drivers/serial/sn_console.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
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 */
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>
52 #include <asm/io.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 */
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 };
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);
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
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);
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 };
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 };
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) */
159 /* routines for running the console in polling mode */
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;
169 ia64_sn_console_getc(&ch);
170 return ch;
171 }
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;
181 status = ia64_sn_console_check(&input);
182 return !status && input;
183 }
185 /* routines for an interrupt driven console (normal) */
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 }
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 }
205 /* these functions are polled and interrupt */
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 }
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 }
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 */
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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);
334 }
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 }
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 }
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 termios *termios,
365 struct termios *old)
366 {
367 }
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 }
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 }
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,
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 };
411 /* End of uart struct functions and defines */
413 #ifdef DEBUG
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;
429 va_start(args, fmt);
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;
434 early_sn_setup();
435 }
436 sal_console_port.sc_ops->sal_puts_raw(printk_buf, printed_len);
438 va_end(args);
439 return printed_len;
440 }
441 #endif /* DEBUG */
443 /*
444 * Interrupt handling routines.
445 */
447 /**
448 * sn_receive_chars - Grab characters, pass them to tty layer
449 * @port: Port to operate on
450 * @regs: Saved registers (needed by uart_handle_sysrq_char)
451 * @flags: irq flags
452 *
453 * Note: If we're not registered with the serial core infrastructure yet,
454 * we don't try to send characters to it...
455 *
456 */
457 static void
458 sn_receive_chars(struct sn_cons_port *port, struct pt_regs *regs,
459 unsigned long flags)
460 {
461 int ch;
462 struct tty_struct *tty;
464 if (!port) {
465 printk(KERN_ERR "sn_receive_chars - port NULL so can't receieve\n");
466 return;
467 }
469 if (!port->sc_ops) {
470 printk(KERN_ERR "sn_receive_chars - port->sc_ops NULL so can't receieve\n");
471 return;
472 }
474 if (port->sc_port.info) {
475 /* The serial_core stuffs are initilized, use them */
476 tty = port->sc_port.info->tty;
477 }
478 else {
479 /* Not registered yet - can't pass to tty layer. */
480 tty = NULL;
481 }
483 while (port->sc_ops->sal_input_pending()) {
484 ch = port->sc_ops->sal_getc();
485 if (ch < 0) {
486 printk(KERN_ERR "sn_console: An error occured while "
487 "obtaining data from the console (0x%0x)\n", ch);
488 break;
489 }
490 #ifdef CONFIG_MAGIC_SYSRQ
491 if (sysrq_requested) {
492 unsigned long sysrq_timeout = sysrq_requested + HZ*5;
494 sysrq_requested = 0;
495 if (ch && time_before(jiffies, sysrq_timeout)) {
496 spin_unlock_irqrestore(&port->sc_port.lock, flags);
497 handle_sysrq(ch, regs, NULL);
498 spin_lock_irqsave(&port->sc_port.lock, flags);
499 /* ignore actual sysrq command char */
500 continue;
501 }
502 }
503 if (ch == *sysrq_serial_ptr) {
504 if (!(*++sysrq_serial_ptr)) {
505 sysrq_requested = jiffies;
506 sysrq_serial_ptr = sysrq_serial_str;
507 }
508 /*
509 * ignore the whole sysrq string except for the
510 * leading escape
511 */
512 if (ch != '\e')
513 continue;
514 }
515 else
516 sysrq_serial_ptr = sysrq_serial_str;
517 #endif /* CONFIG_MAGIC_SYSRQ */
519 /* record the character to pass up to the tty layer */
520 if (tty) {
521 if(tty_insert_flip_char(tty, ch, TTY_NORMAL) == 0)
522 break;
523 }
524 port->sc_port.icount.rx++;
525 }
527 if (tty)
528 tty_flip_buffer_push(tty);
529 }
531 /**
532 * sn_transmit_chars - grab characters from serial core, send off
533 * @port: Port to operate on
534 * @raw: Transmit raw or buffered
535 *
536 * Note: If we're early, before we're registered with serial core, the
537 * writes are going through sn_sal_console_write because that's how
538 * register_console has been set up. We currently could have asynch
539 * polls calling this function due to sn_sal_switch_to_asynch but we can
540 * ignore them until we register with the serial core stuffs.
541 *
542 */
543 static void sn_transmit_chars(struct sn_cons_port *port, int raw)
544 {
545 int xmit_count, tail, head, loops, ii;
546 int result;
547 char *start;
548 struct circ_buf *xmit;
550 if (!port)
551 return;
553 BUG_ON(!port->sc_is_asynch);
555 if (port->sc_port.info) {
556 /* We're initilized, using serial core infrastructure */
557 xmit = &port->sc_port.info->xmit;
558 } else {
559 /* Probably sn_sal_switch_to_asynch has been run but serial core isn't
560 * initilized yet. Just return. Writes are going through
561 * sn_sal_console_write (due to register_console) at this time.
562 */
563 return;
564 }
566 if (uart_circ_empty(xmit) || uart_tx_stopped(&port->sc_port)) {
567 /* Nothing to do. */
568 ia64_sn_console_intr_disable(SAL_CONSOLE_INTR_XMIT);
569 return;
570 }
572 head = xmit->head;
573 tail = xmit->tail;
574 start = &xmit->buf[tail];
576 /* twice around gets the tail to the end of the buffer and
577 * then to the head, if needed */
578 loops = (head < tail) ? 2 : 1;
580 for (ii = 0; ii < loops; ii++) {
581 xmit_count = (head < tail) ?
582 (UART_XMIT_SIZE - tail) : (head - tail);
584 if (xmit_count > 0) {
585 if (raw == TRANSMIT_RAW)
586 result =
587 port->sc_ops->sal_puts_raw(start,
588 xmit_count);
589 else
590 result =
591 port->sc_ops->sal_puts(start, xmit_count);
592 #ifdef DEBUG
593 if (!result)
594 DPRINTF("`");
595 #endif
596 if (result > 0) {
597 xmit_count -= result;
598 port->sc_port.icount.tx += result;
599 tail += result;
600 tail &= UART_XMIT_SIZE - 1;
601 xmit->tail = tail;
602 start = &xmit->buf[tail];
603 }
604 }
605 }
607 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
608 uart_write_wakeup(&port->sc_port);
610 if (uart_circ_empty(xmit))
611 snp_stop_tx(&port->sc_port); /* no-op for us */
612 }
614 /**
615 * sn_sal_interrupt - Handle console interrupts
616 * @irq: irq #, useful for debug statements
617 * @dev_id: our pointer to our port (sn_cons_port which contains the uart port)
618 * @regs: Saved registers, used by sn_receive_chars for uart_handle_sysrq_char
619 *
620 */
621 static irqreturn_t sn_sal_interrupt(int irq, void *dev_id, struct pt_regs *regs)
622 {
623 struct sn_cons_port *port = (struct sn_cons_port *)dev_id;
624 unsigned long flags;
625 int status = ia64_sn_console_intr_status();
627 if (!port)
628 return IRQ_NONE;
630 spin_lock_irqsave(&port->sc_port.lock, flags);
631 if (status & SAL_CONSOLE_INTR_RECV) {
632 sn_receive_chars(port, regs, flags);
633 }
634 if (status & SAL_CONSOLE_INTR_XMIT) {
635 sn_transmit_chars(port, TRANSMIT_BUFFERED);
636 }
637 spin_unlock_irqrestore(&port->sc_port.lock, flags);
638 return IRQ_HANDLED;
639 }
641 /**
642 * sn_sal_connect_interrupt - Request interrupt, handled by sn_sal_interrupt
643 * @port: Our sn_cons_port (which contains the uart port)
644 *
645 * returns the console irq if interrupt is successfully registered, else 0
646 *
647 */
648 static int sn_sal_connect_interrupt(struct sn_cons_port *port)
649 {
650 if (request_irq(SGI_UART_VECTOR, sn_sal_interrupt,
651 IRQF_DISABLED | IRQF_SHARED,
652 "SAL console driver", port) >= 0) {
653 return SGI_UART_VECTOR;
654 }
656 printk(KERN_INFO "sn_console: console proceeding in polled mode\n");
657 return 0;
658 }
660 /**
661 * sn_sal_timer_poll - this function handles polled console mode
662 * @data: A pointer to our sn_cons_port (which contains the uart port)
663 *
664 * data is the pointer that init_timer will store for us. This function is
665 * associated with init_timer to see if there is any console traffic.
666 * Obviously not used in interrupt mode
667 *
668 */
669 static void sn_sal_timer_poll(unsigned long data)
670 {
671 struct sn_cons_port *port = (struct sn_cons_port *)data;
672 unsigned long flags;
674 if (!port)
675 return;
677 if (!port->sc_port.irq) {
678 spin_lock_irqsave(&port->sc_port.lock, flags);
679 if (sn_process_input)
680 sn_receive_chars(port, NULL, flags);
681 sn_transmit_chars(port, TRANSMIT_RAW);
682 spin_unlock_irqrestore(&port->sc_port.lock, flags);
683 mod_timer(&port->sc_timer,
684 jiffies + port->sc_interrupt_timeout);
685 }
686 }
688 /*
689 * Boot-time initialization code
690 */
692 /**
693 * sn_sal_switch_to_asynch - Switch to async mode (as opposed to synch)
694 * @port: Our sn_cons_port (which contains the uart port)
695 *
696 * So this is used by sn_sal_serial_console_init (early on, before we're
697 * registered with serial core). It's also used by sn_sal_module_init
698 * right after we've registered with serial core. The later only happens
699 * if we didn't already come through here via sn_sal_serial_console_init.
700 *
701 */
702 static void __init sn_sal_switch_to_asynch(struct sn_cons_port *port)
703 {
704 unsigned long flags;
706 if (!port)
707 return;
709 DPRINTF("sn_console: about to switch to asynchronous console\n");
711 /* without early_printk, we may be invoked late enough to race
712 * with other cpus doing console IO at this point, however
713 * console interrupts will never be enabled */
714 spin_lock_irqsave(&port->sc_port.lock, flags);
716 /* early_printk invocation may have done this for us */
717 if (!port->sc_ops)
718 port->sc_ops = &poll_ops;
720 /* we can't turn on the console interrupt (as request_irq
721 * calls kmalloc, which isn't set up yet), so we rely on a
722 * timer to poll for input and push data from the console
723 * buffer.
724 */
725 init_timer(&port->sc_timer);
726 port->sc_timer.function = sn_sal_timer_poll;
727 port->sc_timer.data = (unsigned long)port;
729 if (IS_RUNNING_ON_SIMULATOR())
730 port->sc_interrupt_timeout = 6;
731 else {
732 /* 960cps / 16 char FIFO = 60HZ
733 * HZ / (SN_SAL_FIFO_SPEED_CPS / SN_SAL_FIFO_DEPTH) */
734 port->sc_interrupt_timeout =
735 HZ * SN_SAL_UART_FIFO_DEPTH / SN_SAL_UART_FIFO_SPEED_CPS;
736 }
737 mod_timer(&port->sc_timer, jiffies + port->sc_interrupt_timeout);
739 port->sc_is_asynch = 1;
740 spin_unlock_irqrestore(&port->sc_port.lock, flags);
741 }
743 /**
744 * sn_sal_switch_to_interrupts - Switch to interrupt driven mode
745 * @port: Our sn_cons_port (which contains the uart port)
746 *
747 * In sn_sal_module_init, after we're registered with serial core and
748 * the port is added, this function is called to switch us to interrupt
749 * mode. We were previously in asynch/polling mode (using init_timer).
750 *
751 * We attempt to switch to interrupt mode here by calling
752 * sn_sal_connect_interrupt. If that works out, we enable receive interrupts.
753 */
754 static void __init sn_sal_switch_to_interrupts(struct sn_cons_port *port)
755 {
756 int irq;
757 unsigned long flags;
759 if (!port)
760 return;
762 DPRINTF("sn_console: switching to interrupt driven console\n");
764 spin_lock_irqsave(&port->sc_port.lock, flags);
766 irq = sn_sal_connect_interrupt(port);
768 if (irq) {
769 port->sc_port.irq = irq;
770 port->sc_ops = &intr_ops;
772 /* turn on receive interrupts */
773 ia64_sn_console_intr_enable(SAL_CONSOLE_INTR_RECV);
774 }
775 spin_unlock_irqrestore(&port->sc_port.lock, flags);
776 }
778 /*
779 * Kernel console definitions
780 */
782 static void sn_sal_console_write(struct console *, const char *, unsigned);
783 static int __init sn_sal_console_setup(struct console *, char *);
784 static struct uart_driver sal_console_uart;
785 extern struct tty_driver *uart_console_device(struct console *, int *);
787 static struct console sal_console = {
788 .name = DEVICE_NAME,
789 .write = sn_sal_console_write,
790 .device = uart_console_device,
791 .setup = sn_sal_console_setup,
792 .index = -1, /* unspecified */
793 .data = &sal_console_uart,
794 };
796 #define SAL_CONSOLE &sal_console
798 static struct uart_driver sal_console_uart = {
799 .owner = THIS_MODULE,
800 .driver_name = "sn_console",
801 .dev_name = DEVICE_NAME,
802 .major = 0, /* major/minor set at registration time per USE_DYNAMIC_MINOR */
803 .minor = 0,
804 .nr = 1, /* one port */
805 .cons = SAL_CONSOLE,
806 };
808 /**
809 * sn_sal_module_init - When the kernel loads us, get us rolling w/ serial core
810 *
811 * Before this is called, we've been printing kernel messages in a special
812 * early mode not making use of the serial core infrastructure. When our
813 * driver is loaded for real, we register the driver and port with serial
814 * core and try to enable interrupt driven mode.
815 *
816 */
817 static int __init sn_sal_module_init(void)
818 {
819 int retval;
821 if (!ia64_platform_is("sn2"))
822 return 0;
824 printk(KERN_INFO "sn_console: Console driver init\n");
826 if (USE_DYNAMIC_MINOR == 1) {
827 misc.minor = MISC_DYNAMIC_MINOR;
828 misc.name = DEVICE_NAME_DYNAMIC;
829 retval = misc_register(&misc);
830 if (retval != 0) {
831 printk(KERN_WARNING "Failed to register console "
832 "device using misc_register.\n");
833 return -ENODEV;
834 }
835 sal_console_uart.major = MISC_MAJOR;
836 sal_console_uart.minor = misc.minor;
837 } else {
838 sal_console_uart.major = DEVICE_MAJOR;
839 sal_console_uart.minor = DEVICE_MINOR;
840 }
842 /* We register the driver and the port before switching to interrupts
843 * or async above so the proper uart structures are populated */
845 if (uart_register_driver(&sal_console_uart) < 0) {
846 printk
847 ("ERROR sn_sal_module_init failed uart_register_driver, line %d\n",
848 __LINE__);
849 return -ENODEV;
850 }
852 spin_lock_init(&sal_console_port.sc_port.lock);
854 /* Setup the port struct with the minimum needed */
855 sal_console_port.sc_port.membase = (char *)1; /* just needs to be non-zero */
856 sal_console_port.sc_port.type = PORT_16550A;
857 sal_console_port.sc_port.fifosize = SN_SAL_MAX_CHARS;
858 sal_console_port.sc_port.ops = &sn_console_ops;
859 sal_console_port.sc_port.line = 0;
861 if (uart_add_one_port(&sal_console_uart, &sal_console_port.sc_port) < 0) {
862 /* error - not sure what I'd do - so I'll do nothing */
863 printk(KERN_ERR "%s: unable to add port\n", __FUNCTION__);
864 }
866 /* when this driver is compiled in, the console initialization
867 * will have already switched us into asynchronous operation
868 * before we get here through the module initcalls */
869 if (!sal_console_port.sc_is_asynch) {
870 sn_sal_switch_to_asynch(&sal_console_port);
871 }
873 /* at this point (module_init) we can try to turn on interrupts */
874 if (!IS_RUNNING_ON_SIMULATOR()) {
875 sn_sal_switch_to_interrupts(&sal_console_port);
876 }
877 sn_process_input = 1;
878 return 0;
879 }
881 /**
882 * sn_sal_module_exit - When we're unloaded, remove the driver/port
883 *
884 */
885 static void __exit sn_sal_module_exit(void)
886 {
887 del_timer_sync(&sal_console_port.sc_timer);
888 uart_remove_one_port(&sal_console_uart, &sal_console_port.sc_port);
889 uart_unregister_driver(&sal_console_uart);
890 misc_deregister(&misc);
891 }
893 module_init(sn_sal_module_init);
894 module_exit(sn_sal_module_exit);
896 /**
897 * puts_raw_fixed - sn_sal_console_write helper for adding \r's as required
898 * @puts_raw : puts function to do the writing
899 * @s: input string
900 * @count: length
901 *
902 * We need a \r ahead of every \n for direct writes through
903 * ia64_sn_console_putb (what sal_puts_raw below actually does).
904 *
905 */
907 static void puts_raw_fixed(int (*puts_raw) (const char *s, int len),
908 const char *s, int count)
909 {
910 const char *s1;
912 /* Output '\r' before each '\n' */
913 while ((s1 = memchr(s, '\n', count)) != NULL) {
914 puts_raw(s, s1 - s);
915 puts_raw("\r\n", 2);
916 count -= s1 + 1 - s;
917 s = s1 + 1;
918 }
919 puts_raw(s, count);
920 }
922 /**
923 * sn_sal_console_write - Print statements before serial core available
924 * @console: Console to operate on - we ignore since we have just one
925 * @s: String to send
926 * @count: length
927 *
928 * This is referenced in the console struct. It is used for early
929 * console printing before we register with serial core and for things
930 * such as kdb. The console_lock must be held when we get here.
931 *
932 * This function has some code for trying to print output even if the lock
933 * is held. We try to cover the case where a lock holder could have died.
934 * We don't use this special case code if we're not registered with serial
935 * core yet. After we're registered with serial core, the only time this
936 * function would be used is for high level kernel output like magic sys req,
937 * kdb, and printk's.
938 */
939 static void
940 sn_sal_console_write(struct console *co, const char *s, unsigned count)
941 {
942 unsigned long flags = 0;
943 struct sn_cons_port *port = &sal_console_port;
944 static int stole_lock = 0;
946 BUG_ON(!port->sc_is_asynch);
948 /* We can't look at the xmit buffer if we're not registered with serial core
949 * yet. So only do the fancy recovery after registering
950 */
951 if (!port->sc_port.info) {
952 /* Not yet registered with serial core - simple case */
953 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
954 return;
955 }
957 /* somebody really wants this output, might be an
958 * oops, kdb, panic, etc. make sure they get it. */
959 if (spin_is_locked(&port->sc_port.lock)) {
960 int lhead = port->sc_port.info->xmit.head;
961 int ltail = port->sc_port.info->xmit.tail;
962 int counter, got_lock = 0;
964 /*
965 * We attempt to determine if someone has died with the
966 * lock. We wait ~20 secs after the head and tail ptrs
967 * stop moving and assume the lock holder is not functional
968 * and plow ahead. If the lock is freed within the time out
969 * period we re-get the lock and go ahead normally. We also
970 * remember if we have plowed ahead so that we don't have
971 * to wait out the time out period again - the asumption
972 * is that we will time out again.
973 */
975 for (counter = 0; counter < 150; mdelay(125), counter++) {
976 if (!spin_is_locked(&port->sc_port.lock)
977 || stole_lock) {
978 if (!stole_lock) {
979 spin_lock_irqsave(&port->sc_port.lock,
980 flags);
981 got_lock = 1;
982 }
983 break;
984 } else {
985 /* still locked */
986 if ((lhead != port->sc_port.info->xmit.head)
987 || (ltail !=
988 port->sc_port.info->xmit.tail)) {
989 lhead =
990 port->sc_port.info->xmit.head;
991 ltail =
992 port->sc_port.info->xmit.tail;
993 counter = 0;
994 }
995 }
996 }
997 /* flush anything in the serial core xmit buffer, raw */
998 sn_transmit_chars(port, 1);
999 if (got_lock) {
1000 spin_unlock_irqrestore(&port->sc_port.lock, flags);
1001 stole_lock = 0;
1002 } else {
1003 /* fell thru */
1004 stole_lock = 1;
1006 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
1007 } else {
1008 stole_lock = 0;
1009 spin_lock_irqsave(&port->sc_port.lock, flags);
1010 sn_transmit_chars(port, 1);
1011 spin_unlock_irqrestore(&port->sc_port.lock, flags);
1013 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
1018 /**
1019 * sn_sal_console_setup - Set up console for early printing
1020 * @co: Console to work with
1021 * @options: Options to set
1023 * Altix console doesn't do anything with baud rates, etc, anyway.
1025 * This isn't required since not providing the setup function in the
1026 * console struct is ok. However, other patches like KDB plop something
1027 * here so providing it is easier.
1029 */
1030 static int __init sn_sal_console_setup(struct console *co, char *options)
1032 return 0;
1035 /**
1036 * sn_sal_console_write_early - simple early output routine
1037 * @co - console struct
1038 * @s - string to print
1039 * @count - count
1041 * Simple function to provide early output, before even
1042 * sn_sal_serial_console_init is called. Referenced in the
1043 * console struct registerd in sn_serial_console_early_setup.
1045 */
1046 static void __init
1047 sn_sal_console_write_early(struct console *co, const char *s, unsigned count)
1049 puts_raw_fixed(sal_console_port.sc_ops->sal_puts_raw, s, count);
1052 /* Used for very early console printing - again, before
1053 * sn_sal_serial_console_init is run */
1054 static struct console sal_console_early __initdata = {
1055 .name = "sn_sal",
1056 .write = sn_sal_console_write_early,
1057 .flags = CON_PRINTBUFFER,
1058 .index = -1,
1059 };
1061 /**
1062 * sn_serial_console_early_setup - Sets up early console output support
1064 * Register a console early on... This is for output before even
1065 * sn_sal_serial_cosnole_init is called. This function is called from
1066 * setup.c. This allows us to do really early polled writes. When
1067 * sn_sal_serial_console_init is called, this console is unregistered
1068 * and a new one registered.
1069 */
1070 int __init sn_serial_console_early_setup(void)
1072 if (!ia64_platform_is("sn2"))
1073 return -1;
1075 sal_console_port.sc_ops = &poll_ops;
1076 spin_lock_init(&sal_console_port.sc_port.lock);
1077 early_sn_setup(); /* Find SAL entry points */
1078 register_console(&sal_console_early);
1080 return 0;
1083 /**
1084 * sn_sal_serial_console_init - Early console output - set up for register
1086 * This function is called when regular console init happens. Because we
1087 * support even earlier console output with sn_serial_console_early_setup
1088 * (called from setup.c directly), this function unregisters the really
1089 * early console.
1091 * Note: Even if setup.c doesn't register sal_console_early, unregistering
1092 * it here doesn't hurt anything.
1094 */
1095 static int __init sn_sal_serial_console_init(void)
1097 if (ia64_platform_is("sn2")) {
1098 sn_sal_switch_to_asynch(&sal_console_port);
1099 DPRINTF("sn_sal_serial_console_init : register console\n");
1100 register_console(&sal_console);
1101 unregister_console(&sal_console_early);
1103 return 0;
1106 console_initcall(sn_sal_serial_console_init);