path: root/drivers/sbus/char/sab82532.c

/* $Id: sab82532.c,v 1.4 1997/09/03 17:04:21 ecd Exp $
 * sab82532.c: ASYNC Driver for the SIEMENS SAB82532 DUSCC.
 *
 * Copyright (C) 1997  Eddie C. Dost  (ecd@skynet.be)
 *
 */

#include <linux/config.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/interrupt.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/serial.h>
#include <linux/serial_reg.h>
#include <linux/major.h>
#include <linux/string.h>
#include <linux/fcntl.h>
#include <linux/ptrace.h>
#include <linux/ioport.h>
#include <linux/mm.h>
#include <linux/malloc.h>
#include <linux/init.h>
#include <linux/delay.h>

#include <asm/sab82532.h>
#include <asm/uaccess.h>
#include <asm/ebus.h>

#include "sunserial.h"

static DECLARE_TASK_QUEUE(tq_serial);

static struct tty_driver serial_driver, callout_driver;
static int sab82532_refcount;

/* number of characters left in xmit buffer before we ask for more */
#define WAKEUP_CHARS 256

/* Set of debugging defines */
#undef SERIAL_DEBUG_OPEN
#undef SERIAL_DEBUG_INTR
#undef SERIAL_DEBUG_FLOW
#undef SERIAL_DEBUG_WAIT_UNTIL_SENT

static void change_speed(struct sab82532 *info);
static void sab82532_wait_until_sent(struct tty_struct *tty, int timeout);

/*
 * This assumes you have a 29.4912 MHz clock for your UART.
 */
#define BASE_BAUD ( 29491200 / 16 )

static struct sab82532 *sab82532_chain = 0;
static struct tty_struct *sab82532_table[NR_PORTS];
static struct termios *sab82532_termios[NR_PORTS];
static struct termios *sab82532_termios_locked[NR_PORTS];

#ifndef MIN
#define MIN(a,b)	((a) < (b) ? (a) : (b))
#endif

/*
 * tmp_buf is used as a temporary buffer by sab82532_write.  We need to
 * lock it in case the copy_from_user blocks while swapping in a page,
 * and some other program tries to do a serial write at the same time.
 * Since the lock will only come under contention when the system is
 * swapping and available memory is low, it makes sense to share one
 * buffer across all the serial ports, since it significantly saves
 * memory if large numbers of serial ports are open.
 */
static unsigned char *tmp_buf = 0;
static struct semaphore tmp_buf_sem = MUTEX;

static inline int serial_paranoia_check(struct sab82532 *info,
					kdev_t device, const char *routine)
{
#ifdef SERIAL_PARANOIA_CHECK
	static const char *badmagic =
		"Warning: bad magic number for serial struct (%s) in %s\n";
	static const char *badinfo =
		"Warning: null sab82532 for (%s) in %s\n";

	if (!info) {
		printk(badinfo, kdevname(device), routine);
		return 1;
	}
	if (info->magic != SERIAL_MAGIC) {
		printk(badmagic, kdevname(device), routine);
		return 1;
	}
#endif
	return 0;
}

/*
 * This is used to figure out the divisor speeds.
 *
 * The formula is:    Baud = BASE_BAUD / ((N + 1) * (1 << M)),
 *
 * with               0 <= N < 64 and 0 <= M < 16
 *
 * XXX:	Speeds with M = 0 might not work properly for XTAL frequencies
 *      above 10 MHz.
 */
struct ebrg_struct {
	int	baud;
	int	n;
	int	m;
};

static struct ebrg_struct ebrg_table[] = {
	{       0,	0,	 0 },
	{      50,	35,	10 },
	{      75,	47,	 9 },
	{     110,	32,	 9 },
	{     134,	53,	 8 },
	{     150,	47,	 8 },
	{     200,	35,	 8 },
	{     300,	47,	 7 },
	{     600,	47,	 6 },
	{    1200,	47,	 5 },
	{    1800,	31,	 5 },
	{    2400,	47,	 4 },
	{    4800,	47,	 3 },
	{    9600,	47,	 2 },
	{   19200,	47,	 1 },
	{   38400,	23,	 1 },
	{   57600,	15,	 1 },
	{  115200,	 7,	 1 },
	{  230400,	 3,	 1 },
	{  460800,	 1,	 1 },
	{   76800,	11,	 1 },
	{  153600,	 5,	 1 },
	{  307200,	 3,	 1 },
	{  614400,	 3,	 0 },
	{  921600,	 0,	 1 },
};

#define NR_EBRG_VALUES	(sizeof(ebrg_table)/sizeof(struct ebrg_struct))

/*
 * ------------------------------------------------------------
 * sab82532_stop() and sab82532_start()
 *
 * This routines are called before setting or resetting tty->stopped.
 * They enable or disable transmitter interrupts, as necessary.
 * ------------------------------------------------------------
 */
static void sab82532_stop(struct tty_struct *tty)
{
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;
	unsigned long flags;

	if (serial_paranoia_check(info, tty->device, "sab82532_stop"))
		return;

	save_flags(flags); cli();
	info->interrupt_mask1 |= SAB82532_IMR1_XPR;
	info->regs->w.imr1 = info->interrupt_mask1;
	restore_flags(flags);
}

static void sab82532_start(struct tty_struct *tty)
{
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;
	unsigned long flags;
	
	if (serial_paranoia_check(info, tty->device, "sab82532_start"))
		return;

	save_flags(flags); cli();
	info->interrupt_mask1 &= ~(SAB82532_IMR1_XPR);
	info->regs->w.imr1 = info->interrupt_mask1;
	restore_flags(flags);
}

static void batten_down_hatches(void)
{
	/* If we are doing kadb, we call the debugger
	 * else we just drop into the boot monitor.
	 * Note that we must flush the user windows
	 * first before giving up control.
	 */
	printk("\n");
	flush_user_windows();
#ifndef __sparc_v9__
	if ((((unsigned long)linux_dbvec) >= DEBUG_FIRSTVADDR) &&
	    (((unsigned long)linux_dbvec) <= DEBUG_LASTVADDR))
		sp_enter_debugger();
	else
#endif
		prom_cmdline();
}

/*
 * ----------------------------------------------------------------------
 *
 * Here starts the interrupt handling routines.  All of the following
 * subroutines are declared as inline and are folded into
 * sab82532_interrupt().  They were separated out for readability's sake.
 *
 * Note: sab82532_interrupt() is a "fast" interrupt, which means that it
 * runs with interrupts turned off.  People who may want to modify
 * sab82532_interrupt() should try to keep the interrupt handler as fast as
 * possible.  After you are done making modifications, it is not a bad
 * idea to do:
 * 
 * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
 *
 * and look at the resulting assemble code in serial.s.
 *
 * 				- Ted Ts'o (tytso@mit.edu), 7-Mar-93
 * -----------------------------------------------------------------------
 */

/*
 * This routine is used by the interrupt handler to schedule
 * processing in the software interrupt portion of the driver.
 */
static inline void sab82532_sched_event(struct sab82532 *info, int event)
{
	info->event |= 1 << event;
	queue_task(&info->tqueue, &tq_serial);
	mark_bh(SERIAL_BH);
}

static inline void receive_chars(struct sab82532 *info,
				 union sab82532_irq_status *stat)
{
	struct tty_struct *tty = info->tty;
	unsigned char buf[32];
	unsigned char status;
	int free_fifo = 0;
	int i, count = 0;

	/* Read number of BYTES (Character + Status) available. */
	if (stat->sreg.isr0 & SAB82532_ISR0_RPF) {
		count = info->recv_fifo_size;
		free_fifo++;
	}
	if (stat->sreg.isr0 & SAB82532_ISR0_TCD) {
		count = info->regs->r.rbcl & (info->recv_fifo_size - 1);
		free_fifo++;
	}
	if (stat->sreg.isr0 & SAB82532_ISR0_RFO) {
#if 1
		printk("sab82532: receive_chars: RFO");
#endif
		free_fifo++;
	}

	/* Issue a FIFO read command in case we where idle. */
	if (stat->sreg.isr0 & SAB82532_ISR0_TIME) {
		if (info->regs->r.star & SAB82532_STAR_CEC)
			udelay(1);
		info->regs->w.cmdr = SAB82532_CMDR_RFRD;
	}

	/* Read the FIFO. */
	for (i = 0; i < (count << 1); i++)
		buf[i] = info->regs->r.rfifo[i];

	/* Issue Receive Message Complete command. */
	if (free_fifo) {
		if (info->regs->r.star & SAB82532_STAR_CEC)
			udelay(1);
		info->regs->w.cmdr = SAB82532_CMDR_RMC;
	}

