URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [sn_serial.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

/*
 * 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 <linux/config.h>
#include <linux/interrupt.h>
#include <linux/tty.h>
#include <linux/serial.h>
#include <linux/console.h>
#include <linux/module.h>
#include <linux/sysrq.h>
#include <linux/circ_buf.h>
#include <linux/serial_reg.h>
#include <asm/uaccess.h>
#include <asm/sn/sn_sal.h>
#include <asm/sn/pci/pciio.h>           /* this is needed for get_console_nasid */
#include <asm/sn/simulator.h>
#include <asm/sn/sn2/sn_private.h>
 
#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_serial: should wait until sent>");
}
 
 
/*
 * 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 */
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [sn_serial.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
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) 2003 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., 1600 Amphitheatre Pkwy,`
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>`