PageRenderTime 72ms CodeModel.GetById 17ms app.highlight 42ms RepoModel.GetById 0ms app.codeStats 1ms

/drivers/staging/tty/serial167.c

https://bitbucket.org/slukk/jb-tsm-kernel-4.2
C | 2489 lines | 1831 code | 302 blank | 356 comment | 312 complexity | 7c7603d25598577481a09104f77c7255 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0

Large files files are truncated, but you can click here to view the full file

   1/*
   2 * linux/drivers/char/serial167.c
   3 *
   4 * Driver for MVME166/7 board serial ports, which are via a CD2401.
   5 * Based very much on cyclades.c.
   6 *
   7 * MVME166/7 work by Richard Hirst [richard@sleepie.demon.co.uk]
   8 *
   9 * ==============================================================
  10 *
  11 * static char rcsid[] =
  12 * "$Revision: 1.36.1.4 $$Date: 1995/03/29 06:14:14 $";
  13 *
  14 *  linux/kernel/cyclades.c
  15 *
  16 * Maintained by Marcio Saito (cyclades@netcom.com) and
  17 * Randolph Bentson (bentson@grieg.seaslug.org)
  18 *
  19 * Much of the design and some of the code came from serial.c
  20 * which was copyright (C) 1991, 1992  Linus Torvalds.  It was
  21 * extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92,
  22 * and then fixed as suggested by Michael K. Johnson 12/12/92.
  23 *
  24 * This version does not support shared irq's.
  25 *
  26 * $Log: cyclades.c,v $
  27 * Revision 1.36.1.4  1995/03/29  06:14:14  bentson
  28 * disambiguate between Cyclom-16Y and Cyclom-32Ye;
  29 *
  30 * Changes:
  31 *
  32 * 200 lines of changes record removed - RGH 11-10-95, starting work on
  33 * converting this to drive serial ports on mvme166 (cd2401).
  34 *
  35 * Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 2000/08/25
  36 * - get rid of verify_area
  37 * - use get_user to access memory from userspace in set_threshold,
  38 *   set_default_threshold and set_timeout
  39 * - don't use the panic function in serial167_init
  40 * - do resource release on failure on serial167_init
  41 * - include missing restore_flags in mvme167_serial_console_setup
  42 *
  43 * Kars de Jong <jongk@linux-m68k.org> - 2004/09/06
  44 * - replace bottom half handler with task queue handler
  45 */
  46
  47#include <linux/errno.h>
  48#include <linux/signal.h>
  49#include <linux/sched.h>
  50#include <linux/timer.h>
  51#include <linux/tty.h>
  52#include <linux/interrupt.h>
  53#include <linux/serial.h>
  54#include <linux/serialP.h>
  55#include <linux/string.h>
  56#include <linux/fcntl.h>
  57#include <linux/ptrace.h>
  58#include <linux/serial167.h>
  59#include <linux/delay.h>
  60#include <linux/major.h>
  61#include <linux/mm.h>
  62#include <linux/console.h>
  63#include <linux/module.h>
  64#include <linux/bitops.h>
  65#include <linux/tty_flip.h>
  66#include <linux/gfp.h>
  67
  68#include <asm/system.h>
  69#include <asm/io.h>
  70#include <asm/mvme16xhw.h>
  71#include <asm/bootinfo.h>
  72#include <asm/setup.h>
  73
  74#include <linux/types.h>
  75#include <linux/kernel.h>
  76
  77#include <asm/uaccess.h>
  78#include <linux/init.h>
  79
  80#define SERIAL_PARANOIA_CHECK
  81#undef  SERIAL_DEBUG_OPEN
  82#undef  SERIAL_DEBUG_THROTTLE
  83#undef  SERIAL_DEBUG_OTHER
  84#undef  SERIAL_DEBUG_IO
  85#undef  SERIAL_DEBUG_COUNT
  86#undef  SERIAL_DEBUG_DTR
  87#undef  CYCLOM_16Y_HACK
  88#define  CYCLOM_ENABLE_MONITORING
  89
  90#define WAKEUP_CHARS 256
  91
  92#define STD_COM_FLAGS (0)
  93
  94static struct tty_driver *cy_serial_driver;
  95extern int serial_console;
  96static struct cyclades_port *serial_console_info = NULL;
  97static unsigned int serial_console_cflag = 0;
  98u_char initial_console_speed;
  99
 100/* Base address of cd2401 chip on mvme166/7 */
 101
 102#define BASE_ADDR (0xfff45000)
 103#define pcc2chip	((volatile u_char *)0xfff42000)
 104#define PccSCCMICR	0x1d
 105#define PccSCCTICR	0x1e
 106#define PccSCCRICR	0x1f
 107#define PccTPIACKR	0x25
 108#define PccRPIACKR	0x27
 109#define PccIMLR		0x3f
 110
 111/* This is the per-port data structure */
 112struct cyclades_port cy_port[] = {
 113	/* CARD#  */
 114	{-1},			/* ttyS0 */
 115	{-1},			/* ttyS1 */
 116	{-1},			/* ttyS2 */
 117	{-1},			/* ttyS3 */
 118};
 119
 120#define NR_PORTS        ARRAY_SIZE(cy_port)
 121
 122/*
 123 * This is used to look up the divisor speeds and the timeouts
 124 * We're normally limited to 15 distinct baud rates.  The extra
 125 * are accessed via settings in info->flags.
 126 *         0,     1,     2,     3,     4,     5,     6,     7,     8,     9,
 127 *        10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
 128 *                                                  HI            VHI
 129 */
 130static int baud_table[] = {
 131	0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
 132	1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
 133	0
 134};
 135
 136#if 0
 137static char baud_co[] = {	/* 25 MHz clock option table */
 138	/* value =>    00    01   02    03    04 */
 139	/* divide by    8    32   128   512  2048 */
 140	0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
 141	0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 142};
 143
 144static char baud_bpr[] = {	/* 25 MHz baud rate period table */
 145	0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
 146	0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
 147};
 148#endif
 149
 150/* I think 166 brd clocks 2401 at 20MHz.... */
 151
 152/* These values are written directly to tcor, and >> 5 for writing to rcor */
 153static u_char baud_co[] = {	/* 20 MHz clock option table */
 154	0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x60, 0x60, 0x40,
 155	0x40, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 156};
 157
 158/* These values written directly to tbpr/rbpr */
 159static u_char baud_bpr[] = {	/* 20 MHz baud rate period table */
 160	0x00, 0xc0, 0x80, 0x58, 0x6c, 0x40, 0xc0, 0x81, 0x40, 0x81,
 161	0x57, 0x40, 0x81, 0x40, 0x81, 0x40, 0x2b, 0x20, 0x15, 0x10
 162};
 163
 164static u_char baud_cor4[] = {	/* receive threshold */
 165	0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
 166	0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07
 167};
 168
 169static void shutdown(struct cyclades_port *);
 170static int startup(struct cyclades_port *);
 171static void cy_throttle(struct tty_struct *);
 172static void cy_unthrottle(struct tty_struct *);
 173static void config_setup(struct cyclades_port *);
 174#ifdef CYCLOM_SHOW_STATUS
 175static void show_status(int);
 176#endif
 177
 178/*
 179 * I have my own version of udelay(), as it is needed when initialising
 180 * the chip, before the delay loop has been calibrated.  Should probably
 181 * reference one of the vmechip2 or pccchip2 counter for an accurate
 182 * delay, but this wild guess will do for now.
 183 */
 184
 185void my_udelay(long us)
 186{
 187	u_char x;
 188	volatile u_char *p = &x;
 189	int i;
 190
 191	while (us--)
 192		for (i = 100; i; i--)
 193			x |= *p;
 194}
 195
 196static inline int serial_paranoia_check(struct cyclades_port *info, char *name,
 197		const char *routine)
 198{
 199#ifdef SERIAL_PARANOIA_CHECK
 200	if (!info) {
 201		printk("Warning: null cyclades_port for (%s) in %s\n", name,
 202				routine);
 203		return 1;
 204	}
 205
 206	if (info < &cy_port[0] || info >= &cy_port[NR_PORTS]) {
 207		printk("Warning: cyclades_port out of range for (%s) in %s\n",
 208				name, routine);
 209		return 1;
 210	}
 211
 212	if (info->magic != CYCLADES_MAGIC) {
 213		printk("Warning: bad magic number for serial struct (%s) in "
 214				"%s\n", name, routine);
 215		return 1;
 216	}
 217#endif
 218	return 0;
 219}				/* serial_paranoia_check */
 220
 221#if 0
 222/* The following diagnostic routines allow the driver to spew
 223   information on the screen, even (especially!) during interrupts.
 224 */
 225void SP(char *data)
 226{
 227	unsigned long flags;
 228	local_irq_save(flags);
 229	printk(KERN_EMERG "%s", data);
 230	local_irq_restore(flags);
 231}
 232
 233char scrn[2];
 234void CP(char data)
 235{
 236	unsigned long flags;
 237	local_irq_save(flags);
 238	scrn[0] = data;
 239	printk(KERN_EMERG "%c", scrn);
 240	local_irq_restore(flags);
 241}				/* CP */
 242
 243void CP1(int data)
 244{
 245	(data < 10) ? CP(data + '0') : CP(data + 'A' - 10);
 246}				/* CP1 */
 247void CP2(int data)
 248{
 249	CP1((data >> 4) & 0x0f);
 250	CP1(data & 0x0f);
 251}				/* CP2 */
 252void CP4(int data)
 253{
 254	CP2((data >> 8) & 0xff);
 255	CP2(data & 0xff);
 256}				/* CP4 */
 257void CP8(long data)
 258{
 259	CP4((data >> 16) & 0xffff);
 260	CP4(data & 0xffff);
 261}				/* CP8 */
 262#endif
 263
 264/* This routine waits up to 1000 micro-seconds for the previous
 265   command to the Cirrus chip to complete and then issues the
 266   new command.  An error is returned if the previous command
 267   didn't finish within the time limit.
 268 */
 269u_short write_cy_cmd(volatile u_char * base_addr, u_char cmd)
 270{
 271	unsigned long flags;
 272	volatile int i;
 273
 274	local_irq_save(flags);
 275	/* Check to see that the previous command has completed */
 276	for (i = 0; i < 100; i++) {
 277		if (base_addr[CyCCR] == 0) {
 278			break;
 279		}
 280		my_udelay(10L);
 281	}
 282	/* if the CCR never cleared, the previous command
 283	   didn't finish within the "reasonable time" */
 284	if (i == 10) {
 285		local_irq_restore(flags);
 286		return (-1);
 287	}
 288
 289	/* Issue the new command */
 290	base_addr[CyCCR] = cmd;
 291	local_irq_restore(flags);
 292	return (0);
 293}				/* write_cy_cmd */
 294
 295/* cy_start and cy_stop provide software output flow control as a
 296   function of XON/XOFF, software CTS, and other such stuff. */
 297
 298static void cy_stop(struct tty_struct *tty)
 299{
 300	struct cyclades_port *info = tty->driver_data;
 301	volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
 302	int channel;
 303	unsigned long flags;
 304
 305#ifdef SERIAL_DEBUG_OTHER
 306	printk("cy_stop %s\n", tty->name);	/* */
 307#endif
 308
 309	if (serial_paranoia_check(info, tty->name, "cy_stop"))
 310		return;
 311
 312	channel = info->line;
 313
 314	local_irq_save(flags);
 315	base_addr[CyCAR] = (u_char) (channel);	/* index channel */
 316	base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
 317	local_irq_restore(flags);
 318}				/* cy_stop */
 319
 320static void cy_start(struct tty_struct *tty)
 321{
 322	struct cyclades_port *info = tty->driver_data;
 323	volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
 324	int channel;
 325	unsigned long flags;
 326
 327#ifdef SERIAL_DEBUG_OTHER
 328	printk("cy_start %s\n", tty->name);	/* */
 329#endif
 330
 331	if (serial_paranoia_check(info, tty->name, "cy_start"))
 332		return;
 333
 334	channel = info->line;
 335
 336	local_irq_save(flags);
 337	base_addr[CyCAR] = (u_char) (channel);
 338	base_addr[CyIER] |= CyTxMpty;
 339	local_irq_restore(flags);
 340}				/* cy_start */
 341
 342/* The real interrupt service routines are called
 343   whenever the card wants its hand held--chars
 344   received, out buffer empty, modem change, etc.
 345 */
 346static irqreturn_t cd2401_rxerr_interrupt(int irq, void *dev_id)
 347{
 348	struct tty_struct *tty;
 349	struct cyclades_port *info;
 350	volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
 351	unsigned char err, rfoc;
 352	int channel;
 353	char data;
 354
 355	/* determine the channel and change to that context */
 356	channel = (u_short) (base_addr[CyLICR] >> 2);
 357	info = &cy_port[channel];
 358	info->last_active = jiffies;
 359
 360	if ((err = base_addr[CyRISR]) & CyTIMEOUT) {
 361		/* This is a receive timeout interrupt, ignore it */
 362		base_addr[CyREOIR] = CyNOTRANS;
 363		return IRQ_HANDLED;
 364	}
 365
 366	/* Read a byte of data if there is any - assume the error
 367	 * is associated with this character */
 368
 369	if ((rfoc = base_addr[CyRFOC]) != 0)
 370		data = base_addr[CyRDR];
 371	else
 372		data = 0;
 373
 374	/* if there is nowhere to put the data, discard it */
 375	if (info->tty == 0) {
 376		base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
 377		return IRQ_HANDLED;
 378	} else {		/* there is an open port for this data */
 379		tty = info->tty;
 380		if (err & info->ignore_status_mask) {
 381			base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
 382			return IRQ_HANDLED;
 383		}
 384		if (tty_buffer_request_room(tty, 1) != 0) {
 385			if (err & info->read_status_mask) {
 386				if (err & CyBREAK) {
 387					tty_insert_flip_char(tty, data,
 388							     TTY_BREAK);
 389					if (info->flags & ASYNC_SAK) {
 390						do_SAK(tty);
 391					}
 392				} else if (err & CyFRAME) {
 393					tty_insert_flip_char(tty, data,
 394							     TTY_FRAME);
 395				} else if (err & CyPARITY) {
 396					tty_insert_flip_char(tty, data,
 397							     TTY_PARITY);
 398				} else if (err & CyOVERRUN) {
 399					tty_insert_flip_char(tty, 0,
 400							     TTY_OVERRUN);
 401					/*
 402					   If the flip buffer itself is
 403					   overflowing, we still lose
 404					   the next incoming character.
 405					 */
 406					if (tty_buffer_request_room(tty, 1) !=
 407					    0) {
 408						tty_insert_flip_char(tty, data,
 409								     TTY_FRAME);
 410					}
 411					/* These two conditions may imply */
 412					/* a normal read should be done. */
 413					/* else if(data & CyTIMEOUT) */
 414					/* else if(data & CySPECHAR) */
 415				} else {
 416					tty_insert_flip_char(tty, 0,
 417							     TTY_NORMAL);
 418				}
 419			} else {
 420				tty_insert_flip_char(tty, data, TTY_NORMAL);
 421			}
 422		} else {
 423			/* there was a software buffer overrun
 424			   and nothing could be done about it!!! */
 425		}
 426	}
 427	tty_schedule_flip(tty);
 428	/* end of service */
 429	base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
 430	return IRQ_HANDLED;
 431}				/* cy_rxerr_interrupt */
 432
 433static irqreturn_t cd2401_modem_interrupt(int irq, void *dev_id)
 434{
 435	struct cyclades_port *info;
 436	volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
 437	int channel;
 438	int mdm_change;
 439	int mdm_status;
 440
 441	/* determine the channel and change to that context */
 442	channel = (u_short) (base_addr[CyLICR] >> 2);
 443	info = &cy_port[channel];
 444	info->last_active = jiffies;
 445
 446	mdm_change = base_addr[CyMISR];
 447	mdm_status = base_addr[CyMSVR1];
 448
 449	if (info->tty == 0) {	/* nowhere to put the data, ignore it */
 450		;
 451	} else {
 452		if ((mdm_change & CyDCD)
 453		    && (info->flags & ASYNC_CHECK_CD)) {
 454			if (mdm_status & CyDCD) {
 455/* CP('!'); */
 456				wake_up_interruptible(&info->open_wait);
 457			} else {
 458/* CP('@'); */
 459				tty_hangup(info->tty);
 460				wake_up_interruptible(&info->open_wait);
 461				info->flags &= ~ASYNC_NORMAL_ACTIVE;
 462			}
 463		}
 464		if ((mdm_change & CyCTS)
 465		    && (info->flags & ASYNC_CTS_FLOW)) {
 466			if (info->tty->stopped) {
 467				if (mdm_status & CyCTS) {
 468					/* !!! cy_start isn't used because... */
 469					info->tty->stopped = 0;
 470					base_addr[CyIER] |= CyTxMpty;
 471					tty_wakeup(info->tty);
 472				}
 473			} else {
 474				if (!(mdm_status & CyCTS)) {
 475					/* !!! cy_stop isn't used because... */
 476					info->tty->stopped = 1;
 477					base_addr[CyIER] &=
 478					    ~(CyTxMpty | CyTxRdy);
 479				}
 480			}
 481		}
 482		if (mdm_status & CyDSR) {
 483		}
 484	}
 485	base_addr[CyMEOIR] = 0;
 486	return IRQ_HANDLED;
 487}				/* cy_modem_interrupt */
 488
 489static irqreturn_t cd2401_tx_interrupt(int irq, void *dev_id)
 490{
 491	struct cyclades_port *info;
 492	volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
 493	int channel;
 494	int char_count, saved_cnt;
 495	int outch;
 496
 497	/* determine the channel and change to that context */
 498	channel = (u_short) (base_addr[CyLICR] >> 2);
 499
 500	/* validate the port number (as configured and open) */
 501	if ((channel < 0) || (NR_PORTS <= channel)) {
 502		base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
 503		base_addr[CyTEOIR] = CyNOTRANS;
 504		return IRQ_HANDLED;
 505	}
 506	info = &cy_port[channel];
 507	info->last_active = jiffies;
 508	if (info->tty == 0) {
 509		base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
 510		base_addr[CyTEOIR] = CyNOTRANS;
 511		return IRQ_HANDLED;
 512	}
 513
 514	/* load the on-chip space available for outbound data */
 515	saved_cnt = char_count = base_addr[CyTFTC];
 516
 517	if (info->x_char) {	/* send special char */
 518		outch = info->x_char;
 519		base_addr[CyTDR] = outch;
 520		char_count--;
 521		info->x_char = 0;
 522	}
 523
 524	if (info->x_break) {
 525		/*  The Cirrus chip requires the "Embedded Transmit
 526		   Commands" of start break, delay, and end break
 527		   sequences to be sent.  The duration of the
 528		   break is given in TICs, which runs at HZ
 529		   (typically 100) and the PPR runs at 200 Hz,
 530		   so the delay is duration * 200/HZ, and thus a
 531		   break can run from 1/100 sec to about 5/4 sec.
 532		   Need to check these values - RGH 141095.
 533		 */
 534		base_addr[CyTDR] = 0;	/* start break */
 535		base_addr[CyTDR] = 0x81;
 536		base_addr[CyTDR] = 0;	/* delay a bit */
 537		base_addr[CyTDR] = 0x82;
 538		base_addr[CyTDR] = info->x_break * 200 / HZ;
 539		base_addr[CyTDR] = 0;	/* terminate break */
 540		base_addr[CyTDR] = 0x83;
 541		char_count -= 7;
 542		info->x_break = 0;
 543	}
 544
 545	while (char_count > 0) {
 546		if (!info->xmit_cnt) {
 547			base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
 548			break;
 549		}
 550		if (info->xmit_buf == 0) {
 551			base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
 552			break;
 553		}
 554		if (info->tty->stopped || info->tty->hw_stopped) {
 555			base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
 556			break;
 557		}
 558		/* Because the Embedded Transmit Commands have been
 559		   enabled, we must check to see if the escape
 560		   character, NULL, is being sent.  If it is, we
 561		   must ensure that there is room for it to be
 562		   doubled in the output stream.  Therefore we
 563		   no longer advance the pointer when the character
 564		   is fetched, but rather wait until after the check
 565		   for a NULL output character. (This is necessary
 566		   because there may not be room for the two chars
 567		   needed to send a NULL.
 568		 */
 569		outch = info->xmit_buf[info->xmit_tail];
 570		if (outch) {
 571			info->xmit_cnt--;
 572			info->xmit_tail = (info->xmit_tail + 1)
 573			    & (PAGE_SIZE - 1);
 574			base_addr[CyTDR] = outch;
 575			char_count--;
 576		} else {
 577			if (char_count > 1) {
 578				info->xmit_cnt--;
 579				info->xmit_tail = (info->xmit_tail + 1)
 580				    & (PAGE_SIZE - 1);
 581				base_addr[CyTDR] = outch;
 582				base_addr[CyTDR] = 0;
 583				char_count--;
 584				char_count--;
 585			} else {
 586				break;
 587			}
 588		}
 589	}
 590
 591	if (info->xmit_cnt < WAKEUP_CHARS)
 592		tty_wakeup(info->tty);
 593
 594	base_addr[CyTEOIR] = (char_count != saved_cnt) ? 0 : CyNOTRANS;
 595	return IRQ_HANDLED;
 596}				/* cy_tx_interrupt */
 597
 598static irqreturn_t cd2401_rx_interrupt(int irq, void *dev_id)
 599{
 600	struct tty_struct *tty;
 601	struct cyclades_port *info;
 602	volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
 603	int channel;
 604	char data;
 605	int char_count;
 606	int save_cnt;
 607
 608	/* determine the channel and change to that context */
 609	channel = (u_short) (base_addr[CyLICR] >> 2);
 610	info = &cy_port[channel];
 611	info->last_active = jiffies;
 612	save_cnt = char_count = base_addr[CyRFOC];
 613
 614		/* if there is nowhere to put the data, discard it */
 615	if (info->tty == 0) {
 616		while (char_count--) {
 617			data = base_addr[CyRDR];
 618		}
 619	} else {		/* there is an open port for this data */
 620		tty = info->tty;
 621		/* load # characters available from the chip */
 622
 623#ifdef CYCLOM_ENABLE_MONITORING
 624		++info->mon.int_count;
 625		info->mon.char_count += char_count;
 626		if (char_count > info->mon.char_max)
 627			info->mon.char_max = char_count;
 628		info->mon.char_last = char_count;
 629#endif
 630		while (char_count--) {
 631			data = base_addr[CyRDR];
 632			tty_insert_flip_char(tty, data, TTY_NORMAL);
 633#ifdef CYCLOM_16Y_HACK
 634			udelay(10L);
 635#endif
 636		}
 637		tty_schedule_flip(tty);
 638	}
 639	/* end of service */
 640	base_addr[CyREOIR] = save_cnt ? 0 : CyNOTRANS;
 641	return IRQ_HANDLED;
 642}				/* cy_rx_interrupt */
 643
 644/* This is called whenever a port becomes active;
 645   interrupts are enabled and DTR & RTS are turned on.
 646 */
 647static int startup(struct cyclades_port *info)
 648{
 649	unsigned long flags;
 650	volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
 651	int channel;
 652
 653	if (info->flags & ASYNC_INITIALIZED) {
 654		return 0;
 655	}
 656
 657	if (!info->type) {
 658		if (info->tty) {
 659			set_bit(TTY_IO_ERROR, &info->tty->flags);
 660		}
 661		return 0;
 662	}
 663	if (!info->xmit_buf) {
 664		info->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
 665		if (!info->xmit_buf) {
 666			return -ENOMEM;
 667		}
 668	}
 669
 670	config_setup(info);
 671
 672	channel = info->line;
 673
 674#ifdef SERIAL_DEBUG_OPEN
 675	printk("startup channel %d\n", channel);
 676#endif
 677
 678	local_irq_save(flags);
 679	base_addr[CyCAR] = (u_char) channel;
 680	write_cy_cmd(base_addr, CyENB_RCVR | CyENB_XMTR);
 681
 682	base_addr[CyCAR] = (u_char) channel;	/* !!! Is this needed? */
 683	base_addr[CyMSVR1] = CyRTS;
 684/* CP('S');CP('1'); */
 685	base_addr[CyMSVR2] = CyDTR;
 686
 687#ifdef SERIAL_DEBUG_DTR
 688	printk("cyc: %d: raising DTR\n", __LINE__);
 689	printk("     status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
 690	       base_addr[CyMSVR2]);
 691#endif
 692
 693	base_addr[CyIER] |= CyRxData;
 694	info->flags |= ASYNC_INITIALIZED;
 695
 696	if (info->tty) {
 697		clear_bit(TTY_IO_ERROR, &info->tty->flags);
 698	}
 699	info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
 700
 701	local_irq_restore(flags);
 702
 703#ifdef SERIAL_DEBUG_OPEN
 704	printk(" done\n");
 705#endif
 706	return 0;
 707}				/* startup */
 708
 709void start_xmit(struct cyclades_port *info)
 710{
 711	unsigned long flags;
 712	volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
 713	int channel;
 714
 715	channel = info->line;
 716	local_irq_save(flags);
 717	base_addr[CyCAR] = channel;
 718	base_addr[CyIER] |= CyTxMpty;
 719	local_irq_restore(flags);
 720}				/* start_xmit */
 721
 722/*
 723 * This routine shuts down a serial port; interrupts are disabled,
 724 * and DTR is dropped if the hangup on close termio flag is on.
 725 */
 726static void shutdown(struct cyclades_port *info)
 727{
 728	unsigned long flags;
 729	volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
 730	int channel;
 731
 732	if (!(info->flags & ASYNC_INITIALIZED)) {
 733/* CP('$'); */
 734		return;
 735	}
 736
 737	channel = info->line;
 738
 739#ifdef SERIAL_DEBUG_OPEN
 740	printk("shutdown channel %d\n", channel);
 741#endif
 742
 743	/* !!! REALLY MUST WAIT FOR LAST CHARACTER TO BE
 744	   SENT BEFORE DROPPING THE LINE !!!  (Perhaps
 745	   set some flag that is read when XMTY happens.)
 746	   Other choices are to delay some fixed interval
 747	   or schedule some later processing.
 748	 */
 749	local_irq_save(flags);
 750	if (info->xmit_buf) {
 751		free_page((unsigned long)info->xmit_buf);
 752		info->xmit_buf = NULL;
 753	}
 754
 755	base_addr[CyCAR] = (u_char) channel;
 756	if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
 757		base_addr[CyMSVR1] = 0;
 758/* CP('C');CP('1'); */
 759		base_addr[CyMSVR2] = 0;
 760#ifdef SERIAL_DEBUG_DTR
 761		printk("cyc: %d: dropping DTR\n", __LINE__);
 762		printk("     status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
 763		       base_addr[CyMSVR2]);
 764#endif
 765	}
 766	write_cy_cmd(base_addr, CyDIS_RCVR);
 767	/* it may be appropriate to clear _XMIT at
 768	   some later date (after testing)!!! */
 769
 770	if (info->tty) {
 771		set_bit(TTY_IO_ERROR, &info->tty->flags);
 772	}
 773	info->flags &= ~ASYNC_INITIALIZED;
 774	local_irq_restore(flags);
 775
 776#ifdef SERIAL_DEBUG_OPEN
 777	printk(" done\n");
 778#endif
 779}				/* shutdown */
 780
 781/*
 782 * This routine finds or computes the various line characteristics.
 783 */
 784static void config_setup(struct cyclades_port *info)
 785{
 786	unsigned long flags;
 787	volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
 788	int channel;
 789	unsigned cflag;
 790	int i;
 791	unsigned char ti, need_init_chan = 0;
 792
 793	if (!info->tty || !info->tty->termios) {
 794		return;
 795	}
 796	if (info->line == -1) {
 797		return;
 798	}
 799	cflag = info->tty->termios->c_cflag;
 800
 801	/* baud rate */
 802	i = cflag & CBAUD;
 803#ifdef CBAUDEX
 804/* Starting with kernel 1.1.65, there is direct support for
 805   higher baud rates.  The following code supports those
 806   changes.  The conditional aspect allows this driver to be
 807   used for earlier as well as later kernel versions.  (The
 808   mapping is slightly different from serial.c because there
 809   is still the possibility of supporting 75 kbit/sec with
 810   the Cyclades board.)
 811 */
 812	if (i & CBAUDEX) {
 813		if (i == B57600)
 814			i = 16;
 815		else if (i == B115200)
 816			i = 18;
 817#ifdef B78600
 818		else if (i == B78600)
 819			i = 17;
 820#endif
 821		else
 822			info->tty->termios->c_cflag &= ~CBAUDEX;
 823	}
 824#endif
 825	if (i == 15) {
 826		if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
 827			i += 1;
 828		if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
 829			i += 3;
 830	}
 831	/* Don't ever change the speed of the console port.  It will
 832	 * run at the speed specified in bootinfo, or at 19.2K */
 833	/* Actually, it should run at whatever speed 166Bug was using */
 834	/* Note info->timeout isn't used at present */
 835	if (info != serial_console_info) {
 836		info->tbpr = baud_bpr[i];	/* Tx BPR */
 837		info->tco = baud_co[i];	/* Tx CO */
 838		info->rbpr = baud_bpr[i];	/* Rx BPR */
 839		info->rco = baud_co[i] >> 5;	/* Rx CO */
 840		if (baud_table[i] == 134) {
 841			info->timeout =
 842			    (info->xmit_fifo_size * HZ * 30 / 269) + 2;
 843			/* get it right for 134.5 baud */
 844		} else if (baud_table[i]) {
 845			info->timeout =
 846			    (info->xmit_fifo_size * HZ * 15 / baud_table[i]) +
 847			    2;
 848			/* this needs to be propagated into the card info */
 849		} else {
 850			info->timeout = 0;
 851		}
 852	}
 853	/* By tradition (is it a standard?) a baud rate of zero
 854	   implies the line should be/has been closed.  A bit
 855	   later in this routine such a test is performed. */
 856
 857	/* byte size and parity */
 858	info->cor7 = 0;
 859	info->cor6 = 0;
 860	info->cor5 = 0;
 861	info->cor4 = (info->default_threshold ? info->default_threshold : baud_cor4[i]);	/* receive threshold */
 862	/* Following two lines added 101295, RGH. */
 863	/* It is obviously wrong to access CyCORx, and not info->corx here,
 864	 * try and remember to fix it later! */
 865	channel = info->line;
 866	base_addr[CyCAR] = (u_char) channel;
 867	if (C_CLOCAL(info->tty)) {
 868		if (base_addr[CyIER] & CyMdmCh)
 869			base_addr[CyIER] &= ~CyMdmCh;	/* without modem intr */
 870		/* ignore 1->0 modem transitions */
 871		if (base_addr[CyCOR4] & (CyDSR | CyCTS | CyDCD))
 872			base_addr[CyCOR4] &= ~(CyDSR | CyCTS | CyDCD);
 873		/* ignore 0->1 modem transitions */
 874		if (base_addr[CyCOR5] & (CyDSR | CyCTS | CyDCD))
 875			base_addr[CyCOR5] &= ~(CyDSR | CyCTS | CyDCD);
 876	} else {
 877		if ((base_addr[CyIER] & CyMdmCh) != CyMdmCh)
 878			base_addr[CyIER] |= CyMdmCh;	/* with modem intr */
 879		/* act on 1->0 modem transitions */
 880		if ((base_addr[CyCOR4] & (CyDSR | CyCTS | CyDCD)) !=
 881		    (CyDSR | CyCTS | CyDCD))
 882			base_addr[CyCOR4] |= CyDSR | CyCTS | CyDCD;
 883		/* act on 0->1 modem transitions */
 884		if ((base_addr[CyCOR5] & (CyDSR | CyCTS | CyDCD)) !=
 885		    (CyDSR | CyCTS | CyDCD))
 886			base_addr[CyCOR5] |= CyDSR | CyCTS | CyDCD;
 887	}
 888	info->cor3 = (cflag & CSTOPB) ? Cy_2_STOP : Cy_1_STOP;
 889	info->cor2 = CyETC;
 890	switch (cflag & CSIZE) {
 891	case CS5:
 892		info->cor1 = Cy_5_BITS;
 893		break;
 894	case CS6:
 895		info->cor1 = Cy_6_BITS;
 896		break;
 897	case CS7:
 898		info->cor1 = Cy_7_BITS;
 899		break;
 900	case CS8:
 901		info->cor1 = Cy_8_BITS;
 902		break;
 903	}
 904	if (cflag & PARENB) {
 905		if (cflag & PARODD) {
 906			info->cor1 |= CyPARITY_O;
 907		} else {
 908			info->cor1 |= CyPARITY_E;
 909		}
 910	} else {
 911		info->cor1 |= CyPARITY_NONE;
 912	}
 913
 914	/* CTS flow control flag */
 915#if 0
 916	/* Don't complcate matters for now! RGH 141095 */
 917	if (cflag & CRTSCTS) {
 918		info->flags |= ASYNC_CTS_FLOW;
 919		info->cor2 |= CyCtsAE;
 920	} else {
 921		info->flags &= ~ASYNC_CTS_FLOW;
 922		info->cor2 &= ~CyCtsAE;
 923	}
 924#endif
 925	if (cflag & CLOCAL)
 926		info->flags &= ~ASYNC_CHECK_CD;
 927	else
 928		info->flags |= ASYNC_CHECK_CD;
 929
 930     /***********************************************
 931	The hardware option, CyRtsAO, presents RTS when
 932	the chip has characters to send.  Since most modems
 933	use RTS as reverse (inbound) flow control, this
 934	option is not used.  If inbound flow control is
 935	necessary, DTR can be programmed to provide the
 936	appropriate signals for use with a non-standard
 937	cable.  Contact Marcio Saito for details.
 938     ***********************************************/
 939
 940	channel = info->line;
 941
 942	local_irq_save(flags);
 943	base_addr[CyCAR] = (u_char) channel;
 944
 945	/* CyCMR set once only in mvme167_init_serial() */
 946	if (base_addr[CyLICR] != channel << 2)
 947		base_addr[CyLICR] = channel << 2;
 948	if (base_addr[CyLIVR] != 0x5c)
 949		base_addr[CyLIVR] = 0x5c;
 950
 951	/* tx and rx baud rate */
 952
 953	if (base_addr[CyCOR1] != info->cor1)
 954		need_init_chan = 1;
 955	if (base_addr[CyTCOR] != info->tco)
 956		base_addr[CyTCOR] = info->tco;
 957	if (base_addr[CyTBPR] != info->tbpr)
 958		base_addr[CyTBPR] = info->tbpr;
 959	if (base_addr[CyRCOR] != info->rco)
 960		base_addr[CyRCOR] = info->rco;
 961	if (base_addr[CyRBPR] != info->rbpr)
 962		base_addr[CyRBPR] = info->rbpr;
 963
 964	/* set line characteristics  according configuration */
 965
 966	if (base_addr[CySCHR1] != START_CHAR(info->tty))
 967		base_addr[CySCHR1] = START_CHAR(info->tty);
 968	if (base_addr[CySCHR2] != STOP_CHAR(info->tty))
 969		base_addr[CySCHR2] = STOP_CHAR(info->tty);
 970	if (base_addr[CySCRL] != START_CHAR(info->tty))
 971		base_addr[CySCRL] = START_CHAR(info->tty);
 972	if (base_addr[CySCRH] != START_CHAR(info->tty))
 973		base_addr[CySCRH] = START_CHAR(info->tty);
 974	if (base_addr[CyCOR1] != info->cor1)
 975		base_addr[CyCOR1] = info->cor1;
 976	if (base_addr[CyCOR2] != info->cor2)
 977		base_addr[CyCOR2] = info->cor2;
 978	if (base_addr[CyCOR3] != info->cor3)
 979		base_addr[CyCOR3] = info->cor3;
 980	if (base_addr[CyCOR4] != info->cor4)
 981		base_addr[CyCOR4] = info->cor4;
 982	if (base_addr[CyCOR5] != info->cor5)
 983		base_addr[CyCOR5] = info->cor5;
 984	if (base_addr[CyCOR6] != info->cor6)
 985		base_addr[CyCOR6] = info->cor6;
 986	if (base_addr[CyCOR7] != info->cor7)
 987		base_addr[CyCOR7] = info->cor7;
 988
 989	if (need_init_chan)
 990		write_cy_cmd(base_addr, CyINIT_CHAN);
 991
 992	base_addr[CyCAR] = (u_char) channel;	/* !!! Is this needed? */
 993
 994	/* 2ms default rx timeout */
 995	ti = info->default_timeout ? info->default_timeout : 0x02;
 996	if (base_addr[CyRTPRL] != ti)
 997		base_addr[CyRTPRL] = ti;
 998	if (base_addr[CyRTPRH] != 0)
 999		base_addr[CyRTPRH] = 0;
1000
1001	/* Set up RTS here also ????? RGH 141095 */
1002	if (i == 0) {		/* baud rate is zero, turn off line */
1003		if ((base_addr[CyMSVR2] & CyDTR) == CyDTR)
1004			base_addr[CyMSVR2] = 0;
1005#ifdef SERIAL_DEBUG_DTR
1006		printk("cyc: %d: dropping DTR\n", __LINE__);
1007		printk("     status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1008		       base_addr[CyMSVR2]);
1009#endif
1010	} else {
1011		if ((base_addr[CyMSVR2] & CyDTR) != CyDTR)
1012			base_addr[CyMSVR2] = CyDTR;
1013#ifdef SERIAL_DEBUG_DTR
1014		printk("cyc: %d: raising DTR\n", __LINE__);
1015		printk("     status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1016		       base_addr[CyMSVR2]);
1017#endif
1018	}
1019
1020	if (info->tty) {
1021		clear_bit(TTY_IO_ERROR, &info->tty->flags);
1022	}
1023
1024	local_irq_restore(flags);
1025
1026}				/* config_setup */
1027
1028static int cy_put_char(struct tty_struct *tty, unsigned char ch)
1029{
1030	struct cyclades_port *info = tty->driver_data;
1031	unsigned long flags;
1032
1033#ifdef SERIAL_DEBUG_IO
1034	printk("cy_put_char %s(0x%02x)\n", tty->name, ch);
1035#endif
1036
1037	if (serial_paranoia_check(info, tty->name, "cy_put_char"))
1038		return 0;
1039
1040	if (!info->xmit_buf)
1041		return 0;
1042
1043	local_irq_save(flags);
1044	if (info->xmit_cnt >= PAGE_SIZE - 1) {
1045		local_irq_restore(flags);
1046		return 0;
1047	}
1048
1049	info->xmit_buf[info->xmit_head++] = ch;
1050	info->xmit_head &= PAGE_SIZE - 1;
1051	info->xmit_cnt++;
1052	local_irq_restore(flags);
1053	return 1;
1054}				/* cy_put_char */
1055
1056static void cy_flush_chars(struct tty_struct *tty)
1057{
1058	struct cyclades_port *info = tty->driver_data;
1059	unsigned long flags;
1060	volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1061	int channel;
1062
1063#ifdef SERIAL_DEBUG_IO
1064	printk("cy_flush_chars %s\n", tty->name);	/* */
1065#endif
1066
1067	if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1068		return;
1069
1070	if (info->xmit_cnt <= 0 || tty->stopped
1071	    || tty->hw_stopped || !info->xmit_buf)
1072		return;
1073
1074	channel = info->line;
1075
1076	local_irq_save(flags);
1077	base_addr[CyCAR] = channel;
1078	base_addr[CyIER] |= CyTxMpty;
1079	local_irq_restore(flags);
1080}				/* cy_flush_chars */
1081
1082/* This routine gets called when tty_write has put something into
1083    the write_queue.  If the port is not already transmitting stuff,
1084    start it off by enabling interrupts.  The interrupt service
1085    routine will then ensure that the characters are sent.  If the
1086    port is already active, there is no need to kick it.
1087 */
1088static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
1089{
1090	struct cyclades_port *info = tty->driver_data;
1091	unsigned long flags;
1092	int c, total = 0;
1093
1094#ifdef SERIAL_DEBUG_IO
1095	printk("cy_write %s\n", tty->name);	/* */
1096#endif
1097
1098	if (serial_paranoia_check(info, tty->name, "cy_write")) {
1099		return 0;
1100	}
1101
1102	if (!info->xmit_buf) {
1103		return 0;
1104	}
1105
1106	while (1) {
1107		local_irq_save(flags);
1108		c = min_t(int, count, min(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
1109					  SERIAL_XMIT_SIZE - info->xmit_head));
1110		if (c <= 0) {
1111			local_irq_restore(flags);
1112			break;
1113		}
1114
1115		memcpy(info->xmit_buf + info->xmit_head, buf, c);
1116		info->xmit_head =
1117		    (info->xmit_head + c) & (SERIAL_XMIT_SIZE - 1);
1118		info->xmit_cnt += c;
1119		local_irq_restore(flags);
1120
1121		buf += c;
1122		count -= c;
1123		total += c;
1124	}
1125
1126	if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
1127		start_xmit(info);
1128	}
1129	return total;
1130}				/* cy_write */
1131
1132static int cy_write_room(struct tty_struct *tty)
1133{
1134	struct cyclades_port *info = tty->driver_data;
1135	int ret;
1136
1137#ifdef SERIAL_DEBUG_IO
1138	printk("cy_write_room %s\n", tty->name);	/* */
1139#endif
1140
1141	if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1142		return 0;
1143	ret = PAGE_SIZE - info->xmit_cnt - 1;
1144	if (ret < 0)
1145		ret = 0;
1146	return ret;
1147}				/* cy_write_room */
1148
1149static int cy_chars_in_buffer(struct tty_struct *tty)
1150{
1151	struct cyclades_port *info = tty->driver_data;
1152
1153#ifdef SERIAL_DEBUG_IO
1154	printk("cy_chars_in_buffer %s %d\n", tty->name, info->xmit_cnt);	/* */
1155#endif
1156
1157	if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1158		return 0;
1159
1160	return info->xmit_cnt;
1161}				/* cy_chars_in_buffer */
1162
1163static void cy_flush_buffer(struct tty_struct *tty)
1164{
1165	struct cyclades_port *info = tty->driver_data;
1166	unsigned long flags;
1167
1168#ifdef SERIAL_DEBUG_IO
1169	printk("cy_flush_buffer %s\n", tty->name);	/* */
1170#endif
1171
1172	if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1173		return;
1174	local_irq_save(flags);
1175	info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1176	local_irq_restore(flags);
1177	tty_wakeup(tty);
1178}				/* cy_flush_buffer */
1179
1180/* This routine is called by the upper-layer tty layer to signal
1181   that incoming characters should be throttled or that the
1182   throttle should be released.
1183 */
1184static void cy_throttle(struct tty_struct *tty)
1185{
1186	struct cyclades_port *info = tty->driver_data;
1187	unsigned long flags;
1188	volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1189	int channel;
1190
1191#ifdef SERIAL_DEBUG_THROTTLE
1192	char buf[64];
1193
1194	printk("throttle %s: %d....\n", tty_name(tty, buf),
1195	       tty->ldisc.chars_in_buffer(tty));
1196	printk("cy_throttle %s\n", tty->name);
1197#endif
1198
1199	if (serial_paranoia_check(info, tty->name, "cy_nthrottle")) {
1200		return;
1201	}
1202
1203	if (I_IXOFF(tty)) {
1204		info->x_char = STOP_CHAR(tty);
1205		/* Should use the "Send Special Character" feature!!! */
1206	}
1207
1208	channel = info->line;
1209
1210	local_irq_save(flags);
1211	base_addr[CyCAR] = (u_char) channel;
1212	base_addr[CyMSVR1] = 0;
1213	local_irq_restore(flags);
1214}				/* cy_throttle */
1215
1216static void cy_unthrottle(struct tty_struct *tty)
1217{
1218	struct cyclades_port *info = tty->driver_data;
1219	unsigned long flags;
1220	volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1221	int channel;
1222
1223#ifdef SERIAL_DEBUG_THROTTLE
1224	char buf[64];
1225
1226	printk("throttle %s: %d....\n", tty_name(tty, buf),
1227	       tty->ldisc.chars_in_buffer(tty));
1228	printk("cy_unthrottle %s\n", tty->name);
1229#endif
1230
1231	if (serial_paranoia_check(info, tty->name, "cy_nthrottle")) {
1232		return;
1233	}
1234
1235	if (I_IXOFF(tty)) {
1236		info->x_char = START_CHAR(tty);
1237		/* Should use the "Send Special Character" feature!!! */
1238	}
1239
1240	channel = info->line;
1241
1242	local_irq_save(flags);
1243	base_addr[CyCAR] = (u_char) channel;
1244	base_addr[CyMSVR1] = CyRTS;
1245	local_irq_restore(flags);
1246}				/* cy_unthrottle */
1247
1248static int
1249get_serial_info(struct cyclades_port *info,
1250		struct serial_struct __user * retinfo)
1251{
1252	struct serial_struct tmp;
1253
1254/* CP('g'); */
1255	if (!retinfo)
1256		return -EFAULT;
1257	memset(&tmp, 0, sizeof(tmp));
1258	tmp.type = info->type;
1259	tmp.line = info->line;
1260	tmp.port = info->line;
1261	tmp.irq = 0;
1262	tmp.flags = info->flags;
1263	tmp.baud_base = 0;	/*!!! */
1264	tmp.close_delay = info->close_delay;
1265	tmp.custom_divisor = 0;	/*!!! */
1266	tmp.hub6 = 0;		/*!!! */
1267	return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
1268}				/* get_serial_info */
1269
1270static int
1271set_serial_info(struct cyclades_port *info,
1272		struct serial_struct __user * new_info)
1273{
1274	struct serial_struct new_serial;
1275	struct cyclades_port old_info;
1276
1277/* CP('s'); */
1278	if (!new_info)
1279		return -EFAULT;
1280	if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
1281		return -EFAULT;
1282	old_info = *info;
1283
1284	if (!capable(CAP_SYS_ADMIN)) {
1285		if ((new_serial.close_delay != info->close_delay) ||
1286		    ((new_serial.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK) !=
1287		     (info->flags & ASYNC_FLAGS & ~ASYNC_USR_MASK)))
1288			return -EPERM;
1289		info->flags = ((info->flags & ~ASYNC_USR_MASK) |
1290			       (new_serial.flags & ASYNC_USR_MASK));
1291		goto check_and_exit;
1292	}
1293
1294	/*
1295	 * OK, past this point, all the error checking has been done.
1296	 * At this point, we start making changes.....
1297	 */
1298
1299	info->flags = ((info->flags & ~ASYNC_FLAGS) |
1300		       (new_serial.flags & ASYNC_FLAGS));
1301	info->close_delay = new_serial.close_delay;
1302
1303check_and_exit:
1304	if (info->flags & ASYNC_INITIALIZED) {
1305		config_setup(info);
1306		return 0;
1307	}
1308	return startup(info);
1309}				/* set_serial_info */
1310
1311static int cy_tiocmget(struct tty_struct *tty)
1312{
1313	struct cyclades_port *info = tty->driver_data;
1314	int channel;
1315	volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1316	unsigned long flags;
1317	unsigned char status;
1318
1319	channel = info->line;
1320
1321	local_irq_save(flags);
1322	base_addr[CyCAR] = (u_char) channel;
1323	status = base_addr[CyMSVR1] | base_addr[CyMSVR2];
1324	local_irq_restore(flags);
1325
1326	return ((status & CyRTS) ? TIOCM_RTS : 0)
1327	    | ((status & CyDTR) ? TIOCM_DTR : 0)
1328	    | ((status & CyDCD) ? TIOCM_CAR : 0)
1329	    | ((status & CyDSR) ? TIOCM_DSR : 0)
1330	    | ((status & CyCTS) ? TIOCM_CTS : 0);
1331}				/* cy_tiocmget */
1332
1333static int
1334cy_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear)
1335{
1336	struct cyclades_port *info = tty->driver_data;
1337	int channel;
1338	volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1339	unsigned long flags;
1340
1341	channel = info->line;
1342
1343	if (set & TIOCM_RTS) {
1344		local_irq_save(flags);
1345		base_addr[CyCAR] = (u_char) channel;
1346		base_addr[CyMSVR1] = CyRTS;
1347		local_irq_restore(flags);
1348	}
1349	if (set & TIOCM_DTR) {
1350		local_irq_save(flags);
1351		base_addr[CyCAR] = (u_char) channel;
1352/* CP('S');CP('2'); */
1353		base_addr[CyMSVR2] = CyDTR;
1354#ifdef SERIAL_DEBUG_DTR
1355		printk("cyc: %d: raising DTR\n", __LINE__);
1356		printk("     status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1357		       base_addr[CyMSVR2]);
1358#endif
1359		local_irq_restore(flags);
1360	}
1361
1362	if (clear & TIOCM_RTS) {
1363		local_irq_save(flags);
1364		base_addr[CyCAR] = (u_char) channel;
1365		base_addr[CyMSVR1] = 0;
1366		local_irq_restore(flags);
1367	}
1368	if (clear & TIOCM_DTR) {
1369		local_irq_save(flags);
1370		base_addr[CyCAR] = (u_char) channel;
1371/* CP('C');CP('2'); */
1372		base_addr[CyMSVR2] = 0;
1373#ifdef SERIAL_DEBUG_DTR
1374		printk("cyc: %d: dropping DTR\n", __LINE__);
1375		printk("     status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1376		       base_addr[CyMSVR2]);
1377#endif
1378		local_irq_restore(flags);
1379	}
1380
1381	return 0;
1382}				/* set_modem_info */
1383
1384static void send_break(struct cyclades_port *info, int duration)
1385{				/* Let the transmit ISR take care of this (since it
1386				   requires stuffing characters into the output stream).
1387				 */
1388	info->x_break = duration;
1389	if (!info->xmit_cnt) {
1390		start_xmit(info);
1391	}
1392}				/* send_break */
1393
1394static int
1395get_mon_info(struct cyclades_port *info, struct cyclades_monitor __user * mon)
1396{
1397
1398	if (copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
1399		return -EFAULT;
1400	info->mon.int_count = 0;
1401	info->mon.char_count = 0;
1402	info->mon.char_max = 0;
1403	info->mon.char_last = 0;
1404	return 0;
1405}
1406
1407static int set_threshold(struct cyclades_port *info, unsigned long __user * arg)
1408{
1409	volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1410	unsigned long value;
1411	int channel;
1412
1413	if (get_user(value, arg))
1414		return -EFAULT;
1415
1416	channel = info->line;
1417	info->cor4 &= ~CyREC_FIFO;
1418	info->cor4 |= value & CyREC_FIFO;
1419	base_addr[CyCOR4] = info->cor4;
1420	return 0;
1421}
1422
1423static int
1424get_threshold(struct cyclades_port *info, unsigned long __user * value)
1425{
1426	volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1427	int channel;
1428	unsigned long tmp;
1429
1430	channel = info->line;
1431
1432	tmp = base_addr[CyCOR4] & CyREC_FIFO;
1433	return put_user(tmp, value);
1434}
1435
1436static int
1437set_default_threshold(struct cyclades_port *info, unsigned long __user * arg)
1438{
1439	unsigned long value;
1440
1441	if (get_user(value, arg))
1442		return -EFAULT;
1443
1444	info->default_threshold = value & 0x0f;
1445	return 0;
1446}
1447
1448static int
1449get_default_threshold(struct cyclades_port *info, unsigned long __user * value)
1450{
1451	return put_user(info->default_threshold, value);
1452}
1453
1454static int set_timeout(struct cyclades_port *info, unsigned long __user * arg)
1455{
1456	volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1457	int channel;
1458	unsigned long value;
1459
1460	if (get_user(value, arg))
1461		return -EFAULT;
1462
1463	channel = info->line;
1464
1465	base_addr[CyRTPRL] = value & 0xff;
1466	base_addr[CyRTPRH] = (value >> 8) & 0xff;
1467	return 0;
1468}
1469
1470static int get_timeout(struct cyclades_port *info, unsigned long __user * value)
1471{
1472	volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1473	int channel;
1474	unsigned long tmp;
1475
1476	channel = info->line;
1477
1478	tmp = base_addr[CyRTPRL];
1479	return put_user(tmp, value);
1480}
1481
1482static int set_default_timeout(struct cyclades_port *info, unsigned long value)
1483{
1484	info->default_timeout = value & 0xff;
1485	return 0;
1486}
1487
1488static int
1489get_default_timeout(struct cyclades_port *info, unsigned long __user * value)
1490{
1491	return put_user(info->default_timeout, value);
1492}
1493
1494static int
1495cy_ioctl(struct tty_struct *tty,
1496	 unsigned int cmd, unsigned long arg)
1497{
1498	struct cyclades_port *info = tty->driver_data;
1499	int ret_val = 0;
1500	void __user *argp = (void __user *)arg;
1501
1502#ifdef SERIAL_DEBUG_OTHER
1503	printk("cy_ioctl %s, cmd = %x arg = %lx\n", tty->name, cmd, arg);	/* */
1504#endif
1505
1506	tty_lock();
1507
1508	switch (cmd) {
1509	case CYGETMON:
1510		ret_val = get_mon_info(info, argp);
1511		break;
1512	case CYGETTHRESH:
1513		ret_val = get_threshold(info, argp);
1514		break;
1515	case CYSETTHRESH:
1516		ret_val = set_threshold(info, argp);
1517		break;
1518	case CYGETDEFTHRESH:
1519		ret_val = get_default_threshold(info, argp);
1520		break;
1521	case CYSETDEFTHRESH:
1522		ret_val = set_default_threshold(info, argp);
1523		break;
1524	case CYGETTIMEOUT:
1525		ret_val = get_timeout(info, argp);
1526		break;
1527	case CYSETTIMEOUT:
1528		ret_val = set_timeout(info, argp);
1529		break;
1530	case CYGETDEFTIMEOUT:
1531		ret_val = get_default_timeout(info, argp);
1532		break;
1533	case CYSETDEFTIMEOUT:
1534		ret_val = set_default_timeout(info, (unsigned long)arg);
1535		break;
1536	case TCSBRK:		/* SVID version: non-zero arg --> no break */
1537		ret_val = tty_check_change(tty);
1538		if (ret_val)
1539			break;
1540		tty_wait_until_sent(tty, 0);
1541		if (!arg)
1542			send_break(info, HZ / 4);	/* 1/4 second */
1543		break;
1544	case TCSBRKP:		/* support for POSIX tcsendbreak() */
1545		ret_val = tty_check_change(tty);
1546		if (ret_val)
1547			break;
1548		tty_wait_until_sent(tty, 0);
1549		send_break(info, arg ? arg * (HZ / 10) : HZ / 4);
1550		break;
1551
1552/* The following commands are incompletely implemented!!! */
1553	case TIOCGSERIAL:
1554		ret_val = get_serial_info(info, argp);
1555		break;
1556	case TIOCSSERIAL:
1557		ret_val = set_serial_info(info, argp);
1558		break;
1559	default:
1560		ret_val = -ENOIOCTLCMD;
1561	}
1562	tty_unlock();
1563
1564#ifdef SERIAL_DEBUG_OTHER
1565	printk("cy_ioctl done\n");
1566#endif
1567
1568	return ret_val;
1569}				/* cy_ioctl */
1570
1571static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
1572{
1573	struct cyclades_port *info = tty->driver_data;
1574
1575#ifdef SERIAL_DEBUG_OTHER
1576	printk("cy_set_termios %s\n", tty->name);
1577#endif
1578
1579	if (tty->termios->c_cflag == old_termios->c_cflag)
1580		return;
1581	config_setup(info);
1582
1583	if ((old_termios->c_cflag & CRTSCTS) &&
1584	    !(tty->termios->c_cflag & CRTSCTS)) {
1585		tty->stopped = 0;
1586		cy_start(tty);
1587	}
1588#ifdef tytso_patch_94Nov25_1726
1589	if (!(old_termios->c_cflag & CLOCAL) &&
1590	    (tty->termios->c_cflag & CLOCAL))
1591		wake_up_interruptible(&info->open_wait);
1592#endif
1593}				/* cy_set_termios */
1594
1595static void cy_close(struct tty_struct *tty, struct file *filp)
1596{
1597	struct cyclades_port *info = tty->driver_data;
1598
1599/* CP('C'); */
1600#ifdef SERIAL_DEBUG_OTHER
1601	printk("cy_close %s\n", tty->name);
1602#endif
1603
1604	if (!info || serial_paranoia_check(info, tty->name, "cy_close")) {
1605		return;
1606	}
1607#ifdef SERIAL_DEBUG_OPEN
1608	printk("cy_close %s, count = %d\n", tty->name, info->count);
1609#endif
1610
1611	if ((tty->count == 1) && (info->count != 1)) {
1612		/*
1613		 * Uh, oh.  tty->count is 1, which means that the tty
1614		 * structure will be freed.  Info->count should always
1615		 * be one in these conditions.  If it's greater than
1616		 * one, we've got real problems, since it means the
1617		 * serial port won't be shutdown.
1618		 */
1619		printk("cy_close: bad serial port count; tty->count is 1, "
1620		       "info->count is %d\n", info->count);
1621		info->count = 1;
1622	}
1623#ifdef SERIAL_DEBUG_COUNT
1624	printk("cyc: %d: decrementing count to %d\n", __LINE__,
1625	       info->count - 1);
1626#endif
1627	if (--info->count < 0) {
1628		printk("cy_close: bad serial port count for ttys%d: %d\n",
1629		       info->line, info->count);
1630#ifdef SERIAL_DEBUG_COUNT
1631		printk("cyc: %d: setting count to 0\n", __LINE__);
1632#endif
1633		info->count = 0;
1634	}
1635	if (info->count)
1636		return;
1637	info->flags |= ASYNC_CLOSING;
1638	if (info->flags & ASYNC_INITIALIZED)
1639		tty_wait_until_sent(tty, 3000);	/* 30 seconds timeout */
1640	shutdown(info);
1641	cy_flush_buffer(tty);
1642	tty_ldisc_flush(tty);
1643	info->tty = NULL;
1644	if (info->blocked_open) {
1645		if (info->close_delay) {
1646			msleep_interruptible(jiffies_to_msecs
1647					     (info->close_delay));
1648		}
1649		wake_up_interruptible(&info->open_wait);
1650	}
1651	info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
1652	wake_up_interruptible(&info->close_wait);
1653
1654#ifdef SERIAL_DEBUG_OTHER
1655	printk("cy_close done\n");
1656#endif
1657}				/* cy_close */
1658
1659/*
1660 * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
1661 */
1662void cy_hangup(struct tty_struct *tty)
1663{
1664	struct cyclades_port *info = tty->driver_data;
1665
1666#ifdef SERIAL_DEBUG_OTHER
1667	printk("cy_hangup %s\n", tty->name);	/* */
1668#endif
1669
1670	if (serial_paranoia_check(info, tty->name, "cy_hangup"))
1671		return;
1672
1673	shutdown(info);
1674#if 0
1675	info->event = 0;
1676	info->count = 0;
1677#ifdef SERIAL_DEBUG_COUNT
1678	printk("cyc: %d: setting count to 0\n", __LINE__);
1679#endif
1680	info->tty = 0;
1681#endif
1682	info->flags &= ~ASYNC_NORMAL_ACTIVE;
1683	wake_up_interruptible(&info->open_wait);
1684}				/* cy_hangup */
1685
1686/*
1687 * ------------------------------------------------------------
1688 * cy_open() and friends
1689 * ------------------------------------------------------------
1690 */
1691
1692static int
1693block_til_ready(struct tty_struct *tty, struct file *filp,
1694		struct cyclades_port *info)
1695{
1696	DECLARE_WAITQUEUE(wait, current);
1697	unsigned long flags;
1698	int channel;
1699	int retval;
1700	volatile u_char *base_addr = (u_char *) BASE_ADDR;
1701
1702	/*
1703	 * If the device is in the middle of being closed, then block
1704	 * until it's done, and then try again.
1705	 */
1706	if (info->flags & ASYNC_CLOSING) {
1707		interruptible_sleep_on(&info->close_wait);
1708		if (info->flags & ASYNC_HUP_NOTIFY) {
1709			return -EAGAIN;
1710		} else {
1711			return -ERESTARTSYS;
1712		}
1713	}
1714
1715	/*
1716	 * If non-blocking mode is set, then make the check up front
1717	 * and then exit.
1718	 */
1719	if (filp->f_flags & O_NONBLOCK) {
1720		info->flags |= ASYNC_NORMAL_ACTIVE;
1721		return 0;
1722	}
1723
1724	/*
1725	 * Block waiting for the carrier detect and the line to become
1726	 * free (i.e., not in use by the callout).  While we are in
1727	 * this loop, info->count is dropped by one, so that
1728	 * cy_close() knows when to free things.  We restore it upon
1729	 * exit, either normal or abnormal.
1730	 */
1731	retval = 0;
1732	add_wait_queue(&info->open_wait, &wait);
1733#ifdef SERIAL_DEBUG_OPEN
1734	printk("block_til_ready before block: %s, count = %d\n",
1735	       tty->name, info->count);
1736	/**/
1737#endif
1738	    info->count--;
1739#ifdef SERIAL_DEBUG_COUNT
1740	printk("cyc: %d: decrementing count to %d\n", __LINE__, info->count);
1741#endif
1742	info->blocked_open++;
1743
1744	channel = info->line;
1745
1746	while (1) {
1747		local_irq_save(flags);
1748		base_addr[CyCAR] = (u_char) channel;
1749		base_addr[CyMSVR1] = CyRTS;
1750/* CP('S');CP('4'); */
1751		base_addr[CyMSVR2] = CyDTR;
1752#ifdef SERIAL_DEBUG_DTR
1753		printk("cyc: %d: raising DTR\n", __LINE__);
1754		printk("     status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1755		       base_addr[CyMSVR2]);
1756#endif
1757		local_irq_restore(flags);
1758		set_current_state(TASK_INTERRUPTIBLE);
1759		if (tty_hung_up_p(filp)
1760		    || !(info->flags & ASYNC_INITIALIZED)) {
1761			if (info->flags & ASYNC_HUP_NOTIFY) {
1762				retval = -EAGAIN;
1763			} else {
1764				retval = -ERESTARTSYS;
1765			}
1766			break;
1767		}
1768		local_irq_save(flags);
1769		base_addr[CyCAR] = (u_char) channel;
1770/* CP('L');CP1(1 && C_CLOCAL(tty)); CP1(1 && (base_addr[CyMSVR1] & CyDCD) ); */
1771		if (!(info->flags & ASYNC_CLOSING)
1772		    && (C_CLOCAL(tty)
1773			|| (base_addr[CyMSVR1] & CyDCD))) {
1774			local_irq_restore(flags);
1775			break;
1776		}
1777		local_irq_restore(flags);
1778		if (signal_pending(current)) {
1779			retval = -ERESTARTSYS;
1780			break;
1781		}
1782#ifdef SERIAL_DEBUG_OPEN
1783		printk("block_til_ready blocking: %s, count = %d\n",
1784		       tty->name, info->count);
1785		/**/
1786#endif
1787		tty_unlock();
1788		schedule();
1789		tty_lock();
1790	}
1791	__set_current_state(TASK_RUNNING);
1792	remove_wait_queue(&info->open_wait, &wait);
1793	if (!tty_hung_up_p(filp)) {
1794		info->count++;
1795#ifdef SERIAL_DEBUG_COUNT
1796		printk("cyc: %d: incrementing count to %d\n", __LINE__,
1797		       info->count);
1798#endif
1799	}
1800	info->blocked_open--;
1801#ifdef SERIAL_DEBUG_OPEN
1802	printk("block_til_ready after blocking: %s, count = %d\n",
1803	       tty->name, info->count);
1804	/**/
1805#endif
1806	    if (retval)
1807		return retval;
1808	info->flags |= ASYNC_NORMAL_ACTIVE;
1809	return 0;
1810}				/* block_til_ready */
1811
1812/*
1813 * This routine is called whenever a serial port is opened.  It
1814 * performs the serial-specific initialization for the tty structure.
1815 */
1816int cy_open(struct tty_struct *tty, struct file *filp)
1817{
1818	struct cyclades_port *info;
1819	int retval, line;
1820
1821/* CP('O'); */
1822	line = tty->index;
1823	if ((line < 0) || (NR_PORTS <= line)) {
1824		return -ENODEV;
1825	}
1826	info = &cy_port[line];
1827	if (info->line < 0) {
1828		return -ENODEV;
1829	}
1830#ifdef SERIAL_DEBUG_OTHER
1831	printk("cy_open %s\n", tty->name);	/* */
1832#endif
1833	if (serial_paranoia_check(info, tty->name, "cy_open")) {
1834		return -ENODEV;
1835	}
1836#ifdef SERIAL_DEBUG_OPEN
1837	printk("cy_open %s, count = %d\n", tty->name, info->count);
1838	/**/
1839#endif
1840	    info->count++;
1841#ifdef SERIAL_DEBUG_COUNT
1842	printk("cyc: %d: incrementing count to %d\n", __LINE__, info->count);
1843#endif
1844	tty->driver_data = info;
1845	info->tty = tty;
1846
1847	/*
1848	 * Start up serial port
1849	 */
1850	retval = startup(info);
1851	if (retval) {
1852		return retval;
1853	}
1854
1855	retval = block_til_ready(tty, filp, info);
1856	if (retval) {
1857#ifdef SERIAL_DEBUG_OPEN
1858		printk("cy_open returning after block_til_ready with %d\n",
1859		       retval);
1860#endif
1861		return retval;
1862	}
1863#ifdef SERIAL_DEBUG_OPEN
1864	printk("cy_open done\n");
1865	/**/
1866#endif
1867	    return 0;
1868}				/* cy_open */
1869
1870/*
1871 * ---------------------------------------------------------------------
1872 * serial167_init() and friends
1873 *
1874 * serial167_init() is called at boot-time to initialize the serial driver.
1875 * ---------------------------------------------------------------------
1876 */
1877
1878/*
1879 * This routine prints out the appropriate serial driver version
1880 * number, and identifies which options were configured into this
1881 * driver.
1882 */
1883static void show_version(void)
1884{
1885	printk("MVME166/167 cd2401 driver\n");
1886}				/* show_version */
1887
1888/* initialize chips on card -- return number of valid
1889   chips (which is number of ports/4) */
1890
1891/*
1892 * This initialises the hardware to a reasonable state.  It should
1893 * probe the chip first so as to copy 166-Bug setup as a default for
1894 * port 0.  It initialises CMR to CyASYNC; that is never done again, so
1895 * as to limit the number of CyINIT_CHAN commands in normal running.
1896 *
1897 * ... I wonder what I should do if this fails ...
1898 */
1899
1900void mvme167_serial_console_setup(int cflag)
1901{
1902	volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1903	int ch;
1904	u_char spd;
1905	u_char rcor, rbpr, badspeed = 0;
1906	unsigned long flags;
1907
1908	local_irq_save(flags);
1909
1910	/*
1911	 * First probe channel zero of the chip, to see what speed has
1912	 * been selected.
1913	 */
1914
1915	base_addr[CyCAR] = 0;
1916
1917	rcor = base_addr[CyRCOR] << 5;
1918	rbpr = base_addr[CyRBPR];
1919
1920	for (spd = 0; spd < sizeof(baud_bpr); spd++)
1921		if (rbpr == baud_bpr[spd] && rcor == baud_co[spd])
1922			break;
1923	if (spd >= sizeof(baud_bpr)) {
1924		spd = 14;	/* 19200 */
1925		badspeed = 1;	/* Failed to identify speed */
1926	}
1927	initial_console_speed = spd;
1928
1929	/* OK, we have chosen a speed, now reset and reinitialise */
1930
1931	my_udelay(20000L);	/* Allow time for any active o/p to complete */
1932	if (base_addr[CyCCR] != 0x00) {
1933		local_irq_restore(flags);
1934		/* printkā€¦

Large files files are truncated, but you can click here to view the full file