	for (i = 0; i < count; ) {
		if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
#if 1
			printk("sab82532: receive_chars: tty overrun\n");
#endif
			info->icount.buf_overrun++;
			break;
		}

		tty->flip.count++;
		*tty->flip.char_buf_ptr++ = buf[i++];
		status = buf[i++];
		info->icount.rx++;

#ifdef SERIAL_DEBUG_INTR
                printk("DR%02x:%02x...", (unsigned char)*(tty->flip.char_buf_ptr - 1), status);
#endif

		if (status & SAB82532_RSTAT_PE) {
			*tty->flip.flag_buf_ptr++ = TTY_PARITY;
			info->icount.parity++;
		} else if (status & SAB82532_RSTAT_FE) {
			*tty->flip.flag_buf_ptr++ = TTY_FRAME;
			info->icount.frame++;
		}
#ifdef CMSPAR
		else if (status & SAB82532_RSTAT_PARITY)
			*tty->flip.flag_buf_ptr++ = TTY_PARITY;
#endif
		else
			*tty->flip.flag_buf_ptr++ = TTY_NORMAL;
	}

	queue_task(&tty->flip.tqueue, &tq_timer);
}

static inline void transmit_chars(struct sab82532 *info,
				  union sab82532_irq_status *stat)
{
	int i;

	if ((info->xmit_cnt <= 0) || info->tty->stopped ||
	    info->tty->hw_stopped) {
		if (stat->sreg.isr1 & SAB82532_ISR1_ALLS)
			info->all_sent = 1;
		info->interrupt_mask1 |= SAB82532_IMR1_XPR;
		info->regs->w.imr1 = info->interrupt_mask1;
		return;
	}

	/* Stuff 32 bytes into Transmit FIFO. */
	info->all_sent = 0;
	for (i = 0; i < info->xmit_fifo_size; i++) {
		info->regs->w.xfifo[i] = info->xmit_buf[info->xmit_tail++];
		info->xmit_tail &= (SERIAL_XMIT_SIZE - 1);
		info->icount.tx++;
		if (--info->xmit_cnt <= 0)
			break;
	}

	/* Issue a Transmit Frame command. */
	if (info->regs->r.star & SAB82532_STAR_CEC)
		udelay(1);
	info->regs->w.cmdr = SAB82532_CMDR_XF;

	if (info->xmit_cnt < WAKEUP_CHARS)
		sab82532_sched_event(info, RS_EVENT_WRITE_WAKEUP);

#ifdef SERIAL_DEBUG_INTR
	printk("THRE...");
#endif
	if (info->xmit_cnt <= 0) {
		info->interrupt_mask1 |= SAB82532_IMR1_XPR;
		info->regs->w.imr1 = info->interrupt_mask1;
	}
}

static inline void check_status(struct sab82532 *info,
				union sab82532_irq_status *stat)
{
	struct tty_struct *tty = info->tty;
	int modem_change = 0;

	if (stat->sreg.isr1 & SAB82532_ISR1_BRK) {
		if (info->is_console) {
			batten_down_hatches();
			return;
		}
		if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
			info->icount.buf_overrun++;
			goto check_modem;
		}
		tty->flip.count++;
		*tty->flip.flag_buf_ptr++ = TTY_PARITY;
		*tty->flip.char_buf_ptr++ = 0;
		info->icount.brk++;
	}

	if (stat->sreg.isr0 & SAB82532_ISR0_RFO) {
		if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
			info->icount.buf_overrun++;
			goto check_modem;
		}
		tty->flip.count++;
		*tty->flip.flag_buf_ptr++ = TTY_PARITY;
		*tty->flip.char_buf_ptr++ = 0;
		info->icount.overrun++;
	}

	if (info->is_console)
		return;

check_modem:
	if (stat->sreg.isr0 & SAB82532_ISR0_CDSC) {
		info->dcd = (info->regs->r.vstr & SAB82532_VSTR_CD) ? 0 : 1;
		info->icount.dcd++;
		modem_change++;
#if 0
		printk("DCD change: %d\n", info->icount.dcd);
#endif
	}
	if (stat->sreg.isr1 & SAB82532_ISR1_CSC) {
		info->cts = info->regs->r.star & SAB82532_STAR_CTS;
		info->icount.cts++;
		modem_change++;
#if 0
		printk("CTS change: %d, CTS %s\n", info->icount.cts, info->cts ? "on" : "off");
#endif
	}
	if ((info->regs->r.pvr & info->pvr_dsr_bit) ^ info->dsr) {
		info->dsr = info->regs->r.pvr & info->pvr_dsr_bit;
		info->icount.dsr++;
		modem_change++;
#if 0
		printk("DSR change: %d\n", info->icount.dsr);
#endif
	}
	if (modem_change)
		wake_up_interruptible(&info->delta_msr_wait);

	if ((info->flags & ASYNC_CHECK_CD) &&
	    (stat->sreg.isr0 & SAB82532_ISR0_CDSC)) {

#if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR))
		printk("ttys%d CD now %s...", info->line,
		       (info->dcd) ? "on" : "off");
#endif		

		if (info->dcd)
			wake_up_interruptible(&info->open_wait);
		else if (!((info->flags & ASYNC_CALLOUT_ACTIVE) &&
			   (info->flags & ASYNC_CALLOUT_NOHUP))) {

#ifdef SERIAL_DEBUG_OPEN
			printk("scheduling hangup...");
#endif

			queue_task(&info->tqueue_hangup, &tq_scheduler);
		}
	}

	if (info->flags & ASYNC_CTS_FLOW) {
		if (info->tty->hw_stopped) {
			if (info->cts) {

#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
				printk("CTS tx start...");
#endif
				info->tty->hw_stopped = 0;
				sab82532_sched_event(info,
						     RS_EVENT_WRITE_WAKEUP);
				info->interrupt_mask1 &= ~(SAB82532_IMR1_XPR);
				info->regs->w.imr1 = info->interrupt_mask1;
			}
		} else {
			if (!(info->cts)) {

#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
				printk("CTS tx stop...");
#endif
				info->tty->hw_stopped = 1;
			}
		}
	}
}

/*
 * This is the serial driver's generic interrupt routine
 */
static void sab82532_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
	struct sab82532 *info = dev_id;
	union sab82532_irq_status status;

#ifdef SERIAL_DEBUG_INTR
	printk("sab82532_interrupt(%d)...", irq);
#endif

	status.stat = 0;
	if (info->regs->r.gis & SAB82532_GIS_ISA0)
		status.sreg.isr0 = info->regs->r.isr0;
	if (info->regs->r.gis & SAB82532_GIS_ISA1)
		status.sreg.isr1 = info->regs->r.isr1;

#ifdef SERIAL_DEBUG_INTR
	printk("%d<%02x.%02x>", info->line,
	       status.sreg.isr0, status.sreg.isr1);
#endif

	if (!status.stat)
		goto next;

	if (status.sreg.isr0 & (SAB82532_ISR0_TCD | SAB82532_ISR0_TIME |
				SAB82532_ISR0_RFO | SAB82532_ISR0_RPF))
		receive_chars(info, &status);
	if ((status.sreg.isr0 & SAB82532_ISR0_CDSC) ||
	    (status.sreg.isr1 & (SAB82532_ISR1_BRK | SAB82532_ISR1_CSC)))
		check_status(info, &status);
	if (status.sreg.isr1 & (SAB82532_ISR1_ALLS | SAB82532_ISR1_XPR))
		transmit_chars(info, &status);

next:
	info = info->next;
	status.stat = 0;
	if (info->regs->r.gis & SAB82532_GIS_ISB0)
		status.sreg.isr0 = info->regs->r.isr0;
	if (info->regs->r.gis & SAB82532_GIS_ISB1)
		status.sreg.isr1 = info->regs->r.isr1;

#ifdef SERIAL_DEBUG_INTR
	printk("%d<%02x.%02x>", info->line,
	       status.sreg.isr0, status.sreg.isr1);
#endif

	if (!status.stat)
		goto done;

	if (status.sreg.isr0 & (SAB82532_ISR0_TCD | SAB82532_ISR0_TIME |
				SAB82532_ISR0_RFO | SAB82532_ISR0_RPF))
		receive_chars(info, &status);
	if ((status.sreg.isr0 & SAB82532_ISR0_CDSC) ||
	    (status.sreg.isr1 & (SAB82532_ISR1_BRK | SAB82532_ISR1_CSC)))
		check_status(info, &status);
	if (status.sreg.isr1 & (SAB82532_ISR1_ALLS | SAB82532_ISR1_XPR))
		transmit_chars(info, &status);

done:
#ifdef SERIAL_DEBUG_INTR
	printk("end.\n");
