/* * C-Brick Serial Port (and console) driver for SGI Altix machines. * * This driver is NOT suitable for talking to the l1-controller for * anything other than 'console activities' --- please use the l1 * driver for that. * * * Copyright (c) 2003 Silicon Graphics, Inc. All Rights Reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License * as published by the Free Software Foundation. * * This program is distributed in the hope that it would be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * * Further, this software is distributed without any warranty that it is * free of the rightful claim of any third person regarding infringement * or the like. Any license provided herein, whether implied or * otherwise, applies only to this software file. Patent licenses, if * any, provided herein do not apply to combinations of this program with * other software, or any other product whatsoever. * * You should have received a copy of the GNU General Public * License along with this program; if not, write the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA. * * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy, * Mountain View, CA 94043, or: * * http://www.sgi.com * * For further information regarding this notice, see: * * http://oss.sgi.com/projects/GenInfo/NoticeExplan */ #include #include #include #include #include #include #include #include #include #include #include #include /* this is needed for get_console_nasid */ #include #include #if defined(CONFIG_SGI_L1_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) static char sysrq_serial_str[] = "\eSYS"; static char *sysrq_serial_ptr = sysrq_serial_str; static unsigned long sysrq_requested; #endif /* CONFIG_SGI_L1_SERIAL_CONSOLE && CONFIG_MAGIC_SYSRQ */ /* minor device number */ #define SN_SAL_MINOR 64 #define SN_SAL_SUBTYPE 1 /* number of characters left in xmit buffer before we ask for more */ #define WAKEUP_CHARS 128 /* number of characters we can transmit to the SAL console at a time */ #define SN_SAL_MAX_CHARS 120 #define SN_SAL_EVENT_WRITE_WAKEUP 0 #define CONSOLE_RESTART 1 /* 64K, when we're asynch, it must be at least printk's LOG_BUF_LEN to * avoid losing chars, (always has to be a power of 2) */ #define SN_SAL_BUFFER_SIZE (64 * (1 << 10)) #define SN_SAL_UART_FIFO_DEPTH 16 #define SN_SAL_UART_FIFO_SPEED_CPS 9600/10 /* we don't kmalloc/get_free_page these as we want them available * before either of those are initialized */ static char sn_xmit_buff_mem[SN_SAL_BUFFER_SIZE]; struct volatile_circ_buf { char *cb_buf; int cb_head; int cb_tail; }; static struct volatile_circ_buf xmit = { .cb_buf = sn_xmit_buff_mem }; static char sn_tmp_buffer[SN_SAL_BUFFER_SIZE]; static struct tty_struct *sn_sal_tty; static struct timer_list sn_sal_timer; static int sn_sal_event; /* event type for task queue */ static int sn_sal_refcount; static int sn_sal_is_asynch; static int sn_sal_irq; static spinlock_t sn_sal_lock = SPIN_LOCK_UNLOCKED; static int sn_total_tx_count; static int sn_total_rx_count; static struct tty_struct *sn_sal_table; static struct termios *sn_sal_termios; static struct termios *sn_sal_termios_locked; static void sn_sal_tasklet_action(unsigned long data); static DECLARE_TASKLET(sn_sal_tasklet, sn_sal_tasklet_action, 0); static unsigned long sn_interrupt_timeout; extern u64 master_node_bedrock_address; static int sn_debug_printf(const char *fmt, ...); #undef DEBUG #ifdef DEBUG #define DPRINTF(x...) sn_debug_printf(x) #else #define DPRINTF(x...) do { } while (0) #endif struct sn_sal_ops { int (*sal_puts)(const char *s, int len); int (*sal_getc)(void); int (*sal_input_pending)(void); void (*sal_wakeup_transmit)(void); }; /* This is the pointer used. It is assigned to point to one of * the tables below. */ static struct sn_sal_ops *sn_func; /* Prototypes */ static int snt_hw_puts(const char *, int); static int snt_poll_getc(void); static int snt_poll_input_pending(void); static int snt_sim_puts(const char *, int); static int snt_sim_getc(void); static int snt_sim_input_pending(void); static int snt_intr_getc(void); static int snt_intr_input_pending(void); static void sn_intr_transmit_chars(void); /* A table for polling */ static struct sn_sal_ops poll_ops = { .sal_puts = snt_hw_puts, .sal_getc = snt_poll_getc, .sal_input_pending = snt_poll_input_pending }; /* A table for the simulator */ static struct sn_sal_ops sim_ops = { .sal_puts = snt_sim_puts, .sal_getc = snt_sim_getc, .sal_input_pending = snt_sim_input_pending }; /* A table for interrupts enabled */ static struct sn_sal_ops intr_ops = { .sal_puts = snt_hw_puts, .sal_getc = snt_intr_getc, .sal_input_pending = snt_intr_input_pending, .sal_wakeup_transmit = sn_intr_transmit_chars }; /* the console does output in two distinctly different ways: * synchronous and asynchronous (buffered). initally, early_printk * does synchronous output. any data written goes directly to the SAL * to be output (incidentally, it is internally buffered by the SAL) * after interrupts and timers are initialized and available for use, * the console init code switches to asynchronous output. this is * also the earliest opportunity to begin polling for console input. * after console initialization, console output and tty (serial port) * output is buffered and sent to the SAL asynchronously (either by * timer callback or by UART interrupt) */ /* routines for running the console in polling mode */ static int snt_hw_puts(const char *s, int len) { /* looking at the PROM source code, putb calls the flush * routine, so if we send characters in FIFO sized chunks, it * should go out by the next time the timer gets called */ return ia64_sn_console_putb(s, len); } static int snt_poll_getc(void) { int ch; ia64_sn_console_getc(&ch); return ch; } static int snt_poll_input_pending(void) { int status, input; status = ia64_sn_console_check(&input); return !status && input; } /* routines for running the console on the simulator */ static int snt_sim_puts(const char *str, int count) { int counter = count; #ifdef FLAG_DIRECT_CONSOLE_WRITES /* This is an easy way to pre-pend the output to know whether the output * was done via sal or directly */ writeb('[', master_node_bedrock_address + (UART_TX << 3)); writeb('+', master_node_bedrock_address + (UART_TX << 3)); writeb(']', master_node_bedrock_address + (UART_TX << 3)); writeb(' ', master_node_bedrock_address + (UART_TX << 3)); #endif /* FLAG_DIRECT_CONSOLE_WRITES */ while (counter > 0) { writeb(*str, master_node_bedrock_address + (UART_TX << 3)); counter--; str++; } return count; } static int snt_sim_getc(void) { return readb(master_node_bedrock_address + (UART_RX << 3)); } static int snt_sim_input_pending(void) { return readb(master_node_bedrock_address + (UART_LSR << 3)) & UART_LSR_DR; } /* routines for an interrupt driven console (normal) */ static int snt_intr_getc(void) { return ia64_sn_console_readc(); } static int snt_intr_input_pending(void) { return ia64_sn_console_intr_status() & SAL_CONSOLE_INTR_RECV; } /* The early printk (possible setup) and function call */ void early_printk_sn_sal(const char *s, unsigned count) { #if defined(CONFIG_IA64_EARLY_PRINTK_SGI_SN) || defined(CONFIG_IA64_SGI_SN_SIM) extern void early_sn_setup(void); #endif if (!sn_func) { if (IS_RUNNING_ON_SIMULATOR()) sn_func = &sim_ops; else sn_func = &poll_ops; #if defined(CONFIG_IA64_EARLY_PRINTK_SGI_SN) || defined(CONFIG_IA64_SGI_SN_SIM) early_sn_setup(); #endif } sn_func->sal_puts(s, count); } /* this is as "close to the metal" as we can get, used when the driver * itself may be broken */ static int sn_debug_printf(const char *fmt, ...) { static char printk_buf[1024]; int printed_len; va_list args; va_start(args, fmt); printed_len = vsnprintf(printk_buf, sizeof(printk_buf), fmt, args); early_printk_sn_sal(printk_buf, printed_len); va_end(args); return printed_len; } /* * Interrupt handling routines. */ static void sn_sal_sched_event(int event) { sn_sal_event |= (1 << event); tasklet_schedule(&sn_sal_tasklet); } /* sn_receive_chars can be called before sn_sal_tty is initialized. in * that case, its only use is to trigger sysrq and kdb */ static void sn_receive_chars(struct pt_regs *regs, unsigned long *flags) { int ch; while (sn_func->sal_input_pending()) { ch = sn_func->sal_getc(); if (ch < 0) { printk(KERN_ERR "sn_serial: An error occured while " "obtaining data from the console (0x%0x)\n", ch); break; } #if defined(CONFIG_SGI_L1_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) if (sysrq_requested) { unsigned long sysrq_timeout = sysrq_requested + HZ*5; sysrq_requested = 0; if (ch && time_before(jiffies, sysrq_timeout)) { spin_unlock_irqrestore(&sn_sal_lock, *flags); handle_sysrq(ch, regs, NULL, NULL); spin_lock_irqsave(&sn_sal_lock, *flags); /* don't record this char */ continue; } } if (ch == *sysrq_serial_ptr) { if (!(*++sysrq_serial_ptr)) { sysrq_requested = jiffies; sysrq_serial_ptr = sysrq_serial_str; } } else sysrq_serial_ptr = sysrq_serial_str; #endif /* CONFIG_SGI_L1_SERIAL_CONSOLE && CONFIG_MAGIC_SYSRQ */ /* record the character to pass up to the tty layer */ if (sn_sal_tty) { *sn_sal_tty->flip.char_buf_ptr = ch; sn_sal_tty->flip.char_buf_ptr++; sn_sal_tty->flip.count++; if (sn_sal_tty->flip.count == TTY_FLIPBUF_SIZE) break; } sn_total_rx_count++; } if (sn_sal_tty) tty_flip_buffer_push((struct tty_struct *)sn_sal_tty); } /* synch_flush_xmit must be called with sn_sal_lock */ static void synch_flush_xmit(void) { int xmit_count, tail, head, loops, ii; int result; char *start; if (xmit.cb_head == xmit.cb_tail) return; /* Nothing to do. */ head = xmit.cb_head; tail = xmit.cb_tail; start = &xmit.cb_buf[tail]; /* twice around gets the tail to the end of the buffer and * then to the head, if needed */ loops = (head < tail) ? 2 : 1; for (ii = 0; ii < loops; ii++) { xmit_count = (head < tail) ? (SN_SAL_BUFFER_SIZE - tail) : (head - tail); if (xmit_count > 0) { result = sn_func->sal_puts((char *)start, xmit_count); if (!result) sn_debug_printf("\n*** synch_flush_xmit failed to flush\n"); if (result > 0) { xmit_count -= result; sn_total_tx_count += result; tail += result; tail &= SN_SAL_BUFFER_SIZE - 1; xmit.cb_tail = tail; start = (char *)&xmit.cb_buf[tail]; } } } } /* must be called with a lock protecting the circular buffer and * sn_sal_tty */ static void sn_poll_transmit_chars(void) { int xmit_count, tail, head; int result; char *start; BUG_ON(!sn_sal_is_asynch); if (xmit.cb_head == xmit.cb_tail || (sn_sal_tty && (sn_sal_tty->stopped || sn_sal_tty->hw_stopped))) { /* Nothing to do. */ return; } head = xmit.cb_head; tail = xmit.cb_tail; start = &xmit.cb_buf[tail]; xmit_count = (head < tail) ? (SN_SAL_BUFFER_SIZE - tail) : (head - tail); if (xmit_count == 0) sn_debug_printf("\n*** empty xmit_count\n"); /* use the ops, as we could be on the simulator */ result = sn_func->sal_puts((char *)start, xmit_count); if (!result) sn_debug_printf("\n*** error in synchronous sal_puts\n"); /* XXX chadt clean this up */ if (result > 0) { xmit_count -= result; sn_total_tx_count += result; tail += result; tail &= SN_SAL_BUFFER_SIZE - 1; xmit.cb_tail = tail; start = &xmit.cb_buf[tail]; } /* if there's few enough characters left in the xmit buffer * that we could stand for the upper layer to send us some * more, ask for it. */ if (sn_sal_tty) if (CIRC_CNT(xmit.cb_head, xmit.cb_tail, SN_SAL_BUFFER_SIZE) < WAKEUP_CHARS) sn_sal_sched_event(SN_SAL_EVENT_WRITE_WAKEUP); } /* must be called with a lock protecting the circular buffer and * sn_sal_tty */ static void sn_intr_transmit_chars(void) { int xmit_count, tail, head, loops, ii; int result; char *start; BUG_ON(!sn_sal_is_asynch); if (xmit.cb_head == xmit.cb_tail || (sn_sal_tty && (sn_sal_tty->stopped || sn_sal_tty->hw_stopped))) { /* Nothing to do. */ return; } head = xmit.cb_head; tail = xmit.cb_tail; start = &xmit.cb_buf[tail]; /* twice around gets the tail to the end of the buffer and * then to the head, if needed */ loops = (head < tail) ? 2 : 1; for (ii = 0; ii < loops; ii++) { xmit_count = (head < tail) ? (SN_SAL_BUFFER_SIZE - tail) : (head - tail); if (xmit_count > 0) { result = ia64_sn_console_xmit_chars((char *)start, xmit_count); #ifdef DEBUG if (!result) sn_debug_printf("`"); #endif if (result > 0) { xmit_count -= result; sn_total_tx_count += result; tail += result; tail &= SN_SAL_BUFFER_SIZE - 1; xmit.cb_tail = tail; start = &xmit.cb_buf[tail]; } } } /* if there's few enough characters left in the xmit buffer * that we could stand for the upper layer to send us some * more, ask for it. */ if (sn_sal_tty) if (CIRC_CNT(xmit.cb_head, xmit.cb_tail, SN_SAL_BUFFER_SIZE) < WAKEUP_CHARS) sn_sal_sched_event(SN_SAL_EVENT_WRITE_WAKEUP); } static void sn_sal_interrupt(int irq, void *dev_id, struct pt_regs *regs) { /* this call is necessary to pass the interrupt back to the * SAL, since it doesn't intercept the UART interrupts * itself */ int status = ia64_sn_console_intr_status(); unsigned long flags; spin_lock_irqsave(&sn_sal_lock, flags); if (status & SAL_CONSOLE_INTR_RECV) sn_receive_chars(regs, &flags); if (status & SAL_CONSOLE_INTR_XMIT) sn_intr_transmit_chars(); spin_unlock_irqrestore(&sn_sal_lock, flags); } /* returns the console irq if interrupt is successfully registered, * else 0 */ static int sn_sal_connect_interrupt(void) { cpuid_t intr_cpuid; unsigned int intr_cpuloc; nasid_t console_nasid; unsigned int console_irq; int result; /* if it is an old prom, run in poll mode */ if ((sn_sal_rev_major() <= 1) && (sn_sal_rev_minor() <= 3)) { /* before version 1.06 doesn't work */ printk(KERN_INFO "sn_serial: old prom version %x.%02x" " - running in polled mode\n", sn_sal_rev_major(), sn_sal_rev_minor()); return 0; } console_nasid = ia64_sn_get_console_nasid(); intr_cpuid = NODEPDA(NASID_TO_COMPACT_NODEID(console_nasid))->node_first_cpu; intr_cpuloc = cpu_physical_id(intr_cpuid); console_irq = CPU_VECTOR_TO_IRQ(intr_cpuloc, SGI_UART_VECTOR); result = intr_connect_level(intr_cpuid, SGI_UART_VECTOR, 0 /*not used*/, 0 /*not used*/); BUG_ON(result != SGI_UART_VECTOR); result = request_irq(console_irq, sn_sal_interrupt, SA_INTERRUPT, "SAL console driver", &sn_sal_tty); if (result >= 0) return console_irq; printk(KERN_INFO "sn_serial: console proceeding in polled mode\n"); return 0; } static void sn_sal_tasklet_action(unsigned long data) { unsigned long flags; if (sn_sal_tty) { spin_lock_irqsave(&sn_sal_lock, flags); if (sn_sal_tty) { if (test_and_clear_bit(SN_SAL_EVENT_WRITE_WAKEUP, &sn_sal_event)) { if ((sn_sal_tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && sn_sal_tty->ldisc.write_wakeup) (sn_sal_tty->ldisc.write_wakeup)((struct tty_struct *)sn_sal_tty); wake_up_interruptible((wait_queue_head_t *)&sn_sal_tty->write_wait); } } spin_unlock_irqrestore(&sn_sal_lock, flags); } } /* * This function handles polled mode. */ static void sn_sal_timer_poll(unsigned long dummy) { unsigned long flags; if (!sn_sal_irq) { spin_lock_irqsave(&sn_sal_lock, flags); sn_receive_chars(NULL, &flags); sn_poll_transmit_chars(); spin_unlock_irqrestore(&sn_sal_lock, flags); mod_timer(&sn_sal_timer, jiffies + sn_interrupt_timeout); } } static void sn_sal_timer_restart(unsigned long dummy) { unsigned long flags; local_irq_save(flags); sn_sal_interrupt(0, NULL, NULL); local_irq_restore(flags); mod_timer(&sn_sal_timer, jiffies + sn_interrupt_timeout); } /* * User-level console routines */ static int sn_sal_open(struct tty_struct *tty, struct file *filp) { unsigned long flags; DPRINTF("sn_sal_open: sn_sal_tty = %p, tty = %p, filp = %p\n", sn_sal_tty, tty, filp); spin_lock_irqsave(&sn_sal_lock, flags); if (!sn_sal_tty) sn_sal_tty = tty; spin_unlock_irqrestore(&sn_sal_lock, flags); return 0; } /* We're keeping all our resources. We're keeping interrupts turned * on. Maybe just let the tty layer finish its stuff...? GMSH */ static void sn_sal_close(struct tty_struct *tty, struct file * filp) { if (tty->count == 1) { unsigned long flags; tty->closing = 1; if (tty->driver.flush_buffer) tty->driver.flush_buffer(tty); if (tty->ldisc.flush_buffer) tty->ldisc.flush_buffer(tty); tty->closing = 0; spin_lock_irqsave(&sn_sal_lock, flags); sn_sal_tty = NULL; spin_unlock_irqrestore(&sn_sal_lock, flags); } } static int sn_sal_write(struct tty_struct *tty, int from_user, const unsigned char *buf, int count) { int c, ret = 0; unsigned long flags; if (from_user) { while (1) { int c1; c = CIRC_SPACE_TO_END(xmit.cb_head, xmit.cb_tail, SN_SAL_BUFFER_SIZE); if (count < c) c = count; if (c <= 0) break; c -= copy_from_user(sn_tmp_buffer, buf, c); if (!c) { if (!ret) ret = -EFAULT; break; } /* Turn off interrupts and see if the xmit buffer has * moved since the last time we looked. */ spin_lock_irqsave(&sn_sal_lock, flags); c1 = CIRC_SPACE_TO_END(xmit.cb_head, xmit.cb_tail, SN_SAL_BUFFER_SIZE); if (c1 < c) c = c1; memcpy(xmit.cb_buf + xmit.cb_head, sn_tmp_buffer, c); xmit.cb_head = ((xmit.cb_head + c) & (SN_SAL_BUFFER_SIZE - 1)); spin_unlock_irqrestore(&sn_sal_lock, flags); buf += c; count -= c; ret += c; } } else { /* The buffer passed in isn't coming from userland, * so cut out the middleman (sn_tmp_buffer). */ spin_lock_irqsave(&sn_sal_lock, flags); while (1) { c = CIRC_SPACE_TO_END(xmit.cb_head, xmit.cb_tail, SN_SAL_BUFFER_SIZE); if (count < c) c = count; if (c <= 0) { break; } memcpy(xmit.cb_buf + xmit.cb_head, buf, c); xmit.cb_head = ((xmit.cb_head + c) & (SN_SAL_BUFFER_SIZE - 1)); buf += c; count -= c; ret += c; } spin_unlock_irqrestore(&sn_sal_lock, flags); } spin_lock_irqsave(&sn_sal_lock, flags); if (xmit.cb_head != xmit.cb_tail && !(tty && (tty->stopped || tty->hw_stopped))) if (sn_func->sal_wakeup_transmit) sn_func->sal_wakeup_transmit(); spin_unlock_irqrestore(&sn_sal_lock, flags); return ret; } static void sn_sal_put_char(struct tty_struct *tty, unsigned char ch) { unsigned long flags; spin_lock_irqsave(&sn_sal_lock, flags); if (CIRC_SPACE(xmit.cb_head, xmit.cb_tail, SN_SAL_BUFFER_SIZE) != 0) { xmit.cb_buf[xmit.cb_head] = ch; xmit.cb_head = (xmit.cb_head + 1) & (SN_SAL_BUFFER_SIZE-1); if ( sn_func->sal_wakeup_transmit ) sn_func->sal_wakeup_transmit(); } spin_unlock_irqrestore(&sn_sal_lock, flags); } static void sn_sal_flush_chars(struct tty_struct *tty) { unsigned long flags; spin_lock_irqsave(&sn_sal_lock, flags); if (CIRC_CNT(xmit.cb_head, xmit.cb_tail, SN_SAL_BUFFER_SIZE)) if (sn_func->sal_wakeup_transmit) sn_func->sal_wakeup_transmit(); spin_unlock_irqrestore(&sn_sal_lock, flags); } static int sn_sal_write_room(struct tty_struct *tty) { unsigned long flags; int space; spin_lock_irqsave(&sn_sal_lock, flags); space = CIRC_SPACE(xmit.cb_head, xmit.cb_tail, SN_SAL_BUFFER_SIZE); spin_unlock_irqrestore(&sn_sal_lock, flags); return space; } static int sn_sal_chars_in_buffer(struct tty_struct *tty) { unsigned long flags; int space; spin_lock_irqsave(&sn_sal_lock, flags); space = CIRC_CNT(xmit.cb_head, xmit.cb_tail, SN_SAL_BUFFER_SIZE); DPRINTF("<%d>", space); spin_unlock_irqrestore(&sn_sal_lock, flags); return space; } static void sn_sal_flush_buffer(struct tty_struct *tty) { unsigned long flags; /* drop everything */ spin_lock_irqsave(&sn_sal_lock, flags); xmit.cb_head = xmit.cb_tail = 0; spin_unlock_irqrestore(&sn_sal_lock, flags); /* wake up tty level */ wake_up_interruptible(&tty->write_wait); if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup) (tty->ldisc.write_wakeup)(tty); } static void sn_sal_hangup(struct tty_struct *tty) { sn_sal_flush_buffer(tty); } static void sn_sal_wait_until_sent(struct tty_struct *tty, int timeout) { /* this is SAL's problem */ DPRINTF(""); } /* * sn_sal_read_proc * * Console /proc interface */ static int sn_sal_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data) { int len = 0; off_t begin = 0; len += sprintf(page, "sn_serial: nasid:%d irq:%d tx:%d rx:%d\n", snia_get_console_nasid(), sn_sal_irq, sn_total_tx_count, sn_total_rx_count); *eof = 1; if (off >= len+begin) return 0; *start = page + (off-begin); return count < begin+len-off ? count : begin+len-off; } static struct tty_driver sn_sal_driver = { .magic = TTY_DRIVER_MAGIC, .driver_name = "sn_serial", #if defined(CONFIG_DEVFS_FS) .name = "tts/%d", #else .name = "ttyS", #endif .major = TTY_MAJOR, .minor_start = SN_SAL_MINOR, .num = 1, .type = TTY_DRIVER_TYPE_SERIAL, .subtype = SN_SAL_SUBTYPE, .flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS, .refcount = &sn_sal_refcount, .table = &sn_sal_table, .termios = &sn_sal_termios, .termios_locked = &sn_sal_termios_locked, .open = sn_sal_open, .close = sn_sal_close, .write = sn_sal_write, .put_char = sn_sal_put_char, .flush_chars = sn_sal_flush_chars, .write_room = sn_sal_write_room, .chars_in_buffer = sn_sal_chars_in_buffer, .hangup = sn_sal_hangup, .wait_until_sent = sn_sal_wait_until_sent, .read_proc = sn_sal_read_proc, }; /* sn_sal_init wishlist: * - allocate sn_tmp_buffer * - fix up the tty_driver struct * - turn on receive interrupts * - do any termios twiddling once and for all */ /* * Boot-time initialization code */ static void __init sn_sal_switch_to_asynch(void) { unsigned long flags; sn_debug_printf("sn_serial: about to switch to asynchronous console\n"); /* without early_printk, we may be invoked late enough to race * with other cpus doing console IO at this point, however * console interrupts will never be enabled */ spin_lock_irqsave(&sn_sal_lock, flags); /* early_printk invocation may have done this for us */ if (!sn_func) { if (IS_RUNNING_ON_SIMULATOR()) sn_func = &sim_ops; else sn_func = &poll_ops; } /* we can't turn on the console interrupt (as request_irq * calls kmalloc, which isn't set up yet), so we rely on a * timer to poll for input and push data from the console * buffer. */ init_timer(&sn_sal_timer); sn_sal_timer.function = sn_sal_timer_poll; if (IS_RUNNING_ON_SIMULATOR()) sn_interrupt_timeout = 6; else { /* 960cps / 16 char FIFO = 60HZ * HZ / (SN_SAL_FIFO_SPEED_CPS / SN_SAL_FIFO_DEPTH) */ sn_interrupt_timeout = HZ * SN_SAL_UART_FIFO_DEPTH / SN_SAL_UART_FIFO_SPEED_CPS; } mod_timer(&sn_sal_timer, jiffies + sn_interrupt_timeout); sn_sal_is_asynch = 1; spin_unlock_irqrestore(&sn_sal_lock, flags); } static void __init sn_sal_switch_to_interrupts(void) { int irq; sn_debug_printf("sn_serial: switching to interrupt driven console\n"); irq = sn_sal_connect_interrupt(); if (irq) { unsigned long flags; spin_lock_irqsave(&sn_sal_lock, flags); /* sn_sal_irq is a global variable. When it's set to * a non-zero value, we stop polling for input (since * interrupts should now be enabled). */ sn_sal_irq = irq; sn_func = &intr_ops; /* turn on receive interrupts */ ia64_sn_console_intr_enable(SAL_CONSOLE_INTR_RECV); /* the polling timer is already set up, we just change the * frequency. if we've successfully enabled interrupts (and * CONSOLE_RESTART isn't defined) the next timer expiration * will be the last, otherwise we continue polling */ if (CONSOLE_RESTART) { /* kick the console every once in a while in * case we miss an interrupt */ sn_interrupt_timeout = 20*HZ; sn_sal_timer.function = sn_sal_timer_restart; mod_timer(&sn_sal_timer, jiffies + sn_interrupt_timeout); } spin_unlock_irqrestore(&sn_sal_lock, flags); } } static int __init sn_sal_module_init(void) { int retval; printk("sn_serial: sn_sal_module_init\n"); if (!ia64_platform_is("sn2")) return -ENODEV; /* when this driver is compiled in, the console initialization * will have already switched us into asynchronous operation * before we get here through the module initcalls */ if (!sn_sal_is_asynch) sn_sal_switch_to_asynch(); /* at this point (module_init) we can try to turn on interrupts */ if (!IS_RUNNING_ON_SIMULATOR()) sn_sal_switch_to_interrupts(); sn_sal_driver.init_termios = tty_std_termios; sn_sal_driver.init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; if ((retval = tty_register_driver(&sn_sal_driver))) { printk(KERN_ERR "sn_serial: Unable to register tty driver\n"); return retval; } tty_register_devfs(&sn_sal_driver, 0, sn_sal_driver.minor_start); return 0; } static void __exit sn_sal_module_exit(void) { del_timer_sync(&sn_sal_timer); tty_unregister_driver(&sn_sal_driver); } module_init(sn_sal_module_init); module_exit(sn_sal_module_exit); /* * Kernel console definitions */ #ifdef CONFIG_SGI_L1_SERIAL_CONSOLE /* * Print a string to the SAL console. The console_lock must be held * when we get here. */ static void sn_sal_console_write(struct console *co, const char *s, unsigned count) { unsigned long flags; if (count > CIRC_SPACE_TO_END(xmit.cb_head, xmit.cb_tail, SN_SAL_BUFFER_SIZE)) sn_debug_printf("\n*** SN_SAL_BUFFER_SIZE too small, lost chars\n"); /* somebody really wants this output, might be an * oops, kdb, panic, etc. make sure they get it. */ #if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT) if (spin_is_locked(&sn_sal_lock)) { synch_flush_xmit(); sn_func->sal_puts(s, count); } else #endif if (in_interrupt()) { spin_lock_irqsave(&sn_sal_lock, flags); synch_flush_xmit(); spin_unlock_irqrestore(&sn_sal_lock, flags); sn_func->sal_puts(s, count); } else { #if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT) sn_sal_write(NULL, 0, s, count); #else synch_flush_xmit(); sn_func->sal_puts(s, count); #endif } } static kdev_t sn_sal_console_device(struct console *c) { return MKDEV(TTY_MAJOR, 64 + c->index); } static int __init sn_sal_console_setup(struct console *co, char *options) { return 0; } static struct console sal_console = { .name = "ttyS", .write = sn_sal_console_write, .device = sn_sal_console_device, .setup = sn_sal_console_setup, .index = -1 }; void __init sn_sal_serial_console_init(void) { if (ia64_platform_is("sn2")) { sn_sal_switch_to_asynch(); register_console(&sal_console); } } #endif /* CONFIG_SGI_L1_SERIAL_CONSOLE */