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