#endif
}

/*
 * -------------------------------------------------------------------
 * Here ends the serial interrupt routines.
 * -------------------------------------------------------------------
 */

/*
 * This routine is used to handle the "bottom half" processing for the
 * serial driver, known also the "software interrupt" processing.
 * This processing is done at the kernel interrupt level, after the
 * sab82532_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This
 * is where time-consuming activities which can not be done in the
 * interrupt driver proper are done; the interrupt driver schedules
 * them using sab82532_sched_event(), and they get done here.
 */
static void do_serial_bh(void)
{
	run_task_queue(&tq_serial);
}

static void do_softint(void *private_)
{
	struct sab82532	*info = (struct sab82532 *)private_;
	struct tty_struct *tty;

	tty = info->tty;
	if (!tty)
		return;

	if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
		if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
		    tty->ldisc.write_wakeup)
			(tty->ldisc.write_wakeup)(tty);
		wake_up_interruptible(&tty->write_wait);
	}
}

/*
 * This routine is called from the scheduler tqueue when the interrupt
 * routine has signalled that a hangup has occurred.  The path of
 * hangup processing is:
 *
 * 	serial interrupt routine -> (scheduler tqueue) ->
 * 	do_serial_hangup() -> tty->hangup() -> sab82532_hangup()
 * 
 */
static void do_serial_hangup(void *private_)
{
	struct sab82532	*info = (struct sab82532 *) private_;
	struct tty_struct *tty;

	tty = info->tty;
	if (!tty)
		return;

	tty_hangup(tty);
}


static int startup(struct sab82532 *info)
{
	unsigned long flags;
	unsigned long page;
	unsigned char stat;

	page = get_free_page(GFP_KERNEL);
	if (!page)
		return -ENOMEM;

	save_flags(flags); cli();

	if (info->flags & ASYNC_INITIALIZED) {
		free_page(page);
		goto errout;
	}

	if (!info->regs) {
		if (info->tty)
			set_bit(TTY_IO_ERROR, &info->tty->flags);
		free_page(page);
		goto errout;
	}
	if (info->xmit_buf)
		free_page(page);
	else
		info->xmit_buf = (unsigned char *)page;

#ifdef SERIAL_DEBUG_OPEN
	printk("starting up serial port %d...", info->line);
#endif

	/*
	 * Clear the FIFO buffers.
	 */
	if (info->regs->r.star & SAB82532_STAR_CEC)
		udelay(1);
	info->regs->w.cmdr = SAB82532_CMDR_RRES;
	if (info->regs->r.star & SAB82532_STAR_CEC)
		udelay(1);
	info->regs->w.cmdr = SAB82532_CMDR_XRES;

	/*
	 * Clear the interrupt registers.
	 */
	stat = info->regs->r.isr0;
	stat = info->regs->r.isr1;

	/*
	 * Now, initialize the UART 
	 */
	info->regs->w.ccr0 = 0;				/* power-down */
	info->regs->w.ccr0 = SAB82532_CCR0_MCE | SAB82532_CCR0_SC_NRZ |
			     SAB82532_CCR0_SM_ASYNC;
	info->regs->w.ccr1 = SAB82532_CCR1_ODS | SAB82532_CCR1_BCR | 7;
	info->regs->w.ccr2 = SAB82532_CCR2_BDF | SAB82532_CCR2_SSEL |
			     SAB82532_CCR2_TOE;
	info->regs->w.ccr3 = 0;
	info->regs->w.ccr4 = SAB82532_CCR4_MCK4 | SAB82532_CCR4_EBRG;
	info->regs->w.mode = SAB82532_MODE_RTS | SAB82532_MODE_FCTS |
			     SAB82532_MODE_RAC;
	info->regs->w.rfc = SAB82532_RFC_DPS | SAB82532_RFC_RFDF;
	switch (info->recv_fifo_size) {
		case 1:
			info->regs->w.rfc |= SAB82532_RFC_RFTH_1;
			break;
		case 4:
			info->regs->w.rfc |= SAB82532_RFC_RFTH_4;
			break;
		case 16:
			info->regs->w.rfc |= SAB82532_RFC_RFTH_16;
			break;
		default:
			info->recv_fifo_size = 32;
			/* fall through */
		case 32:
			info->regs->w.rfc |= SAB82532_RFC_RFTH_32;
			break;
	}
	info->regs->rw.ccr0 |= SAB82532_CCR0_PU;	/* power-up */
	
	/*
	 * Finally, enable interrupts
	 */
	info->interrupt_mask0 = SAB82532_IMR0_PERR | SAB82532_IMR0_FERR |
				SAB82532_IMR0_PLLA;
	info->regs->w.imr0 = info->interrupt_mask0;
	info->interrupt_mask1 = SAB82532_IMR1_BRKT | SAB82532_IMR1_XOFF |
				SAB82532_IMR1_TIN | SAB82532_IMR1_XON |
				SAB82532_IMR1_XPR;
	info->regs->w.imr1 = info->interrupt_mask1;

	if (info->tty)
		clear_bit(TTY_IO_ERROR, &info->tty->flags);
	info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;

	/*
	 * and set the speed of the serial port
	 */
	change_speed(info);

	info->flags |= ASYNC_INITIALIZED;
	restore_flags(flags);
	return 0;
	
errout:
	restore_flags(flags);
	return -ENODEV;
}

/*
 * This routine will shutdown a serial port; interrupts are disabled, and
 * DTR is dropped if the hangup on close termio flag is on.
 */
static void shutdown(struct sab82532 *info)
{
	unsigned long flags;

	if (!(info->flags & ASYNC_INITIALIZED))
		return;

#ifdef SERIAL_DEBUG_OPEN
	printk("Shutting down serial port %d...", info->line);
#endif

	save_flags(flags); cli(); /* Disable interrupts */

	/*
	 * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
	 * here so the queue might never be waken up
	 */
	wake_up_interruptible(&info->delta_msr_wait);

	if (info->xmit_buf) {
		free_page((unsigned long)info->xmit_buf);
		info->xmit_buf = 0;
	}

	/* Disable Interrupts */
	info->interrupt_mask0 = 0xff;
	info->regs->w.imr0 = info->interrupt_mask0;
	info->interrupt_mask1 = 0xff;
	info->regs->w.imr1 = info->interrupt_mask1;

	if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
		info->regs->rw.mode |= SAB82532_MODE_FRTS;
		info->regs->rw.mode |= SAB82532_MODE_RTS;
		info->regs->rw.pvr |= info->pvr_dtr_bit;
	}

	/* Disable break condition */
	info->regs->rw.dafo &= ~(SAB82532_DAFO_XBRK);

	/* Disable Receiver */	
	info->regs->rw.mode &= ~(SAB82532_MODE_RAC);

	/* Power Down */	
	info->regs->rw.ccr0 &= ~(SAB82532_CCR0_PU);

	if (info->tty)
		set_bit(TTY_IO_ERROR, &info->tty->flags);

	info->flags &= ~ASYNC_INITIALIZED;
	restore_flags(flags);
}

/*
 * This routine is called to set the UART divisor registers to match
 * the specified baud rate for a serial port.
 */
