1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Serial driver for the amiga builtin port.
   4 *
   5 * This code was created by taking serial.c version 4.30 from kernel
   6 * release 2.3.22, replacing all hardware related stuff with the
   7 * corresponding amiga hardware actions, and removing all irrelevant
   8 * code. As a consequence, it uses many of the constants and names
   9 * associated with the registers and bits of 16550 compatible UARTS -
  10 * but only to keep track of status, etc in the state variables. It
  11 * was done this was to make it easier to keep the code in line with
  12 * (non hardware specific) changes to serial.c.
  13 *
  14 * The port is registered with the tty driver as minor device 64, and
  15 * therefore other ports should should only use 65 upwards.
  16 *
  17 * Richard Lucock 28/12/99
  18 *
  19 *  Copyright (C) 1991, 1992  Linus Torvalds
  20 *  Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 
  21 * 		1998, 1999  Theodore Ts'o
  22 *
  23 */
  24
  25#include <linux/delay.h>
  26
  27/* Set of debugging defines */
  28
  29#undef SERIAL_DEBUG_INTR
  30#undef SERIAL_DEBUG_OPEN
  31#undef SERIAL_DEBUG_FLOW
  32#undef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
  33
  34/* Sanity checks */
  35
  36#if defined(MODULE) && defined(SERIAL_DEBUG_MCOUNT)
  37#define DBG_CNT(s) printk("(%s): [%x] refc=%d, serc=%d, ttyc=%d -> %s\n", \
  38 tty->name, (info->tport.flags), serial_driver->refcount,info->count,tty->count,s)
  39#else
  40#define DBG_CNT(s)
  41#endif
  42
  43/*
  44 * End of serial driver configuration section.
  45 */
  46
  47#include <linux/module.h>
  48
  49#include <linux/types.h>
  50#include <linux/serial.h>
  51#include <linux/serial_reg.h>
  52static char *serial_version = "4.30";
  53
  54#include <linux/errno.h>
  55#include <linux/signal.h>
  56#include <linux/sched.h>
  57#include <linux/kernel.h>
  58#include <linux/timer.h>
  59#include <linux/interrupt.h>
  60#include <linux/tty.h>
  61#include <linux/tty_flip.h>
  62#include <linux/circ_buf.h>
  63#include <linux/console.h>
  64#include <linux/major.h>
  65#include <linux/string.h>
  66#include <linux/fcntl.h>
  67#include <linux/ptrace.h>
  68#include <linux/ioport.h>
  69#include <linux/mm.h>
  70#include <linux/seq_file.h>
  71#include <linux/slab.h>
  72#include <linux/init.h>
  73#include <linux/bitops.h>
  74#include <linux/platform_device.h>
  75
  76#include <asm/setup.h>
  77
  78
  79#include <asm/irq.h>
  80
  81#include <asm/amigahw.h>
  82#include <asm/amigaints.h>
  83
  84struct serial_state {
  85	struct tty_port		tport;
  86	struct circ_buf		xmit;
  87	struct async_icount	icount;
  88
  89	unsigned long		port;
  90	int			baud_base;
  91	int			xmit_fifo_size;
  92	int			custom_divisor;
  93	int			read_status_mask;
  94	int			ignore_status_mask;
  95	int			timeout;
  96	int			quot;
  97	int			IER; 	/* Interrupt Enable Register */
  98	int			MCR; 	/* Modem control register */
  99	int			x_char;	/* xon/xoff character */
 100};
 101
 102#define custom amiga_custom
 103static char *serial_name = "Amiga-builtin serial driver";
 104
 105static struct tty_driver *serial_driver;
 106
 107/* number of characters left in xmit buffer before we ask for more */
 108#define WAKEUP_CHARS 256
 109
 110static unsigned char current_ctl_bits;
 111
 112static void change_speed(struct tty_struct *tty, struct serial_state *info,
 113		struct ktermios *old);
 114static void rs_wait_until_sent(struct tty_struct *tty, int timeout);
 115
 116
 117static struct serial_state rs_table[1];
 118
 119#define NR_PORTS ARRAY_SIZE(rs_table)
 120
 121#include <linux/uaccess.h>
 122
 123#define serial_isroot()	(capable(CAP_SYS_ADMIN))
 124
 125/* some serial hardware definitions */
 126#define SDR_OVRUN   (1<<15)
 127#define SDR_RBF     (1<<14)
 128#define SDR_TBE     (1<<13)
 129#define SDR_TSRE    (1<<12)
 130
 131#define SERPER_PARENB    (1<<15)
 132
 133#define AC_SETCLR   (1<<15)
 134#define AC_UARTBRK  (1<<11)
 135
 136#define SER_DTR     (1<<7)
 137#define SER_RTS     (1<<6)
 138#define SER_DCD     (1<<5)
 139#define SER_CTS     (1<<4)
 140#define SER_DSR     (1<<3)
 141
 142static __inline__ void rtsdtr_ctrl(int bits)
 143{
 144    ciab.pra = ((bits & (SER_RTS | SER_DTR)) ^ (SER_RTS | SER_DTR)) | (ciab.pra & ~(SER_RTS | SER_DTR));
 145}
 146
 147/*
 148 * ------------------------------------------------------------
 149 * rs_stop() and rs_start()
 150 *
 151 * This routines are called before setting or resetting tty->stopped.
 152 * They enable or disable transmitter interrupts, as necessary.
 153 * ------------------------------------------------------------
 154 */
 155static void rs_stop(struct tty_struct *tty)
 156{
 157	struct serial_state *info = tty->driver_data;
 158	unsigned long flags;
 159
 160	local_irq_save(flags);
 161	if (info->IER & UART_IER_THRI) {
 162		info->IER &= ~UART_IER_THRI;
 163		/* disable Tx interrupt and remove any pending interrupts */
 164		custom.intena = IF_TBE;
 165		mb();
 166		custom.intreq = IF_TBE;
 167		mb();
 168	}
 169	local_irq_restore(flags);
 170}
 171
 172static void rs_start(struct tty_struct *tty)
 173{
 174	struct serial_state *info = tty->driver_data;
 175	unsigned long flags;
 176
 177	local_irq_save(flags);
 178	if (info->xmit.head != info->xmit.tail
 179	    && info->xmit.buf
 180	    && !(info->IER & UART_IER_THRI)) {
 181		info->IER |= UART_IER_THRI;
 182		custom.intena = IF_SETCLR | IF_TBE;
 183		mb();
 184		/* set a pending Tx Interrupt, transmitter should restart now */
 185		custom.intreq = IF_SETCLR | IF_TBE;
 186		mb();
 187	}
 188	local_irq_restore(flags);
 189}
 190
 191/*
 192 * ----------------------------------------------------------------------
 193 *
 194 * Here starts the interrupt handling routines.  All of the following
 195 * subroutines are declared as inline and are folded into
 196 * rs_interrupt().  They were separated out for readability's sake.
 197 *
 198 * Note: rs_interrupt() is a "fast" interrupt, which means that it
 199 * runs with interrupts turned off.  People who may want to modify
 200 * rs_interrupt() should try to keep the interrupt handler as fast as
 201 * possible.  After you are done making modifications, it is not a bad
 202 * idea to do:
 203 * 
 204 * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
 205 *
 206 * and look at the resulting assemble code in serial.s.
 207 *
 208 * 				- Ted Ts'o (tytso@mit.edu), 7-Mar-93
 209 * -----------------------------------------------------------------------
 210 */
 211
 212static void receive_chars(struct serial_state *info)
 213{
 214        int status;
 215	int serdatr;
 216	unsigned char ch, flag;
 217	struct	async_icount *icount;
 218	int oe = 0;
 219
 220	icount = &info->icount;
 221
 222	status = UART_LSR_DR; /* We obviously have a character! */
 223	serdatr = custom.serdatr;
 224	mb();
 225	custom.intreq = IF_RBF;
 226	mb();
 227
 228	if((serdatr & 0x1ff) == 0)
 229	    status |= UART_LSR_BI;
 230	if(serdatr & SDR_OVRUN)
 231	    status |= UART_LSR_OE;
 232
 233	ch = serdatr & 0xff;
 234	icount->rx++;
 235
 236#ifdef SERIAL_DEBUG_INTR
 237	printk("DR%02x:%02x...", ch, status);
 238#endif
 239	flag = TTY_NORMAL;
 240
 241	/*
 242	 * We don't handle parity or frame errors - but I have left
 243	 * the code in, since I'm not sure that the errors can't be
 244	 * detected.
 245	 */
 246
 247	if (status & (UART_LSR_BI | UART_LSR_PE |
 248		      UART_LSR_FE | UART_LSR_OE)) {
 249	  /*
 250	   * For statistics only
 251	   */
 252	  if (status & UART_LSR_BI) {
 253	    status &= ~(UART_LSR_FE | UART_LSR_PE);
 254	    icount->brk++;
 255	  } else if (status & UART_LSR_PE)
 256	    icount->parity++;
 257	  else if (status & UART_LSR_FE)
 258	    icount->frame++;
 259	  if (status & UART_LSR_OE)
 260	    icount->overrun++;
 261
 262	  /*
 263	   * Now check to see if character should be
 264	   * ignored, and mask off conditions which
 265	   * should be ignored.
 266	   */
 267	  if (status & info->ignore_status_mask)
 268	    goto out;
 269
 270	  status &= info->read_status_mask;
 271
 272	  if (status & (UART_LSR_BI)) {
 273#ifdef SERIAL_DEBUG_INTR
 274	    printk("handling break....");
 275#endif
 276	    flag = TTY_BREAK;
 277	    if (info->tport.flags & ASYNC_SAK)
 278	      do_SAK(info->tport.tty);
 279	  } else if (status & UART_LSR_PE)
 280	    flag = TTY_PARITY;
 281	  else if (status & UART_LSR_FE)
 282	    flag = TTY_FRAME;
 283	  if (status & UART_LSR_OE) {
 284	    /*
 285	     * Overrun is special, since it's
 286	     * reported immediately, and doesn't
 287	     * affect the current character
 288	     */
 289	     oe = 1;
 290	  }
 291	}
 292	tty_insert_flip_char(&info->tport, ch, flag);
 293	if (oe == 1)
 294		tty_insert_flip_char(&info->tport, 0, TTY_OVERRUN);
 295	tty_flip_buffer_push(&info->tport);
 296out:
 297	return;
 298}
 299
 300static void transmit_chars(struct serial_state *info)
 301{
 302	custom.intreq = IF_TBE;
 303	mb();
 304	if (info->x_char) {
 305	        custom.serdat = info->x_char | 0x100;
 306		mb();
 307		info->icount.tx++;
 308		info->x_char = 0;
 309		return;
 310	}
 311	if (info->xmit.head == info->xmit.tail
 312	    || info->tport.tty->stopped
 313	    || info->tport.tty->hw_stopped) {
 314		info->IER &= ~UART_IER_THRI;
 315	        custom.intena = IF_TBE;
 316		mb();
 317		return;
 318	}
 319
 320	custom.serdat = info->xmit.buf[info->xmit.tail++] | 0x100;
 321	mb();
 322	info->xmit.tail = info->xmit.tail & (SERIAL_XMIT_SIZE-1);
 323	info->icount.tx++;
 324
 325	if (CIRC_CNT(info->xmit.head,
 326		     info->xmit.tail,
 327		     SERIAL_XMIT_SIZE) < WAKEUP_CHARS)
 328		tty_wakeup(info->tport.tty);
 329
 330#ifdef SERIAL_DEBUG_INTR
 331	printk("THRE...");
 332#endif
 333	if (info->xmit.head == info->xmit.tail) {
 334	        custom.intena = IF_TBE;
 335		mb();
 336		info->IER &= ~UART_IER_THRI;
 337	}
 338}
 339
 340static void check_modem_status(struct serial_state *info)
 341{
 342	struct tty_port *port = &info->tport;
 343	unsigned char status = ciab.pra & (SER_DCD | SER_CTS | SER_DSR);
 344	unsigned char dstatus;
 345	struct	async_icount *icount;
 346
 347	/* Determine bits that have changed */
 348	dstatus = status ^ current_ctl_bits;
 349	current_ctl_bits = status;
 350
 351	if (dstatus) {
 352		icount = &info->icount;
 353		/* update input line counters */
 354		if (dstatus & SER_DSR)
 355			icount->dsr++;
 356		if (dstatus & SER_DCD) {
 357			icount->dcd++;
 358		}
 359		if (dstatus & SER_CTS)
 360			icount->cts++;
 361		wake_up_interruptible(&port->delta_msr_wait);
 362	}
 363
 364	if (tty_port_check_carrier(port) && (dstatus & SER_DCD)) {
 365#if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR))
 366		printk("ttyS%d CD now %s...", info->line,
 367		       (!(status & SER_DCD)) ? "on" : "off");
 368#endif
 369		if (!(status & SER_DCD))
 370			wake_up_interruptible(&port->open_wait);
 371		else {
 372#ifdef SERIAL_DEBUG_OPEN
 373			printk("doing serial hangup...");
 374#endif
 375			if (port->tty)
 376				tty_hangup(port->tty);
 377		}
 378	}
 379	if (tty_port_cts_enabled(port)) {
 380		if (port->tty->hw_stopped) {
 381			if (!(status & SER_CTS)) {
 382#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
 383				printk("CTS tx start...");
 384#endif
 385				port->tty->hw_stopped = 0;
 386				info->IER |= UART_IER_THRI;
 387				custom.intena = IF_SETCLR | IF_TBE;
 388				mb();
 389				/* set a pending Tx Interrupt, transmitter should restart now */
 390				custom.intreq = IF_SETCLR | IF_TBE;
 391				mb();
 392				tty_wakeup(port->tty);
 393				return;
 394			}
 395		} else {
 396			if ((status & SER_CTS)) {
 397#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
 398				printk("CTS tx stop...");
 399#endif
 400				port->tty->hw_stopped = 1;
 401				info->IER &= ~UART_IER_THRI;
 402				/* disable Tx interrupt and remove any pending interrupts */
 403				custom.intena = IF_TBE;
 404				mb();
 405				custom.intreq = IF_TBE;
 406				mb();
 407			}
 408		}
 409	}
 410}
 411
 412static irqreturn_t ser_vbl_int( int irq, void *data)
 413{
 414        /* vbl is just a periodic interrupt we tie into to update modem status */
 415	struct serial_state *info = data;
 416	/*
 417	 * TBD - is it better to unregister from this interrupt or to
 418	 * ignore it if MSI is clear ?
 419	 */
 420	if(info->IER & UART_IER_MSI)
 421	  check_modem_status(info);
 422	return IRQ_HANDLED;
 423}
 424
 425static irqreturn_t ser_rx_int(int irq, void *dev_id)
 426{
 427	struct serial_state *info = dev_id;
 428
 429#ifdef SERIAL_DEBUG_INTR
 430	printk("ser_rx_int...");
 431#endif
 432
 433	if (!info->tport.tty)
 434		return IRQ_NONE;
 435
 436	receive_chars(info);
 437#ifdef SERIAL_DEBUG_INTR
 438	printk("end.\n");
 439#endif
 440	return IRQ_HANDLED;
 441}
 442
 443static irqreturn_t ser_tx_int(int irq, void *dev_id)
 444{
 445	struct serial_state *info = dev_id;
 446
 447	if (custom.serdatr & SDR_TBE) {
 448#ifdef SERIAL_DEBUG_INTR
 449	  printk("ser_tx_int...");
 450#endif
 451
 452	  if (!info->tport.tty)
 453		return IRQ_NONE;
 454
 455	  transmit_chars(info);
 456#ifdef SERIAL_DEBUG_INTR
 457	  printk("end.\n");
 458#endif
 459	}
 460	return IRQ_HANDLED;
 461}
 462
 463/*
 464 * -------------------------------------------------------------------
 465 * Here ends the serial interrupt routines.
 466 * -------------------------------------------------------------------
 467 */
 468
 469/*
 470 * ---------------------------------------------------------------
 471 * Low level utility subroutines for the serial driver:  routines to
 472 * figure out the appropriate timeout for an interrupt chain, routines
 473 * to initialize and startup a serial port, and routines to shutdown a
 474 * serial port.  Useful stuff like that.
 475 * ---------------------------------------------------------------
 476 */
 477
 478static int startup(struct tty_struct *tty, struct serial_state *info)
 479{
 480	struct tty_port *port = &info->tport;
 481	unsigned long flags;
 482	int	retval=0;
 483	unsigned long page;
 484
 485	page = get_zeroed_page(GFP_KERNEL);
 486	if (!page)
 487		return -ENOMEM;
 488
 489	local_irq_save(flags);
 490
 491	if (tty_port_initialized(port)) {
 492		free_page(page);
 493		goto errout;
 494	}
 495
 496	if (info->xmit.buf)
 497		free_page(page);
 498	else
 499		info->xmit.buf = (unsigned char *) page;
 500
 501#ifdef SERIAL_DEBUG_OPEN
 502	printk("starting up ttys%d ...", info->line);
 503#endif
 504
 505	/* Clear anything in the input buffer */
 506
 507	custom.intreq = IF_RBF;
 508	mb();
 509
 510	retval = request_irq(IRQ_AMIGA_VERTB, ser_vbl_int, 0, "serial status", info);
 511	if (retval) {
 512	  if (serial_isroot()) {
 513	      set_bit(TTY_IO_ERROR, &tty->flags);
 514	    retval = 0;
 515	  }
 516	  goto errout;
 517	}
 518
 519	/* enable both Rx and Tx interrupts */
 520	custom.intena = IF_SETCLR | IF_RBF | IF_TBE;
 521	mb();
 522	info->IER = UART_IER_MSI;
 523
 524	/* remember current state of the DCD and CTS bits */
 525	current_ctl_bits = ciab.pra & (SER_DCD | SER_CTS | SER_DSR);
 526
 527	info->MCR = 0;
 528	if (C_BAUD(tty))
 529	  info->MCR = SER_DTR | SER_RTS;
 530	rtsdtr_ctrl(info->MCR);
 531
 532	clear_bit(TTY_IO_ERROR, &tty->flags);
 533	info->xmit.head = info->xmit.tail = 0;
 534
 535	/*
 536	 * and set the speed of the serial port
 537	 */
 538	change_speed(tty, info, NULL);
 539
 540	tty_port_set_initialized(port, 1);
 541	local_irq_restore(flags);
 542	return 0;
 543
 544errout:
 545	local_irq_restore(flags);
 546	return retval;
 547}
 548
 549/*
 550 * This routine will shutdown a serial port; interrupts are disabled, and
 551 * DTR is dropped if the hangup on close termio flag is on.
 552 */
 553static void shutdown(struct tty_struct *tty, struct serial_state *info)
 554{
 555	unsigned long	flags;
 556	struct serial_state *state;
 557
 558	if (!tty_port_initialized(&info->tport))
 559		return;
 560
 561	state = info;
 562
 563#ifdef SERIAL_DEBUG_OPEN
 564	printk("Shutting down serial port %d ....\n", info->line);
 565#endif
 566
 567	local_irq_save(flags); /* Disable interrupts */
 568
 569	/*
 570	 * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
 571	 * here so the queue might never be waken up
 572	 */
 573	wake_up_interruptible(&info->tport.delta_msr_wait);
 574
 575	/*
 576	 * Free the IRQ, if necessary
 577	 */
 578	free_irq(IRQ_AMIGA_VERTB, info);
 579
 580	if (info->xmit.buf) {
 581		free_page((unsigned long) info->xmit.buf);
 582		info->xmit.buf = NULL;
 583	}
 584
 585	info->IER = 0;
 586	custom.intena = IF_RBF | IF_TBE;
 587	mb();
 588
 589	/* disable break condition */
 590	custom.adkcon = AC_UARTBRK;
 591	mb();
 592
 593	if (C_HUPCL(tty))
 594		info->MCR &= ~(SER_DTR|SER_RTS);
 595	rtsdtr_ctrl(info->MCR);
 596
 597	set_bit(TTY_IO_ERROR, &tty->flags);
 598
 599	tty_port_set_initialized(&info->tport, 0);
 600	local_irq_restore(flags);
 601}
 602
 603
 604/*
 605 * This routine is called to set the UART divisor registers to match
 606 * the specified baud rate for a serial port.
 607 */
 608static void change_speed(struct tty_struct *tty, struct serial_state *info,
 609			 struct ktermios *old_termios)
 610{
 611	struct tty_port *port = &info->tport;
 612	int	quot = 0, baud_base, baud;
 613	unsigned cflag, cval = 0;
 614	int	bits;
 615	unsigned long	flags;
 616
 617	cflag = tty->termios.c_cflag;
 618
 619	/* Byte size is always 8 bits plus parity bit if requested */
 620
 621	cval = 3; bits = 10;
 622	if (cflag & CSTOPB) {
 623		cval |= 0x04;
 624		bits++;
 625	}
 626	if (cflag & PARENB) {
 627		cval |= UART_LCR_PARITY;
 628		bits++;
 629	}
 630	if (!(cflag & PARODD))
 631		cval |= UART_LCR_EPAR;
 632#ifdef CMSPAR
 633	if (cflag & CMSPAR)
 634		cval |= UART_LCR_SPAR;
 635#endif
 636
 637	/* Determine divisor based on baud rate */
 638	baud = tty_get_baud_rate(tty);
 639	if (!baud)
 640		baud = 9600;	/* B0 transition handled in rs_set_termios */
 641	baud_base = info->baud_base;
 642	if (baud == 38400 && (port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
 643		quot = info->custom_divisor;
 644	else {
 645		if (baud == 134)
 646			/* Special case since 134 is really 134.5 */
 647			quot = (2*baud_base / 269);
 648		else if (baud)
 649			quot = baud_base / baud;
 650	}
 651	/* If the quotient is zero refuse the change */
 652	if (!quot && old_termios) {
 653		/* FIXME: Will need updating for new tty in the end */
 654		tty->termios.c_cflag &= ~CBAUD;
 655		tty->termios.c_cflag |= (old_termios->c_cflag & CBAUD);
 656		baud = tty_get_baud_rate(tty);
 657		if (!baud)
 658			baud = 9600;
 659		if (baud == 38400 &&
 660		    (port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
 661			quot = info->custom_divisor;
 662		else {
 663			if (baud == 134)
 664				/* Special case since 134 is really 134.5 */
 665				quot = (2*baud_base / 269);
 666			else if (baud)
 667				quot = baud_base / baud;
 668		}
 669	}
 670	/* As a last resort, if the quotient is zero, default to 9600 bps */
 671	if (!quot)
 672		quot = baud_base / 9600;
 673	info->quot = quot;
 674	info->timeout = ((info->xmit_fifo_size*HZ*bits*quot) / baud_base);
 675	info->timeout += HZ/50;		/* Add .02 seconds of slop */
 676
 677	/* CTS flow control flag and modem status interrupts */
 678	info->IER &= ~UART_IER_MSI;
 679	if (port->flags & ASYNC_HARDPPS_CD)
 680		info->IER |= UART_IER_MSI;
 681	tty_port_set_cts_flow(port, cflag & CRTSCTS);
 682	if (cflag & CRTSCTS)
 683		info->IER |= UART_IER_MSI;
 684	tty_port_set_check_carrier(port, ~cflag & CLOCAL);
 685	if (~cflag & CLOCAL)
 686		info->IER |= UART_IER_MSI;
 687	/* TBD:
 688	 * Does clearing IER_MSI imply that we should disable the VBL interrupt ?
 689	 */
 690
 691	/*
 692	 * Set up parity check flag
 693	 */
 694
 695	info->read_status_mask = UART_LSR_OE | UART_LSR_DR;
 696	if (I_INPCK(tty))
 697		info->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
 698	if (I_BRKINT(tty) || I_PARMRK(tty))
 699		info->read_status_mask |= UART_LSR_BI;
 700
 701	/*
 702	 * Characters to ignore
 703	 */
 704	info->ignore_status_mask = 0;
 705	if (I_IGNPAR(tty))
 706		info->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
 707	if (I_IGNBRK(tty)) {
 708		info->ignore_status_mask |= UART_LSR_BI;
 709		/*
 710		 * If we're ignore parity and break indicators, ignore 
 711		 * overruns too.  (For real raw support).
 712		 */
 713		if (I_IGNPAR(tty))
 714			info->ignore_status_mask |= UART_LSR_OE;
 715	}
 716	/*
 717	 * !!! ignore all characters if CREAD is not set
 718	 */
 719	if ((cflag & CREAD) == 0)
 720		info->ignore_status_mask |= UART_LSR_DR;
 721	local_irq_save(flags);
 722
 723	{
 724	  short serper;
 725
 726	/* Set up the baud rate */
 727	  serper = quot - 1;
 728
 729	/* Enable or disable parity bit */
 730
 731	if(cval & UART_LCR_PARITY)
 732	  serper |= (SERPER_PARENB);
 733
 734	custom.serper = serper;
 735	mb();
 736	}
 737
 738	local_irq_restore(flags);
 739}
 740
 741static int rs_put_char(struct tty_struct *tty, unsigned char ch)
 742{
 743	struct serial_state *info;
 744	unsigned long flags;
 745
 746	info = tty->driver_data;
 747
 748	if (!info->xmit.buf)
 749		return 0;
 750
 751	local_irq_save(flags);
 752	if (CIRC_SPACE(info->xmit.head,
 753		       info->xmit.tail,
 754		       SERIAL_XMIT_SIZE) == 0) {
 755		local_irq_restore(flags);
 756		return 0;
 757	}
 758
 759	info->xmit.buf[info->xmit.head++] = ch;
 760	info->xmit.head &= SERIAL_XMIT_SIZE-1;
 761	local_irq_restore(flags);
 762	return 1;
 763}
 764
 765static void rs_flush_chars(struct tty_struct *tty)
 766{
 767	struct serial_state *info = tty->driver_data;
 768	unsigned long flags;
 769
 770	if (info->xmit.head == info->xmit.tail
 771	    || tty->stopped
 772	    || tty->hw_stopped
 773	    || !info->xmit.buf)
 774		return;
 775
 776	local_irq_save(flags);
 777	info->IER |= UART_IER_THRI;
 778	custom.intena = IF_SETCLR | IF_TBE;
 779	mb();
 780	/* set a pending Tx Interrupt, transmitter should restart now */
 781	custom.intreq = IF_SETCLR | IF_TBE;
 782	mb();
 783	local_irq_restore(flags);
 784}
 785
 786static int rs_write(struct tty_struct * tty, const unsigned char *buf, int count)
 787{
 788	int	c, ret = 0;
 789	struct serial_state *info = tty->driver_data;
 790	unsigned long flags;
 791
 792	if (!info->xmit.buf)
 793		return 0;
 794
 795	local_irq_save(flags);
 796	while (1) {
 797		c = CIRC_SPACE_TO_END(info->xmit.head,
 798				      info->xmit.tail,
 799				      SERIAL_XMIT_SIZE);
 800		if (count < c)
 801			c = count;
 802		if (c <= 0) {
 803			break;
 804		}
 805		memcpy(info->xmit.buf + info->xmit.head, buf, c);
 806		info->xmit.head = ((info->xmit.head + c) &
 807				   (SERIAL_XMIT_SIZE-1));
 808		buf += c;
 809		count -= c;
 810		ret += c;
 811	}
 812	local_irq_restore(flags);
 813
 814	if (info->xmit.head != info->xmit.tail
 815	    && !tty->stopped
 816	    && !tty->hw_stopped
 817	    && !(info->IER & UART_IER_THRI)) {
 818		info->IER |= UART_IER_THRI;
 819		local_irq_disable();
 820		custom.intena = IF_SETCLR | IF_TBE;
 821		mb();
 822		/* set a pending Tx Interrupt, transmitter should restart now */
 823		custom.intreq = IF_SETCLR | IF_TBE;
 824		mb();
 825		local_irq_restore(flags);
 826	}
 827	return ret;
 828}
 829
 830static int rs_write_room(struct tty_struct *tty)
 831{
 832	struct serial_state *info = tty->driver_data;
 833
 834	return CIRC_SPACE(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
 835}
 836
 837static int rs_chars_in_buffer(struct tty_struct *tty)
 838{
 839	struct serial_state *info = tty->driver_data;
 840
 841	return CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
 842}
 843
 844static void rs_flush_buffer(struct tty_struct *tty)
 845{
 846	struct serial_state *info = tty->driver_data;
 847	unsigned long flags;
 848
 849	local_irq_save(flags);
 850	info->xmit.head = info->xmit.tail = 0;
 851	local_irq_restore(flags);
 852	tty_wakeup(tty);
 853}
 854
 855/*
 856 * This function is used to send a high-priority XON/XOFF character to
 857 * the device
 858 */
 859static void rs_send_xchar(struct tty_struct *tty, char ch)
 860{
 861	struct serial_state *info = tty->driver_data;
 862        unsigned long flags;
 863
 864	info->x_char = ch;
 865	if (ch) {
 866		/* Make sure transmit interrupts are on */
 867
 868	        /* Check this ! */
 869	        local_irq_save(flags);
 870		if(!(custom.intenar & IF_TBE)) {
 871		    custom.intena = IF_SETCLR | IF_TBE;
 872		    mb();
 873		    /* set a pending Tx Interrupt, transmitter should restart now */
 874		    custom.intreq = IF_SETCLR | IF_TBE;
 875		    mb();
 876		}
 877		local_irq_restore(flags);
 878
 879		info->IER |= UART_IER_THRI;
 880	}
 881}
 882
 883/*
 884 * ------------------------------------------------------------
 885 * rs_throttle()
 886 * 
 887 * This routine is called by the upper-layer tty layer to signal that
 888 * incoming characters should be throttled.
 889 * ------------------------------------------------------------
 890 */
 891static void rs_throttle(struct tty_struct * tty)
 892{
 893	struct serial_state *info = tty->driver_data;
 894	unsigned long flags;
 895#ifdef SERIAL_DEBUG_THROTTLE
 896	printk("throttle %s ....\n", tty_name(tty));
 897#endif
 898
 899	if (I_IXOFF(tty))
 900		rs_send_xchar(tty, STOP_CHAR(tty));
 901
 902	if (C_CRTSCTS(tty))
 903		info->MCR &= ~SER_RTS;
 904
 905	local_irq_save(flags);
 906	rtsdtr_ctrl(info->MCR);
 907	local_irq_restore(flags);
 908}
 909
 910static void rs_unthrottle(struct tty_struct * tty)
 911{
 912	struct serial_state *info = tty->driver_data;
 913	unsigned long flags;
 914#ifdef SERIAL_DEBUG_THROTTLE
 915	printk("unthrottle %s ....\n", tty_name(tty));
 916#endif
 917
 918	if (I_IXOFF(tty)) {
 919		if (info->x_char)
 920			info->x_char = 0;
 921		else
 922			rs_send_xchar(tty, START_CHAR(tty));
 923	}
 924	if (C_CRTSCTS(tty))
 925		info->MCR |= SER_RTS;
 926	local_irq_save(flags);
 927	rtsdtr_ctrl(info->MCR);
 928	local_irq_restore(flags);
 929}
 930
 931/*
 932 * ------------------------------------------------------------
 933 * rs_ioctl() and friends
 934 * ------------------------------------------------------------
 935 */
 936
 937static int get_serial_info(struct tty_struct *tty, struct serial_struct *ss)
 938{
 939	struct serial_state *state = tty->driver_data;
 
 940
 941	tty_lock(tty);
 
 
 
 
 
 942	ss->line = tty->index;
 943	ss->port = state->port;
 944	ss->flags = state->tport.flags;
 945	ss->xmit_fifo_size = state->xmit_fifo_size;
 946	ss->baud_base = state->baud_base;
 947	ss->close_delay = state->tport.close_delay;
 948	ss->closing_wait = state->tport.closing_wait;
 949	ss->custom_divisor = state->custom_divisor;
 950	tty_unlock(tty);
 951	return 0;
 952}
 953
 954static int set_serial_info(struct tty_struct *tty, struct serial_struct *ss)
 955{
 956	struct serial_state *state = tty->driver_data;
 957	struct tty_port *port = &state->tport;
 958	bool change_spd;
 959	int 			retval = 0;
 
 960
 961	tty_lock(tty);
 962	change_spd = ((ss->flags ^ port->flags) & ASYNC_SPD_MASK) ||
 963		ss->custom_divisor != state->custom_divisor;
 964	if (ss->irq || ss->port != state->port ||
 965			ss->xmit_fifo_size != state->xmit_fifo_size) {
 966		tty_unlock(tty);
 967		return -EINVAL;
 968	}
 969  
 
 
 
 
 
 970	if (!serial_isroot()) {
 971		if ((ss->baud_base != state->baud_base) ||
 972		    (ss->close_delay != port->close_delay) ||
 
 973		    (ss->xmit_fifo_size != state->xmit_fifo_size) ||
 974		    ((ss->flags & ~ASYNC_USR_MASK) !=
 975		     (port->flags & ~ASYNC_USR_MASK))) {
 976			tty_unlock(tty);
 977			return -EPERM;
 978		}
 979		port->flags = ((port->flags & ~ASYNC_USR_MASK) |
 980			       (ss->flags & ASYNC_USR_MASK));
 981		state->custom_divisor = ss->custom_divisor;
 982		goto check_and_exit;
 983	}
 984
 985	if (ss->baud_base < 9600) {
 986		tty_unlock(tty);
 987		return -EINVAL;
 988	}
 989
 990	/*
 991	 * OK, past this point, all the error checking has been done.
 992	 * At this point, we start making changes.....
 993	 */
 994
 995	state->baud_base = ss->baud_base;
 996	port->flags = ((port->flags & ~ASYNC_FLAGS) |
 997			(ss->flags & ASYNC_FLAGS));
 998	state->custom_divisor = ss->custom_divisor;
 999	port->close_delay = ss->close_delay * HZ/100;
1000	port->closing_wait = ss->closing_wait * HZ/100;
1001	port->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
1002
1003check_and_exit:
1004	if (tty_port_initialized(port)) {
1005		if (change_spd) {
1006			/* warn about deprecation unless clearing */
1007			if (ss->flags & ASYNC_SPD_MASK)
1008				dev_warn_ratelimited(tty->dev, "use of SPD flags is deprecated\n");
1009			change_speed(tty, state, NULL);
1010		}
1011	} else
1012		retval = startup(tty, state);
1013	tty_unlock(tty);
1014	return retval;
1015}
1016
1017/*
1018 * get_lsr_info - get line status register info
1019 *
1020 * Purpose: Let user call ioctl() to get info when the UART physically
1021 * 	    is emptied.  On bus types like RS485, the transmitter must
1022 * 	    release the bus after transmitting. This must be done when
1023 * 	    the transmit shift register is empty, not be done when the
1024 * 	    transmit holding register is empty.  This functionality
1025 * 	    allows an RS485 driver to be written in user space. 
1026 */
1027static int get_lsr_info(struct serial_state *info, unsigned int __user *value)
1028{
1029	unsigned char status;
1030	unsigned int result;
1031	unsigned long flags;
1032
1033	local_irq_save(flags);
1034	status = custom.serdatr;
1035	mb();
1036	local_irq_restore(flags);
1037	result = ((status & SDR_TSRE) ? TIOCSER_TEMT : 0);
1038	if (copy_to_user(value, &result, sizeof(int)))
1039		return -EFAULT;
1040	return 0;
1041}
1042
1043
1044static int rs_tiocmget(struct tty_struct *tty)
1045{
1046	struct serial_state *info = tty->driver_data;
1047	unsigned char control, status;
1048	unsigned long flags;
1049
1050	if (tty_io_error(tty))
1051		return -EIO;
1052
1053	control = info->MCR;
1054	local_irq_save(flags);
1055	status = ciab.pra;
1056	local_irq_restore(flags);
1057	return    ((control & SER_RTS) ? TIOCM_RTS : 0)
1058		| ((control & SER_DTR) ? TIOCM_DTR : 0)
1059		| (!(status  & SER_DCD) ? TIOCM_CAR : 0)
1060		| (!(status  & SER_DSR) ? TIOCM_DSR : 0)
1061		| (!(status  & SER_CTS) ? TIOCM_CTS : 0);
1062}
1063
1064static int rs_tiocmset(struct tty_struct *tty, unsigned int set,
1065						unsigned int clear)
1066{
1067	struct serial_state *info = tty->driver_data;
1068	unsigned long flags;
1069
1070	if (tty_io_error(tty))
1071		return -EIO;
1072
1073	local_irq_save(flags);
1074	if (set & TIOCM_RTS)
1075		info->MCR |= SER_RTS;
1076	if (set & TIOCM_DTR)
1077		info->MCR |= SER_DTR;
1078	if (clear & TIOCM_RTS)
1079		info->MCR &= ~SER_RTS;
1080	if (clear & TIOCM_DTR)
1081		info->MCR &= ~SER_DTR;
1082	rtsdtr_ctrl(info->MCR);
1083	local_irq_restore(flags);
1084	return 0;
1085}
1086
1087/*
1088 * rs_break() --- routine which turns the break handling on or off
1089 */
1090static int rs_break(struct tty_struct *tty, int break_state)
1091{
1092	unsigned long flags;
1093
1094	local_irq_save(flags);
1095	if (break_state == -1)
1096	  custom.adkcon = AC_SETCLR | AC_UARTBRK;
1097	else
1098	  custom.adkcon = AC_UARTBRK;
1099	mb();
1100	local_irq_restore(flags);
1101	return 0;
1102}
1103
1104/*
1105 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1106 * Return: write counters to the user passed counter struct
1107 * NB: both 1->0 and 0->1 transitions are counted except for
1108 *     RI where only 0->1 is counted.
1109 */
1110static int rs_get_icount(struct tty_struct *tty,
1111				struct serial_icounter_struct *icount)
1112{
1113	struct serial_state *info = tty->driver_data;
1114	struct async_icount cnow;
1115	unsigned long flags;
1116
1117	local_irq_save(flags);
1118	cnow = info->icount;
1119	local_irq_restore(flags);
1120	icount->cts = cnow.cts;
1121	icount->dsr = cnow.dsr;
1122	icount->rng = cnow.rng;
1123	icount->dcd = cnow.dcd;
1124	icount->rx = cnow.rx;
1125	icount->tx = cnow.tx;
1126	icount->frame = cnow.frame;
1127	icount->overrun = cnow.overrun;
1128	icount->parity = cnow.parity;
1129	icount->brk = cnow.brk;
1130	icount->buf_overrun = cnow.buf_overrun;
1131
1132	return 0;
1133}
1134
1135static int rs_ioctl(struct tty_struct *tty,
1136		    unsigned int cmd, unsigned long arg)
1137{
1138	struct serial_state *info = tty->driver_data;
1139	struct async_icount cprev, cnow;	/* kernel counter temps */
1140	void __user *argp = (void __user *)arg;
1141	unsigned long flags;
1142	DEFINE_WAIT(wait);
1143	int ret;
1144
1145	if ((cmd != TIOCSERCONFIG) &&
1146	    (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
1147		if (tty_io_error(tty))
1148		    return -EIO;
1149	}
1150
1151	switch (cmd) {
1152		case TIOCSERCONFIG:
1153			return 0;
1154
1155		case TIOCSERGETLSR: /* Get line status register */
1156			return get_lsr_info(info, argp);
1157
1158		/*
1159		 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
1160		 * - mask passed in arg for lines of interest
1161 		 *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
1162		 * Caller should use TIOCGICOUNT to see which one it was
1163		 */
1164		case TIOCMIWAIT:
1165			local_irq_save(flags);
1166			/* note the counters on entry */
1167			cprev = info->icount;
1168			local_irq_restore(flags);
1169			while (1) {
1170				prepare_to_wait(&info->tport.delta_msr_wait,
1171						&wait, TASK_INTERRUPTIBLE);
1172				local_irq_save(flags);
1173				cnow = info->icount; /* atomic copy */
1174				local_irq_restore(flags);
1175				if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && 
1176				    cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
1177					ret = -EIO; /* no change => error */
1178					break;
1179				}
1180				if ( ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
1181				     ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
1182				     ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
1183				     ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
1184					ret = 0;
1185					break;
1186				}
1187				schedule();
1188				/* see if a signal did it */
1189				if (signal_pending(current)) {
1190					ret = -ERESTARTSYS;
1191					break;
1192				}
1193				cprev = cnow;
1194			}
1195			finish_wait(&info->tport.delta_msr_wait, &wait);
1196			return ret;
1197
1198		default:
1199			return -ENOIOCTLCMD;
1200		}
1201	return 0;
1202}
1203
1204static void rs_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
1205{
1206	struct serial_state *info = tty->driver_data;
1207	unsigned long flags;
1208	unsigned int cflag = tty->termios.c_cflag;
1209
1210	change_speed(tty, info, old_termios);
1211
1212	/* Handle transition to B0 status */
1213	if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD)) {
1214		info->MCR &= ~(SER_DTR|SER_RTS);
1215		local_irq_save(flags);
1216		rtsdtr_ctrl(info->MCR);
1217		local_irq_restore(flags);
1218	}
1219
1220	/* Handle transition away from B0 status */
1221	if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
1222		info->MCR |= SER_DTR;
1223		if (!C_CRTSCTS(tty) || !tty_throttled(tty))
1224			info->MCR |= SER_RTS;
1225		local_irq_save(flags);
1226		rtsdtr_ctrl(info->MCR);
1227		local_irq_restore(flags);
1228	}
1229
1230	/* Handle turning off CRTSCTS */
1231	if ((old_termios->c_cflag & CRTSCTS) && !C_CRTSCTS(tty)) {
1232		tty->hw_stopped = 0;
1233		rs_start(tty);
1234	}
1235
1236#if 0
1237	/*
1238	 * No need to wake up processes in open wait, since they
1239	 * sample the CLOCAL flag once, and don't recheck it.
1240	 * XXX  It's not clear whether the current behavior is correct
1241	 * or not.  Hence, this may change.....
1242	 */
1243	if (!(old_termios->c_cflag & CLOCAL) && C_CLOCAL(tty))
1244		wake_up_interruptible(&info->open_wait);
1245#endif
1246}
1247
1248/*
1249 * ------------------------------------------------------------
1250 * rs_close()
1251 * 
1252 * This routine is called when the serial port gets closed.  First, we
1253 * wait for the last remaining data to be sent.  Then, we unlink its
1254 * async structure from the interrupt chain if necessary, and we free
1255 * that IRQ if nothing is left in the chain.
1256 * ------------------------------------------------------------
1257 */
1258static void rs_close(struct tty_struct *tty, struct file * filp)
1259{
1260	struct serial_state *state = tty->driver_data;
1261	struct tty_port *port = &state->tport;
1262
1263	if (tty_port_close_start(port, tty, filp) == 0)
1264		return;
1265
1266	/*
1267	 * At this point we stop accepting input.  To do this, we
1268	 * disable the receive line status interrupts, and tell the
1269	 * interrupt driver to stop checking the data ready bit in the
1270	 * line status register.
1271	 */
1272	state->read_status_mask &= ~UART_LSR_DR;
1273	if (tty_port_initialized(port)) {
1274	        /* disable receive interrupts */
1275	        custom.intena = IF_RBF;
1276		mb();
1277		/* clear any pending receive interrupt */
1278		custom.intreq = IF_RBF;
1279		mb();
1280
1281		/*
1282		 * Before we drop DTR, make sure the UART transmitter
1283		 * has completely drained; this is especially
1284		 * important if there is a transmit FIFO!
1285		 */
1286		rs_wait_until_sent(tty, state->timeout);
1287	}
1288	shutdown(tty, state);
1289	rs_flush_buffer(tty);
1290		
1291	tty_ldisc_flush(tty);
1292	port->tty = NULL;
1293
1294	tty_port_close_end(port, tty);
1295}
1296
1297/*
1298 * rs_wait_until_sent() --- wait until the transmitter is empty
1299 */
1300static void rs_wait_until_sent(struct tty_struct *tty, int timeout)
1301{
1302	struct serial_state *info = tty->driver_data;
1303	unsigned long orig_jiffies, char_time;
1304	int lsr;
1305
1306	if (info->xmit_fifo_size == 0)
1307		return; /* Just in case.... */
1308
1309	orig_jiffies = jiffies;
1310
1311	/*
1312	 * Set the check interval to be 1/5 of the estimated time to
1313	 * send a single character, and make it at least 1.  The check
1314	 * interval should also be less than the timeout.
1315	 * 
1316	 * Note: we have to use pretty tight timings here to satisfy
1317	 * the NIST-PCTS.
1318	 */
1319	char_time = (info->timeout - HZ/50) / info->xmit_fifo_size;
1320	char_time = char_time / 5;
1321	if (char_time == 0)
1322		char_time = 1;
1323	if (timeout)
1324	  char_time = min_t(unsigned long, char_time, timeout);
1325	/*
1326	 * If the transmitter hasn't cleared in twice the approximate
1327	 * amount of time to send the entire FIFO, it probably won't
1328	 * ever clear.  This assumes the UART isn't doing flow
1329	 * control, which is currently the case.  Hence, if it ever
1330	 * takes longer than info->timeout, this is probably due to a
1331	 * UART bug of some kind.  So, we clamp the timeout parameter at
1332	 * 2*info->timeout.
1333	 */
1334	if (!timeout || timeout > 2*info->timeout)
1335		timeout = 2*info->timeout;
1336#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1337	printk("In rs_wait_until_sent(%d) check=%lu...", timeout, char_time);
1338	printk("jiff=%lu...", jiffies);
1339#endif
1340	while(!((lsr = custom.serdatr) & SDR_TSRE)) {
1341#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1342		printk("serdatr = %d (jiff=%lu)...", lsr, jiffies);
1343#endif
1344		msleep_interruptible(jiffies_to_msecs(char_time));
1345		if (signal_pending(current))
1346			break;
1347		if (timeout && time_after(jiffies, orig_jiffies + timeout))
1348			break;
1349	}
1350	__set_current_state(TASK_RUNNING);
1351
1352#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1353	printk("lsr = %d (jiff=%lu)...done\n", lsr, jiffies);
1354#endif
1355}
1356
1357/*
1358 * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
1359 */
1360static void rs_hangup(struct tty_struct *tty)
1361{
1362	struct serial_state *info = tty->driver_data;
1363
1364	rs_flush_buffer(tty);
1365	shutdown(tty, info);
1366	info->tport.count = 0;
1367	tty_port_set_active(&info->tport, 0);
1368	info->tport.tty = NULL;
1369	wake_up_interruptible(&info->tport.open_wait);
1370}
1371
1372/*
1373 * This routine is called whenever a serial port is opened.  It
1374 * enables interrupts for a serial port, linking in its async structure into
1375 * the IRQ chain.   It also performs the serial-specific
1376 * initialization for the tty structure.
1377 */
1378static int rs_open(struct tty_struct *tty, struct file * filp)
1379{
1380	struct serial_state *info = rs_table + tty->index;
1381	struct tty_port *port = &info->tport;
1382	int retval;
1383
1384	port->count++;
1385	port->tty = tty;
1386	tty->driver_data = info;
1387	tty->port = port;
1388
1389	port->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
1390
1391	retval = startup(tty, info);
1392	if (retval) {
1393		return retval;
1394	}
1395
1396	return tty_port_block_til_ready(port, tty, filp);
1397}
1398
1399/*
1400 * /proc fs routines....
1401 */
1402
1403static inline void line_info(struct seq_file *m, int line,
1404		struct serial_state *state)
1405{
1406	char	stat_buf[30], control, status;
1407	unsigned long flags;
1408
1409	seq_printf(m, "%d: uart:amiga_builtin", line);
1410
1411	local_irq_save(flags);
1412	status = ciab.pra;
1413	control = tty_port_initialized(&state->tport) ? state->MCR : status;
1414	local_irq_restore(flags);
1415
1416	stat_buf[0] = 0;
1417	stat_buf[1] = 0;
1418	if(!(control & SER_RTS))
1419		strcat(stat_buf, "|RTS");
1420	if(!(status & SER_CTS))
1421		strcat(stat_buf, "|CTS");
1422	if(!(control & SER_DTR))
1423		strcat(stat_buf, "|DTR");
1424	if(!(status & SER_DSR))
1425		strcat(stat_buf, "|DSR");
1426	if(!(status & SER_DCD))
1427		strcat(stat_buf, "|CD");
1428
1429	if (state->quot)
1430		seq_printf(m, " baud:%d", state->baud_base / state->quot);
1431
1432	seq_printf(m, " tx:%d rx:%d", state->icount.tx, state->icount.rx);
1433
1434	if (state->icount.frame)
1435		seq_printf(m, " fe:%d", state->icount.frame);
1436
1437	if (state->icount.parity)
1438		seq_printf(m, " pe:%d", state->icount.parity);
1439
1440	if (state->icount.brk)
1441		seq_printf(m, " brk:%d", state->icount.brk);
1442
1443	if (state->icount.overrun)
1444		seq_printf(m, " oe:%d", state->icount.overrun);
1445
1446	/*
1447	 * Last thing is the RS-232 status lines
1448	 */
1449	seq_printf(m, " %s\n", stat_buf+1);
1450}
1451
1452static int rs_proc_show(struct seq_file *m, void *v)
1453{
1454	seq_printf(m, "serinfo:1.0 driver:%s\n", serial_version);
1455	line_info(m, 0, &rs_table[0]);
1456	return 0;
1457}
1458
1459/*
1460 * ---------------------------------------------------------------------
1461 * rs_init() and friends
1462 *
1463 * rs_init() is called at boot-time to initialize the serial driver.
1464 * ---------------------------------------------------------------------
1465 */
1466
1467/*
1468 * This routine prints out the appropriate serial driver version
1469 * number, and identifies which options were configured into this
1470 * driver.
1471 */
1472static void show_serial_version(void)
1473{
1474 	printk(KERN_INFO "%s version %s\n", serial_name, serial_version);
1475}
1476
1477
1478static const struct tty_operations serial_ops = {
1479	.open = rs_open,
1480	.close = rs_close,
1481	.write = rs_write,
1482	.put_char = rs_put_char,
1483	.flush_chars = rs_flush_chars,
1484	.write_room = rs_write_room,
1485	.chars_in_buffer = rs_chars_in_buffer,
1486	.flush_buffer = rs_flush_buffer,
1487	.ioctl = rs_ioctl,
1488	.throttle = rs_throttle,
1489	.unthrottle = rs_unthrottle,
1490	.set_termios = rs_set_termios,
1491	.stop = rs_stop,
1492	.start = rs_start,
1493	.hangup = rs_hangup,
1494	.break_ctl = rs_break,
1495	.send_xchar = rs_send_xchar,
1496	.wait_until_sent = rs_wait_until_sent,
1497	.tiocmget = rs_tiocmget,
1498	.tiocmset = rs_tiocmset,
1499	.get_icount = rs_get_icount,
1500	.set_serial = set_serial_info,
1501	.get_serial = get_serial_info,
1502	.proc_show = rs_proc_show,
1503};
1504
1505static int amiga_carrier_raised(struct tty_port *port)
1506{
1507	return !(ciab.pra & SER_DCD);
1508}
1509
1510static void amiga_dtr_rts(struct tty_port *port, int raise)
1511{
1512	struct serial_state *info = container_of(port, struct serial_state,
1513			tport);
1514	unsigned long flags;
1515
1516	if (raise)
1517		info->MCR |= SER_DTR|SER_RTS;
1518	else
1519		info->MCR &= ~(SER_DTR|SER_RTS);
1520
1521	local_irq_save(flags);
1522	rtsdtr_ctrl(info->MCR);
1523	local_irq_restore(flags);
1524}
1525
1526static const struct tty_port_operations amiga_port_ops = {
1527	.carrier_raised = amiga_carrier_raised,
1528	.dtr_rts = amiga_dtr_rts,
1529};
1530
1531/*
1532 * The serial driver boot-time initialization code!
1533 */
1534static int __init amiga_serial_probe(struct platform_device *pdev)
1535{
1536	unsigned long flags;
1537	struct serial_state * state;
1538	int error;
1539
1540	serial_driver = alloc_tty_driver(NR_PORTS);
1541	if (!serial_driver)
1542		return -ENOMEM;
1543
1544	show_serial_version();
1545
1546	/* Initialize the tty_driver structure */
1547
1548	serial_driver->driver_name = "amiserial";
1549	serial_driver->name = "ttyS";
1550	serial_driver->major = TTY_MAJOR;
1551	serial_driver->minor_start = 64;
1552	serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
1553	serial_driver->subtype = SERIAL_TYPE_NORMAL;
1554	serial_driver->init_termios = tty_std_termios;
1555	serial_driver->init_termios.c_cflag =
1556		B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1557	serial_driver->flags = TTY_DRIVER_REAL_RAW;
1558	tty_set_operations(serial_driver, &serial_ops);
1559
1560	state = rs_table;
1561	state->port = (int)&custom.serdatr; /* Just to give it a value */
1562	state->custom_divisor = 0;
1563	state->icount.cts = state->icount.dsr = 
1564	  state->icount.rng = state->icount.dcd = 0;
1565	state->icount.rx = state->icount.tx = 0;
1566	state->icount.frame = state->icount.parity = 0;
1567	state->icount.overrun = state->icount.brk = 0;
1568	tty_port_init(&state->tport);
1569	state->tport.ops = &amiga_port_ops;
1570	tty_port_link_device(&state->tport, serial_driver, 0);
1571
1572	error = tty_register_driver(serial_driver);
1573	if (error)
1574		goto fail_put_tty_driver;
1575
1576	printk(KERN_INFO "ttyS0 is the amiga builtin serial port\n");
1577
1578	/* Hardware set up */
1579
1580	state->baud_base = amiga_colorclock;
1581	state->xmit_fifo_size = 1;
1582
1583	/* set ISRs, and then disable the rx interrupts */
1584	error = request_irq(IRQ_AMIGA_TBE, ser_tx_int, 0, "serial TX", state);
1585	if (error)
1586		goto fail_unregister;
1587
1588	error = request_irq(IRQ_AMIGA_RBF, ser_rx_int, 0,
1589			    "serial RX", state);
1590	if (error)
1591		goto fail_free_irq;
1592
1593	local_irq_save(flags);
1594
1595	/* turn off Rx and Tx interrupts */
1596	custom.intena = IF_RBF | IF_TBE;
1597	mb();
1598
1599	/* clear any pending interrupt */
1600	custom.intreq = IF_RBF | IF_TBE;
1601	mb();
1602
1603	local_irq_restore(flags);
1604
1605	/*
1606	 * set the appropriate directions for the modem control flags,
1607	 * and clear RTS and DTR
1608	 */
1609	ciab.ddra |= (SER_DTR | SER_RTS);   /* outputs */
1610	ciab.ddra &= ~(SER_DCD | SER_CTS | SER_DSR);  /* inputs */
1611
1612	platform_set_drvdata(pdev, state);
1613
1614	return 0;
1615
1616fail_free_irq:
1617	free_irq(IRQ_AMIGA_TBE, state);
1618fail_unregister:
1619	tty_unregister_driver(serial_driver);
1620fail_put_tty_driver:
1621	tty_port_destroy(&state->tport);
1622	put_tty_driver(serial_driver);
1623	return error;
1624}
1625
1626static int __exit amiga_serial_remove(struct platform_device *pdev)
1627{
1628	int error;
1629	struct serial_state *state = platform_get_drvdata(pdev);
1630
1631	/* printk("Unloading %s: version %s\n", serial_name, serial_version); */
1632	error = tty_unregister_driver(serial_driver);
1633	if (error)
1634		printk("SERIAL: failed to unregister serial driver (%d)\n",
1635		       error);
1636	put_tty_driver(serial_driver);
1637	tty_port_destroy(&state->tport);
1638
1639	free_irq(IRQ_AMIGA_TBE, state);
1640	free_irq(IRQ_AMIGA_RBF, state);
1641
1642	return error;
1643}
1644
1645static struct platform_driver amiga_serial_driver = {
1646	.remove = __exit_p(amiga_serial_remove),
1647	.driver   = {
1648		.name	= "amiga-serial",
1649	},
1650};
1651
1652module_platform_driver_probe(amiga_serial_driver, amiga_serial_probe);
1653
1654
1655#if defined(CONFIG_SERIAL_CONSOLE) && !defined(MODULE)
1656
1657/*
1658 * ------------------------------------------------------------
1659 * Serial console driver
1660 * ------------------------------------------------------------
1661 */
1662
1663static void amiga_serial_putc(char c)
1664{
1665	custom.serdat = (unsigned char)c | 0x100;
1666	while (!(custom.serdatr & 0x2000))
1667		barrier();
1668}
1669
1670/*
1671 *	Print a string to the serial port trying not to disturb
1672 *	any possible real use of the port...
1673 *
1674 *	The console must be locked when we get here.
1675 */
1676static void serial_console_write(struct console *co, const char *s,
1677				unsigned count)
1678{
1679	unsigned short intena = custom.intenar;
1680
1681	custom.intena = IF_TBE;
1682
1683	while (count--) {
1684		if (*s == '\n')
1685			amiga_serial_putc('\r');
1686		amiga_serial_putc(*s++);
1687	}
1688
1689	custom.intena = IF_SETCLR | (intena & IF_TBE);
1690}
1691
1692static struct tty_driver *serial_console_device(struct console *c, int *index)
1693{
1694	*index = 0;
1695	return serial_driver;
1696}
1697
1698static struct console sercons = {
1699	.name =		"ttyS",
1700	.write =	serial_console_write,
1701	.device =	serial_console_device,
1702	.flags =	CON_PRINTBUFFER,
1703	.index =	-1,
1704};
1705
1706/*
1707 *	Register console.
1708 */
1709static int __init amiserial_console_init(void)
1710{
1711	if (!MACH_IS_AMIGA)
1712		return -ENODEV;
1713
1714	register_console(&sercons);
1715	return 0;
1716}
1717console_initcall(amiserial_console_init);
1718
1719#endif /* CONFIG_SERIAL_CONSOLE && !MODULE */
1720
1721MODULE_LICENSE("GPL");
1722MODULE_ALIAS("platform:amiga-serial");