static void change_speed(struct sab82532 *info)
{
	unsigned long	flags;
	unsigned int	ebrg;
	tcflag_t	cflag;
	unsigned char	dafo;
	int		i;

	if (!info->tty || !info->tty->termios)
		return;
	cflag = info->tty->termios->c_cflag;

	/* Byte size and parity */
	switch (cflag & CSIZE) {
	      case CS5: dafo = SAB82532_DAFO_CHL5; break;
	      case CS6: dafo = SAB82532_DAFO_CHL6; break;
	      case CS7: dafo = SAB82532_DAFO_CHL7; break;
	      case CS8: dafo = SAB82532_DAFO_CHL8; break;
	      /* Never happens, but GCC is too dumb to figure it out */
	      default:  dafo = SAB82532_DAFO_CHL5; break;
	}

	if (cflag & CSTOPB)
		dafo |= SAB82532_DAFO_STOP;

	if (cflag & PARENB)
		dafo |= SAB82532_DAFO_PARE;

	if (cflag & PARODD) {
#ifdef CMSPAR
		if (cflag & CMSPAR)
			dafo |= SAB82532_DAFO_PAR_MARK;
		else
#endif
			dafo |= SAB82532_DAFO_PAR_ODD;
	} else {
#ifdef CMSPAR
		if (cflag & CMSPAR)
			dafo |= SAB82532_DAFO_PAR_SPACE;
		else
#endif
			dafo |= SAB82532_DAFO_PAR_EVEN;
	}

	/* Determine EBRG values based on baud rate */
	i = cflag & CBAUD;
	if (i & CBAUDEX) {
		i &= ~(CBAUDEX);
		if ((i < 1) || ((i + 15) >= NR_EBRG_VALUES))
			info->tty->termios->c_cflag &= ~CBAUDEX;
		else
			i += 15;
	}
	ebrg = ebrg_table[i].n;
	ebrg |= (ebrg_table[i].m << 6);

	/* CTS flow control flags */
	if (cflag & CRTSCTS)
		info->flags |= ASYNC_CTS_FLOW;
	else
		info->flags &= ~(ASYNC_CTS_FLOW);

	if (cflag & CLOCAL)
		info->flags &= ~(ASYNC_CHECK_CD);
	else
		info->flags |= ASYNC_CHECK_CD;
	if (info->tty)
		info->tty->hw_stopped = 0;

	/*
	 * Set up parity check flag
	 * XXX: not implemented, yet.
	 */
#define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))

	/*
	 * Characters to ignore
	 * XXX: not implemented, yet.
	 */

	/*
	 * !!! ignore all characters if CREAD is not set
	 * XXX: not implemented, yet.
	 */
	if ((cflag & CREAD) == 0)
		info->ignore_status_mask |= SAB82532_ISR0_RPF |
					    SAB82532_ISR0_TCD |
					    SAB82532_ISR0_TIME;

	save_flags(flags); cli();
	info->regs->w.dafo = dafo;
	info->regs->w.bgr = ebrg & 0xff;
	info->regs->rw.ccr2 &= ~(0xc0);
	info->regs->rw.ccr2 |= (ebrg >> 2) & 0xc0;
	if (info->flags & ASYNC_CTS_FLOW) {
		info->regs->rw.mode &= ~(SAB82532_MODE_RTS);
		info->regs->rw.mode |= SAB82532_MODE_FRTS;
		info->regs->rw.mode &= ~(SAB82532_MODE_FCTS);
	} else {
		info->regs->rw.mode |= SAB82532_MODE_RTS;
		info->regs->rw.mode &= ~(SAB82532_MODE_FRTS);
		info->regs->rw.mode |= SAB82532_MODE_FCTS;
	}
	info->regs->rw.mode |= SAB82532_MODE_RAC;
	restore_flags(flags);
}

static void sab82532_put_char(struct tty_struct *tty, unsigned char ch)
{
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;
	unsigned long flags;

	if (serial_paranoia_check(info, tty->device, "sab82532_put_char"))
		return;

	if (!tty || !info->xmit_buf)
		return;

	save_flags(flags); cli();
	if (info->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
		restore_flags(flags);
		return;
	}

	info->xmit_buf[info->xmit_head++] = ch;
	info->xmit_head &= SERIAL_XMIT_SIZE-1;
	info->xmit_cnt++;
	restore_flags(flags);
}

static void sab82532_flush_chars(struct tty_struct *tty)
{
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;
	unsigned long flags;

	if (serial_paranoia_check(info, tty->device, "sab82532_flush_chars"))
		return;

	if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
	    !info->xmit_buf)
		return;

	save_flags(flags); cli();
	info->interrupt_mask1 &= ~(SAB82532_IMR1_XPR);
	info->regs->w.imr1 = info->interrupt_mask1;
	restore_flags(flags);
}

static int sab82532_write(struct tty_struct * tty, int from_user,
			  const unsigned char *buf, int count)
{
	int c, ret = 0;
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;
	unsigned long flags;

	if (serial_paranoia_check(info, tty->device, "sab82532_write"))
		return 0;

	if (!tty || !info->xmit_buf || !tmp_buf)
		return 0;
	    
	if (from_user)
		down(&tmp_buf_sem);
	save_flags(flags);
	while (1) {
		cli();		
		c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
				   SERIAL_XMIT_SIZE - info->xmit_head));
		if (c <= 0)
			break;

		if (from_user) {
			c -= copy_from_user(tmp_buf, buf, c);
			if (!c) {
				if (!ret)
					ret = -EFAULT;
				break;
			}
			c = MIN(c, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
				       SERIAL_XMIT_SIZE - info->xmit_head));
			memcpy(info->xmit_buf + info->xmit_head, tmp_buf, c);
		} else
			memcpy(info->xmit_buf + info->xmit_head, buf, c);
		info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
		info->xmit_cnt += c;
		restore_flags(flags);
		buf += c;
		count -= c;
		ret += c;
	}
	if (from_user)
		up(&tmp_buf_sem);

	if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
	    (info->interrupt_mask1 & SAB82532_IMR1_XPR)) {
		info->interrupt_mask1 &= ~(SAB82532_IMR1_XPR);
		info->regs->w.imr1 = info->interrupt_mask1;
	}

	restore_flags(flags);
	return ret;
}

static int sab82532_write_room(struct tty_struct *tty)
{
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;
	int ret;

	if (serial_paranoia_check(info, tty->device, "sab82532_write_room"))
		return 0;
	ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
	if (ret < 0)
		ret = 0;
	return ret;
}

static int sab82532_chars_in_buffer(struct tty_struct *tty)
{
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;
				
	if (serial_paranoia_check(info, tty->device, "sab82532_chars_in_buffer"))
		return 0;
	return info->xmit_cnt;
}

static void sab82532_flush_buffer(struct tty_struct *tty)
{
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;
				
	if (serial_paranoia_check(info, tty->device, "sab82532_flush_buffer"))
		return;
	cli();
	info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
	sti();
	wake_up_interruptible(&tty->write_wait);
	if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
	    tty->ldisc.write_wakeup)
		(tty->ldisc.write_wakeup)(tty);
}

/*
 * This function is used to send a high-priority XON/XOFF character to
 * the device
 */
static void sab82532_send_xchar(struct tty_struct *tty, char ch)
{
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;

	if (serial_paranoia_check(info, tty->device, "sab82532_send_xchar"))
		return;

	if (info->regs->r.star & SAB82532_STAR_TEC)
		udelay(1);
	info->regs->w.tic = ch;
}

/*
 * ------------------------------------------------------------
 * sab82532_throttle()
 * 
 * This routine is called by the upper-layer tty layer to signal that
 * incoming characters should be throttled.
 * ------------------------------------------------------------
 */
static void sab82532_throttle(struct tty_struct * tty)
{
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;
#ifdef SERIAL_DEBUG_THROTTLE
	char	buf[64];
	
	printk("throttle %s: %d....\n", _tty_name(tty, buf),
	       tty->ldisc.chars_in_buffer(tty));
#endif

	if (serial_paranoia_check(info, tty->device, "sab82532_throttle"))
		return;
	
	if (I_IXOFF(tty))
		sab82532_send_xchar(tty, STOP_CHAR(tty));
#if 0
	if (tty->termios->c_cflag & CRTSCTS)
		info->regs->rw.mode |= SAB82532_MODE_RTS;
#endif
}

static void sab82532_unthrottle(struct tty_struct * tty)
{
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;
#ifdef SERIAL_DEBUG_THROTTLE
	char	buf[64];
	
	printk("unthrottle %s: %d....\n", _tty_name(tty, buf),
	       tty->ldisc.chars_in_buffer(tty));
#endif

	if (serial_paranoia_check(info, tty->device, "sab82532_unthrottle"))
		return;
	
	if (I_IXOFF(tty)) {
		if (info->x_char)
			info->x_char = 0;
		else
			sab82532_send_xchar(tty, START_CHAR(tty));
	}

#if 0
	if (tty->termios->c_cflag & CRTSCTS)
		info->regs->rw.mode &= ~(SAB82532_MODE_RTS);
#endif
}

/*
 * ------------------------------------------------------------
 * sab82532_ioctl() and friends
 * ------------------------------------------------------------
 */

static int get_serial_info(struct sab82532 *info,
			   struct serial_struct *retinfo)
{
	struct serial_struct tmp;
   
	if (!retinfo)
		return -EFAULT;
	memset(&tmp, 0, sizeof(tmp));
	tmp.type = info->type;
	tmp.line = info->line;
	tmp.port = (unsigned long)info->regs;
	tmp.irq = info->irq;
	tmp.flags = info->flags;
	tmp.xmit_fifo_size = info->xmit_fifo_size;
	tmp.baud_base = info->baud_base;
	tmp.close_delay = info->close_delay;
	tmp.closing_wait = info->closing_wait;
	tmp.custom_divisor = info->custom_divisor;
	tmp.hub6 = 0;
	if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
		return -EFAULT;
	return 0;
}

static int set_serial_info(struct sab82532 *info,
			   struct serial_struct *new_info)
{
	return 0;
}


/*
 * get_lsr_info - get line status register info
 *
 * Purpose: Let user call ioctl() to get info when the UART physically
 * 	    is emptied.  On bus types like RS485, the transmitter must
 * 	    release the bus after transmitting. This must be done when
 * 	    the transmit shift register is empty, not be done when the
 * 	    transmit holding register is empty.  This functionality
 * 	    allows an RS485 driver to be written in user space. 
 */
static int get_lsr_info(struct sab82532 * info, unsigned int *value)
{
	unsigned int result;

	result = info->all_sent ? TIOCSER_TEMT : 0;
	return put_user(result, value);
}


static int get_modem_info(struct sab82532 * info, unsigned int *value)
{
	unsigned int result;

	result =  ((info->regs->r.mode & SAB82532_MODE_FRTS) ? 0 : TIOCM_RTS)
		| ((info->regs->r.pvr & info->pvr_dtr_bit) ? 0 : TIOCM_DTR)
		| ((info->regs->r.vstr & SAB82532_VSTR_CD) ? 0 : TIOCM_CAR)
		| ((info->regs->r.pvr & info->pvr_dsr_bit) ? 0 : TIOCM_DSR)
		| ((info->regs->r.star & SAB82532_STAR_CTS) ? TIOCM_CTS : 0);
	return put_user(result,value);
}

static int set_modem_info(struct sab82532 * info, unsigned int cmd,
			  unsigned int *value)
{
	int error;
	unsigned int arg;

	error = get_user(arg, value);
	if (error)
		return error;
	switch (cmd) {
	case TIOCMBIS: 
		if (arg & TIOCM_RTS) {
			info->regs->rw.mode &= ~(SAB82532_MODE_FRTS);
			info->regs->rw.mode |= SAB82532_MODE_RTS;
		}
		if (arg & TIOCM_DTR) {
			info->regs->rw.pvr &= ~(info->pvr_dtr_bit);
		}
		break;
	case TIOCMBIC:
		if (arg & TIOCM_RTS) {
			info->regs->rw.mode |= SAB82532_MODE_FRTS;
			info->regs->rw.mode |= SAB82532_MODE_RTS;
		}
		if (arg & TIOCM_DTR) {
			info->regs->rw.pvr |= info->pvr_dtr_bit;
		}
		break;
	case TIOCMSET:
		if (arg & TIOCM_RTS) {
			info->regs->rw.mode &= ~(SAB82532_MODE_FRTS);
			info->regs->rw.mode |= SAB82532_MODE_RTS;
		} else {
			info->regs->rw.mode |= SAB82532_MODE_FRTS;
			info->regs->rw.mode |= SAB82532_MODE_RTS;
		}
		if (arg & TIOCM_DTR) {
			info->regs->rw.pvr &= ~(info->pvr_dtr_bit);
		} else {
			info->regs->rw.pvr |= info->pvr_dtr_bit;
		}
		break;
	default:
		return -EINVAL;
	}
	return 0;
}

/*
 * This routine sends a break character out the serial port.
 */
static void send_break(	struct sab82532 * info, int duration)
{
	if (!info->regs)
		return;
	current->state = TASK_INTERRUPTIBLE;
	current->timeout = jiffies + duration;
#ifdef SERIAL_DEBUG_SEND_BREAK
	printk("sab82532_send_break(%d) jiff=%lu...", duration, jiffies);
#endif
	cli();
	info->regs->rw.dafo |= SAB82532_DAFO_XBRK;
	schedule();
	info->regs->rw.dafo &= ~(SAB82532_DAFO_XBRK);
	sti();
#ifdef SERIAL_DEBUG_SEND_BREAK
	printk("done jiffies=%lu\n", jiffies);
#endif
}

/*
 * This routine sets the break condition on the serial port.
 */
static void begin_break(struct sab82532 * info)
{
	if (!info->regs)
		return;
	info->regs->rw.dafo |= SAB82532_DAFO_XBRK;
}

/*
 * This routine clears the break condition on the serial port.
 */
static void end_break(struct sab82532 * info)
{
	if (!info->regs)
		return;
	info->regs->rw.dafo &= ~(SAB82532_DAFO_XBRK);
}

static int sab82532_ioctl(struct tty_struct *tty, struct file * file,
		    unsigned int cmd, unsigned long arg)
{
	int error;
	struct sab82532 * info = (struct sab82532 *)tty->driver_data;
	int retval;
	struct async_icount cprev, cnow;	/* kernel counter temps */
	struct serial_icounter_struct *p_cuser;	/* user space */

	if (serial_paranoia_check(info, tty->device, "sab82532_ioctl"))
		return -ENODEV;

	if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
	    (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGWILD)  &&
	    (cmd != TIOCSERSWILD) && (cmd != TIOCSERGSTRUCT) &&
	    (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
		if (tty->flags & (1 << TTY_IO_ERROR))
		    return -EIO;
	}
	
	switch (cmd) {
		case TCSBRK:	/* SVID version: non-zero arg --> no break */
			retval = tty_check_change(tty);
			if (retval)
				return retval;
			tty_wait_until_sent(tty, 0);
			if (signal_pending(current))
				return -EINTR;
			if (!arg) {
				send_break(info, HZ/4);	/* 1/4 second */
				if (signal_pending(current))
					return -EINTR;
			}
			return 0;
		case TCSBRKP:	/* support for POSIX tcsendbreak() */
			retval = tty_check_change(tty);
			if (retval)
				return retval;
			tty_wait_until_sent(tty, 0);
			if (signal_pending(current))
				return -EINTR;
			send_break(info, arg ? arg*(HZ/10) : HZ/4);
			if (signal_pending(current))
				return -EINTR;
			return 0;
		case TIOCSBRK:
			retval = tty_check_change(tty);
			if (retval)
				return retval;
			tty_wait_until_sent(tty, 0);
			begin_break(info);
			return 0;
		case TIOCCBRK:
			retval = tty_check_change(tty);
			if (retval)
				return retval;
			end_break(info);
			return 0;
		case TIOCGSOFTCAR:
			return put_user(C_CLOCAL(tty) ? 1 : 0, (int *) arg);
		case TIOCSSOFTCAR:
			error = get_user(arg, (unsigned int *) arg);
			if (error)
				return error;
			tty->termios->c_cflag =
				((tty->termios->c_cflag & ~CLOCAL) |
				 (arg ? CLOCAL : 0));
			return 0;
		case TIOCMGET:
			return get_modem_info(info, (unsigned int *) arg);
		case TIOCMBIS:
		case TIOCMBIC:
		case TIOCMSET:
			return set_modem_info(info, cmd, (unsigned int *) arg);
		case TIOCGSERIAL:
			return get_serial_info(info,
					       (struct serial_struct *) arg);
		case TIOCSSERIAL:
			return set_serial_info(info,
					       (struct serial_struct *) arg);

		case TIOCSERGETLSR: /* Get line status register */
			return get_lsr_info(info, (unsigned int *) arg);

		case TIOCSERGSTRUCT:
			if (copy_to_user((struct sab82532 *) arg,
					 info, sizeof(struct sab82532)))
				return -EFAULT;
			return 0;
				
		/*
		 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
		 * - mask passed in arg for lines of interest
 		 *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
		 * Caller should use TIOCGICOUNT to see which one it was
		 */
		 case TIOCMIWAIT:
			cli();
			/* note the counters on entry */
			cprev = info->icount;
			sti();
			while (1) {
				interruptible_sleep_on(&info->delta_msr_wait);
				/* see if a signal did it */
				if (signal_pending(current))
					return -ERESTARTSYS;
				cli();
				cnow = info->icount; /* atomic copy */
				sti();
				if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && 
				    cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
					return -EIO; /* no change => error */
				if ( ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
				     ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
				     ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
				     ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
					return 0;
				}
				cprev = cnow;
			}
			/* NOTREACHED */

		/* 
		 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
		 * Return: write counters to the user passed counter struct
		 * NB: both 1->0 and 0->1 transitions are counted except for
		 *     RI where only 0->1 is counted.
		 */
		case TIOCGICOUNT:
			cli();
			cnow = info->icount;
			sti();
			p_cuser = (struct serial_icounter_struct *) arg;
			error = put_user(cnow.cts, &p_cuser->cts);
			if (error) return error;
			error = put_user(cnow.dsr, &p_cuser->dsr);
			if (error) return error;
			error = put_user(cnow.rng, &p_cuser->rng);
			if (error) return error;
			error = put_user(cnow.dcd, &p_cuser->dcd);
			if (error) return error;
			return 0;

		default:
			return -ENOIOCTLCMD;
		}
	return 0;
}

static void sab82532_set_termios(struct tty_struct *tty,
				 struct termios *old_termios)
{
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;

	if (   (tty->termios->c_cflag == old_termios->c_cflag)
	    && (   RELEVANT_IFLAG(tty->termios->c_iflag) 
		== RELEVANT_IFLAG(old_termios->c_iflag)))
	  return;

	change_speed(info);

	/* Handle transition to B0 status */
	if ((old_termios->c_cflag & CBAUD) &&
	    !(tty->termios->c_cflag & CBAUD)) {
		info->regs->w.mode |= SAB82532_MODE_FRTS;
		info->regs->w.mode |= SAB82532_MODE_RTS;
		info->regs->w.pvr |= info->pvr_dtr_bit;
	}
	
	/* Handle transition away from B0 status */
	if (!(old_termios->c_cflag & CBAUD) &&
	    (tty->termios->c_cflag & CBAUD)) {
		info->regs->w.pvr &= ~(info->pvr_dtr_bit);
		if (!tty->hw_stopped ||
		    !(tty->termios->c_cflag & CRTSCTS)) {
			info->regs->w.mode &= ~(SAB82532_MODE_FRTS);
			info->regs->w.mode |= SAB82532_MODE_RTS;
		}
	}
	
	/* Handle turning off CRTSCTS */
	if ((old_termios->c_cflag & CRTSCTS) &&
	    !(tty->termios->c_cflag & CRTSCTS)) {
		tty->hw_stopped = 0;
		sab82532_start(tty);
	}

#if 0
	/*
	 * No need to wake up processes in open wait, since they
	 * sample the CLOCAL flag once, and don't recheck it.
	 * XXX  It's not clear whether the current behavior is correct
	 * or not.  Hence, this may change.....
	 */
	if (!(old_termios->c_cflag & CLOCAL) &&
	    (tty->termios->c_cflag & CLOCAL))
		wake_up_interruptible(&info->open_wait);
#endif
}

/*
 * ------------------------------------------------------------
 * sab82532_close()
 * 
 * This routine is called when the serial port gets closed.  First, we
 * wait for the last remaining data to be sent.  Then, we unlink its
 * async structure from the interrupt chain if necessary, and we free
 * that IRQ if nothing is left in the chain.
 * ------------------------------------------------------------
 */
static void sab82532_close(struct tty_struct *tty, struct file * filp)
{
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;
	unsigned long flags;

	if (!info || serial_paranoia_check(info, tty->device, "sab82532_close"))
		return;

	save_flags(flags); cli();

	if (tty_hung_up_p(filp)) {
		MOD_DEC_USE_COUNT;
		restore_flags(flags);
		return;
	}

#ifdef SERIAL_DEBUG_OPEN
	printk("sab82532_close ttys%d, count = %d\n", info->line, info->count);
#endif
	if ((tty->count == 1) && (info->count != 1)) {
		/*
		 * Uh, oh.  tty->count is 1, which means that the tty
		 * structure will be freed.  info->count should always
		 * be one in these conditions.  If it's greater than
		 * one, we've got real problems, since it means the
		 * serial port won't be shutdown.
		 */
		printk("sab82532_close: bad serial port count; tty->count is 1,"
		       " info->count is %d\n", info->count);
		info->count = 1;
	}
	if (--info->count < 0) {
		printk("sab82532_close: bad serial port count for ttys%d: %d\n",
		       info->line, info->count);
		info->count = 0;
	}
	if (info->count) {
		MOD_DEC_USE_COUNT;
		restore_flags(flags);
		return;
	}
	info->flags |= ASYNC_CLOSING;
	/*
	 * Save the termios structure, since this port may have
	 * separate termios for callout and dialin.
	 */
	if (info->flags & ASYNC_NORMAL_ACTIVE)
		info->normal_termios = *tty->termios;
	if (info->flags & ASYNC_CALLOUT_ACTIVE)
		info->callout_termios = *tty->termios;
	/*
	 * Now we wait for the transmit buffer to clear; and we notify 
	 * the line discipline to only process XON/XOFF characters.
	 */
	tty->closing = 1;
	if (info->closing_wait != ASYNC_CLOSING_WAIT_NONE)
		tty_wait_until_sent(tty, info->closing_wait);

	/*
	 * At this point we stop accepting input.  To do this, we
	 * disable the receive line status interrupts, and turn off
	 * the receiver.
	 */
	info->interrupt_mask0 |= SAB82532_IMR0_TCD;
	info->regs->w.imr0 = info->interrupt_mask0;
	info->regs->rw.mode &= ~(SAB82532_MODE_RAC);
	if (info->flags & ASYNC_INITIALIZED) {
		/*
		 * Before we drop DTR, make sure the UART transmitter
		 * has completely drained; this is especially
		 * important if there is a transmit FIFO!
		 */
		sab82532_wait_until_sent(tty, info->timeout);
	}
	shutdown(info);
	if (tty->driver.flush_buffer)
		tty->driver.flush_buffer(tty);
	if (tty->ldisc.flush_buffer)
		tty->ldisc.flush_buffer(tty);
	tty->closing = 0;
	info->event = 0;
	info->tty = 0;
	if (info->blocked_open) {
		if (info->close_delay) {
			current->state = TASK_INTERRUPTIBLE;
			current->timeout = jiffies + info->close_delay;
			schedule();
		}
		wake_up_interruptible(&info->open_wait);
	}
	info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE|
			 ASYNC_CLOSING);
	wake_up_interruptible(&info->close_wait);
	MOD_DEC_USE_COUNT;
	restore_flags(flags);
}

/*
 * sab82532_wait_until_sent() --- wait until the transmitter is empty
 */
static void sab82532_wait_until_sent(struct tty_struct *tty, int timeout)
{
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;
	unsigned long orig_jiffies, char_time;

	if (serial_paranoia_check(info,tty->device,"sab82532_wait_until_sent"))
		return;

	orig_jiffies = jiffies;
	/*
	 * Set the check interval to be 1/5 of the estimated time to
	 * send a single character, and make it at least 1.  The check
	 * interval should also be less than the timeout.
	 * 
	 * Note: we have to use pretty tight timings here to satisfy
	 * the NIST-PCTS.
	 */
	char_time = (info->timeout - HZ/50) / info->xmit_fifo_size;
	char_time = char_time / 5;
	if (char_time == 0)
		char_time = 1;
	if (timeout)
	  char_time = MIN(char_time, timeout);
#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
	printk("In sab82532_wait_until_sent(%d) check=%lu...", timeout, char_time);
	printk("jiff=%lu...", jiffies);
#endif

	/* XXX: Implement this... */

	current->state = TASK_RUNNING;
#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
	printk("lsr = %d (jiff=%lu)...done\n", lsr, jiffies);
#endif
}

/*
 * sab82532_hangup() --- called by tty_hangup() when a hangup is signaled.
 */
static void sab82532_hangup(struct tty_struct *tty)
{
	struct sab82532 * info = (struct sab82532 *)tty->driver_data;
	
	if (serial_paranoia_check(info, tty->device, "sab82532_hangup"))
		return;

	sab82532_flush_buffer(tty);
	shutdown(info);
	info->event = 0;
	info->count = 0;
	info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE);
	info->tty = 0;
	wake_up_interruptible(&info->open_wait);
}

/*
 * ------------------------------------------------------------
 * sab82532_open() and friends
 * ------------------------------------------------------------
 */
static int block_til_ready(struct tty_struct *tty, struct file * filp,
			   struct sab82532 *info)
{
	struct wait_queue wait = { current, NULL };
	int retval;
	int do_clocal = 0;

	/*
	 * If the device is in the middle of being closed, then block
	 * until it's done, and then try again.
	 */
	if (tty_hung_up_p(filp) ||
	    (info->flags & ASYNC_CLOSING)) {
		if (info->flags & ASYNC_CLOSING)
			interruptible_sleep_on(&info->close_wait);
#ifdef SERIAL_DO_RESTART
		if (info->flags & ASYNC_HUP_NOTIFY)
			return -EAGAIN;
		else
			return -ERESTARTSYS;
#else
		return -EAGAIN;
#endif
	}

	/*
	 * If this is a callout device, then just make sure the normal
	 * device isn't being used.
	 */
	if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) {
		if (info->flags & ASYNC_NORMAL_ACTIVE)
			return -EBUSY;
		if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
		    (info->flags & ASYNC_SESSION_LOCKOUT) &&
		    (info->session != current->session))
		    return -EBUSY;
		if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
		    (info->flags & ASYNC_PGRP_LOCKOUT) &&
		    (info->pgrp != current->pgrp))
		    return -EBUSY;
		info->flags |= ASYNC_CALLOUT_ACTIVE;
		return 0;
	}
	
	/*
	 * If non-blocking mode is set, or the port is not enabled,
	 * then make the check up front and then exit.
	 */
	if ((filp->f_flags & O_NONBLOCK) ||
	    (tty->flags & (1 << TTY_IO_ERROR))) {
		if (info->flags & ASYNC_CALLOUT_ACTIVE)
			return -EBUSY;
		info->flags |= ASYNC_NORMAL_ACTIVE;
		return 0;
	}

	if (info->flags & ASYNC_CALLOUT_ACTIVE) {
		if (info->normal_termios.c_cflag & CLOCAL)
			do_clocal = 1;
	} else {
		if (tty->termios->c_cflag & CLOCAL)
			do_clocal = 1;
	}
	
	/*
	 * Block waiting for the carrier detect and the line to become
	 * free (i.e., not in use by the callout).  While we are in
	 * this loop, info->count is dropped by one, so that
	 * sab82532_close() knows when to free things.  We restore it upon
	 * exit, either normal or abnormal.
	 */
	retval = 0;
	add_wait_queue(&info->open_wait, &wait);
#ifdef SERIAL_DEBUG_OPEN
	printk("block_til_ready before block: ttyS%d, count = %d\n",
	       info->line, info->count);
#endif
	cli();
	if (!tty_hung_up_p(filp)) 
		info->count--;
	sti();
	info->blocked_open++;
	while (1) {
		cli();
		if (!(info->flags & ASYNC_CALLOUT_ACTIVE) &&
		    (tty->termios->c_cflag & CBAUD)) {
			info->regs->rw.pvr &= ~(info->pvr_dtr_bit);
			info->regs->rw.mode |= SAB82532_MODE_FRTS;
			info->regs->rw.mode &= ~(SAB82532_MODE_RTS);
		}
		sti();
		current->state = TASK_INTERRUPTIBLE;
		if (tty_hung_up_p(filp) ||
		    !(info->flags & ASYNC_INITIALIZED)) {
#ifdef SERIAL_DO_RESTART
			if (info->flags & ASYNC_HUP_NOTIFY)
				retval = -EAGAIN;
			else
				retval = -ERESTARTSYS;	
#else
			retval = -EAGAIN;
#endif
			break;
		}
		if (!(info->flags & ASYNC_CALLOUT_ACTIVE) &&
		    !(info->flags & ASYNC_CLOSING) &&
		    (do_clocal || !(info->regs->r.vstr & SAB82532_VSTR_CD)))
			break;
		if (signal_pending(current)) {
			retval = -ERESTARTSYS;
			break;
		}
#ifdef SERIAL_DEBUG_OPEN
		printk("block_til_ready blocking: ttyS%d, count = %d, flags = %x, clocal = %d, vstr = %02x\n",
		       info->line, info->count, info->flags, do_clocal, info->regs->r.vstr);
#endif
		schedule();
	}
	current->state = TASK_RUNNING;
	remove_wait_queue(&info->open_wait, &wait);
	if (!tty_hung_up_p(filp))
		info->count++;
	info->blocked_open--;
#ifdef SERIAL_DEBUG_OPEN
	printk("block_til_ready after blocking: ttys%d, count = %d\n",
	       info->line, info->count);
#endif
	if (retval)
		return retval;
	info->flags |= ASYNC_NORMAL_ACTIVE;
	return 0;
}

/*
 * This routine is called whenever a serial port is opened.  It
 * enables interrupts for a serial port, linking in its async structure into
 * the IRQ chain.   It also performs the serial-specific
 * initialization for the tty structure.
 */
static int sab82532_open(struct tty_struct *tty, struct file * filp)
{
	struct sab82532	*info = sab82532_chain;
	int retval, line;
	unsigned long page;

#ifdef SERIAL_DEBUG_OPEN
	printk("sab82532_open: count = %d\n", info->count);
#endif
	line = MINOR(tty->device) - tty->driver.minor_start;
	if ((line < 0) || (line >= NR_PORTS))
		return -ENODEV;

	while (info) {
		if (info->line == line)
			break;
		info = info->next;
	}
	if (!info) {
		printk("sab82532_open: can't find info for line %d\n",
		       line);
		return -ENODEV;
	}

	info->count++;
	if (serial_paranoia_check(info, tty->device, "sab82532_open"))
		return -ENODEV;

#ifdef SERIAL_DEBUG_OPEN
	printk("sab82532_open %s%d, count = %d\n", tty->driver.name, info->line,
	       info->count);
#endif
	tty->driver_data = info;
	info->tty = tty;

	if (!tmp_buf) {
		page = get_free_page(GFP_KERNEL);
		if (!page)
			return -ENOMEM;
		if (tmp_buf)
			free_page(page);
		else
			tmp_buf = (unsigned char *) page;
	}
	
	/*
	 * Start up serial port
	 */
	retval = startup(info);
	if (retval)
		return retval;

	MOD_INC_USE_COUNT;
	retval = block_til_ready(tty, filp, info);
	if (retval) {
#ifdef SERIAL_DEBUG_OPEN
		printk("sab82532_open returning after block_til_ready with %d\n",
		       retval);
#endif
		return retval;
	}

	if ((info->count == 1) &&
	    (info->flags & ASYNC_SPLIT_TERMIOS)) {
		if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
			*tty->termios = info->normal_termios;
		else 
			*tty->termios = info->callout_termios;
		change_speed(info);
	}

	info->session = current->session;
	info->pgrp = current->pgrp;

#ifdef SERIAL_DEBUG_OPEN
	printk("sab82532_open ttys%d successful... count %d", info->line, info->count);
#endif
	return 0;
}

/*
 * /proc fs routines....
 */

static int inline line_info(char *buf, struct tty_struct *tty)
{
	struct sab82532 *info = (struct sab82532 *)tty->driver_data;
	int ret;

	ret = sprintf(buf, "%d: uart:SAB82532 ", info->line);
	switch (info->type) {
		case 0:
			ret += sprintf(buf+ret, "V1.0 ");
			break;
		case 1:
			ret += sprintf(buf+ret, "V2.0 ");
			break;
		case 2:
			ret += sprintf(buf+ret, "V3.2 ");
			break;
		default:
			ret += sprintf(buf+ret, "V?.? ");
			break;
	}
	ret += sprintf(buf+ret, "port:%lX irq:%d",
		       (unsigned long)info->regs, info->irq);

	if (!info->regs) {
		ret += sprintf(buf+ret, "\n");
		return ret;
	}

	/*
	 * Figure out the current RS-232 lines
	 */

	ret += sprintf(buf+ret, "\n");
	return ret;
}

int sab82532_read_proc(char *page, char **start, off_t off, int count,
		       int *eof, void *data)
{
	int i, len = 0;
	off_t	begin = 0;

	len += sprintf(page, "serinfo:1.0 driver:%s\n", "$Revision: 1.4 $");
	for (i = 0; i < NR_PORTS && len < 4000; i++) {
		len += line_info(page + len, sab82532_table[i]);
		if (len+begin > off+count)
			goto done;
		if (len+begin < off) {
			begin += len;
			len = 0;
		}
	}
	*eof = 1;
done:
	if (off >= len+begin)
		return 0;
	*start = page + (begin-off);
	return ((count < begin+len-off) ? count : begin+len-off);
}

/*
 * ---------------------------------------------------------------------
 * sab82532_init() and friends
 *
 * sab82532_init() is called at boot-time to initialize the serial driver.
 * ---------------------------------------------------------------------
 */
__initfunc(static int get_sab82532(void))
{
	struct linux_ebus *ebus;
	struct linux_ebus_device *edev;
	struct sab82532 *sab;
	unsigned long regs, offset;
	int i;

	for_all_ebusdev(edev, ebus)
		if (!strcmp(edev->prom_name, "se"))
			break;
	if (!edev)
		return -ENODEV;

	printk("%s: SAB82532 at 0x%lx IRQ %x\n", __FUNCTION__,
	       edev->base_address[0], edev->irqs[0]);

	regs = edev->base_address[0];
	offset = sizeof(union sab82532_async_regs);

	for (i = 0; i < 2; i++) {
		sab = (struct sab82532 *)kmalloc(sizeof(struct sab82532),
						 GFP_KERNEL);
		if (!sab) {
			printk("sab82532: can't alloc sab struct\n");
			break;
		}
		memset(sab, 0, sizeof(struct sab82532));

		sab->regs = (union sab82532_async_regs *)(regs + offset);
		sab->irq = edev->irqs[0];

		if (check_region((unsigned long)sab->regs,
				 sizeof(union sab82532_async_regs))) {
			kfree(sab);
			continue;
		}
		request_region((unsigned long)sab->regs,
			       sizeof(union sab82532_async_regs),
			       "serial(sab82532)");

		sab->regs->w.ipc = SAB82532_IPC_IC_ACT_LOW;

		sab->next = sab82532_chain;
		sab82532_chain = sab;

		offset -= sizeof(union sab82532_async_regs);
	}
	return 0;
}

/* Hooks for running a serial console. con_init() calls this if the
 * console is run over one of the ttya/ttyb serial ports.
 * 'chip' should be zero, as for now we only have one chip on board.
 * 'line' is decoded as 0=ttya, 1=ttyb.
 */
void
sab82532_cons_hook(int chip, int out, int line)
{
	prom_printf("sab82532: serial console is not implemented, yet\n");
	prom_halt();
}

void
sab82532_kgdb_hook(int line)
{
	prom_printf("sab82532: kgdb support is not implemented, yet\n");
	prom_halt();
}

__initfunc(static inline void show_serial_version(void))
{
	char *revision = "$Revision: 1.4 $";
	char *version, *p;

	version = strchr(revision, ' ');
	p = strchr(++version, ' ');
	*p = '\0';
	printk("SAB82532 serial driver version %s\n", version);
}

/*
 * The serial driver boot-time initialization code!
 */
__initfunc(int sab82532_init(void))
{
	struct sab82532 *info;
	int i;

	if (!sab82532_chain)
		get_sab82532();
	if (!sab82532_chain)
		return -ENODEV;

	init_bh(SERIAL_BH, do_serial_bh);

	show_serial_version();

	/* Initialize the tty_driver structure */
	memset(&serial_driver, 0, sizeof(struct tty_driver));
	serial_driver.magic = TTY_DRIVER_MAGIC;
	serial_driver.driver_name = "serial";
	serial_driver.name = "ttyS";
	serial_driver.major = TTY_MAJOR;
	serial_driver.minor_start = 64;
	serial_driver.num = NR_PORTS;
	serial_driver.type = TTY_DRIVER_TYPE_SERIAL;
	serial_driver.subtype = SERIAL_TYPE_NORMAL;
	serial_driver.init_termios = tty_std_termios;
	serial_driver.init_termios.c_cflag =
		B9600 | CS8 | CREAD | HUPCL | CLOCAL;
	serial_driver.flags = TTY_DRIVER_REAL_RAW;
	serial_driver.refcount = &sab82532_refcount;
	serial_driver.table = sab82532_table;
	serial_driver.termios = sab82532_termios;
	serial_driver.termios_locked = sab82532_termios_locked;

	serial_driver.open = sab82532_open;
	serial_driver.close = sab82532_close;
	serial_driver.write = sab82532_write;
	serial_driver.put_char = sab82532_put_char;
	serial_driver.flush_chars = sab82532_flush_chars;
	serial_driver.write_room = sab82532_write_room;
	serial_driver.chars_in_buffer = sab82532_chars_in_buffer;
	serial_driver.flush_buffer = sab82532_flush_buffer;
	serial_driver.ioctl = sab82532_ioctl;
	serial_driver.throttle = sab82532_throttle;
	serial_driver.unthrottle = sab82532_unthrottle;
	serial_driver.send_xchar = sab82532_send_xchar;
	serial_driver.set_termios = sab82532_set_termios;
	serial_driver.stop = sab82532_stop;
	serial_driver.start = sab82532_start;
	serial_driver.hangup = sab82532_hangup;
	serial_driver.wait_until_sent = sab82532_wait_until_sent;
	serial_driver.read_proc = sab82532_read_proc;

	/*
	 * The callout device is just like normal device except for
	 * major number and the subtype code.
	 */
	callout_driver = serial_driver;
	callout_driver.name = "cua";
	callout_driver.major = TTYAUX_MAJOR;
	callout_driver.subtype = SERIAL_TYPE_CALLOUT;
	callout_driver.read_proc = 0;
	callout_driver.proc_entry = 0;

	if (tty_register_driver(&serial_driver))
		panic("Couldn't register serial driver\n");
	if (tty_register_driver(&callout_driver))
		panic("Couldn't register callout driver\n");

	for (info = sab82532_chain, i = 0; info; info = info->next, i++) {
		info->magic = SERIAL_MAGIC;
		info->line = i;
		info->tty = 0;
		info->count = 0;

		info->type = info->regs->r.vstr & 0x0f;
		info->regs->w.pcr = ~((1 << 1) | (1 << 2) | (1 << 4));
		info->regs->w.pim = 0xff;
		if (info->line == 0) {
			info->pvr_dsr_bit = (1 << 0);
			info->pvr_dtr_bit = (1 << 1);
		} else {
			info->pvr_dsr_bit = (1 << 3);
			info->pvr_dtr_bit = (1 << 2);
		}
		info->regs->w.pvr = (1 << 1) | (1 << 2) | (1 << 4);
		info->regs->rw.mode |= SAB82532_MODE_FRTS;
		info->regs->rw.mode |= SAB82532_MODE_RTS;

		info->xmit_fifo_size = 32;
		info->recv_fifo_size = 32;
		info->custom_divisor = 16;
		info->close_delay = 5*HZ/10;
		info->closing_wait = 30*HZ;
		info->x_char = 0;
		info->event = 0;	
		info->count = 0;
		info->blocked_open = 0;
		info->tqueue.routine = do_softint;
		info->tqueue.data = info;
		info->tqueue_hangup.routine = do_serial_hangup;
		info->tqueue_hangup.data = info;
		info->callout_termios = callout_driver.init_termios;
		info->normal_termios = serial_driver.init_termios;
		info->open_wait = 0;
		info->close_wait = 0;
		info->delta_msr_wait = 0;
		info->icount.cts = info->icount.dsr = 
			info->icount.rng = info->icount.dcd = 0;
		info->icount.rx = info->icount.tx = 0;
		info->icount.frame = info->icount.parity = 0;
		info->icount.overrun = info->icount.brk = 0;

		if (!(info->line & 0x01)) {
			if (request_irq(info->irq, sab82532_interrupt, SA_SHIRQ,
					"serial(sab82532)", info)) {
				printk("sab82532: can't get IRQ %x\n",
				       info->irq);
				panic("sab82532 initialization failed");
			}
		}
	
		printk(KERN_INFO "ttyS%02d at 0x%lx (irq = %x) is a %s\n",
		       info->line, (unsigned long)info->regs, info->irq,
		       "SAB82532");
	}
	return 0;
}

__initfunc(int sab82532_probe(unsigned long *memory_start))
{
	int node, enode, snode;

        node = prom_getchild(prom_root_node);
	node = prom_searchsiblings(node, "pci");

	/*
	 * For each PCI bus...
	 */
	while (node) {
		enode = prom_getchild(node);
		enode = prom_searchsiblings(enode, "ebus");

		/*
		 * For each EBus on this PCI...
		 */
		while (enode) {
			snode = prom_getchild(enode);
			snode = prom_searchsiblings(snode, "se");
			if (snode)
				goto found;

			enode = prom_getsibling(enode);
			enode = prom_searchsiblings(enode, "ebus");
		}
		node = prom_getsibling(node);
		node = prom_searchsiblings(node, "pci");
	}
	return -ENODEV;

found:
	sunserial_setinitfunc(memory_start, sab82532_init);
	rs_ops.rs_cons_hook = sab82532_cons_hook;
	rs_ops.rs_kgdb_hook = sab82532_kgdb_hook;
	return 0;
}

#ifdef MODULE
int init_module(void)
{
	if (get_sab82532())
		return -ENODEV;

	return sab82532_init();
}

void cleanup_module(void) 
{
	unsigned long flags;
	int e1, e2;
	int i;

	/* printk("Unloading %s: version %s\n", serial_name, serial_version); */
	save_flags(flags);
	cli();
	timer_active &= ~(1 << RS_TIMER);
	timer_table[RS_TIMER].fn = NULL;
	timer_table[RS_TIMER].expires = 0;
        remove_bh(SERIAL_BH);
	if ((e1 = tty_unregister_driver(&serial_driver)))
		printk("SERIAL: failed to unregister serial driver (%d)\n",
		       e1);
	if ((e2 = tty_unregister_driver(&callout_driver)))
		printk("SERIAL: failed to unregister callout driver (%d)\n", 
		       e2);
	restore_flags(flags);

	for (i = 0; i < NR_PORTS; i++) {
		if (sab82532_table[i].type != PORT_UNKNOWN)
			release_region(sab82532_table[i].port, 8);
	}
	if (tmp_buf) {
		free_page((unsigned long) tmp_buf);
		tmp_buf = NULL;
	}
}
#endif /* MODULE */