patch-2.4.20 linux-2.4.20/drivers/char/pdc_console.c

• Lines: 682
• Date: Thu Nov 28 15:53:12 2002
• Orig file: linux-2.4.19/drivers/char/pdc_console.c
• Orig date: Wed Dec 31 16:00:00 1969

diff -urN linux-2.4.19/drivers/char/pdc_console.c linux-2.4.20/drivers/char/pdc_console.c
@@ -0,0 +1,681 @@
+/*
+ *  linux/drivers/char/pdc_console.c
+ *
+ *  2001, Christoph Plattner
+ * 
+ *  Driver template was linux's serial.c
+ *
+ */
+
+static char *pdc_drv_version = "0.3";
+static char *pdc_drv_revdate = "2001-11-17";
+#define AUTHOR "christoph.plattner@gmx.at"
+#include <linux/config.h>
+#include <linux/version.h>
+
+#undef PDC_DRV_DEBUG
+
+#undef SERIAL_PARANOIA_CHECK
+#define CONFIG_SERIAL_NOPAUSE_IO
+#define SERIAL_DO_RESTART
+
+#define PDC_POLL_DELAY (30 * HZ / 1000)
+
+/*
+ * End of serial driver configuration section.
+ */
+
+#include <linux/module.h>
+
+#include <linux/types.h>
+#include <linux/serial.h>
+#include <linux/serialP.h>
+#include <linux/serial_reg.h>
+#include <asm/serial.h>
+#define LOCAL_VERSTRING ""
+
+#include <linux/errno.h>
+#include <linux/signal.h>
+#include <linux/sched.h>
+#include <linux/timer.h>
+#include <linux/interrupt.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/major.h>
+#include <linux/string.h>
+#include <linux/fcntl.h>
+#include <linux/ptrace.h>
+#include <linux/ioport.h>
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <asm/uaccess.h>
+#include <linux/delay.h>
+
+#include <asm/system.h>
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/bitops.h>
+
+#ifdef CONFIG_GSC
+#include <asm/gsc.h>
+#endif
+
+extern int pdc_console_poll_key(void *);
+extern void pdc_outc(unsigned char);
+
+static char *pdc_drv_name = "PDC Software Console";
+
+static struct tty_driver pdc_drv_driver;
+static int pdc_drv_refcount = 0;
+static struct async_struct *pdc_drv_info;
+
+static struct timer_list pdc_drv_timer;
+
+/* serial subtype definitions */
+#ifndef SERIAL_TYPE_NORMAL
+#define SERIAL_TYPE_NORMAL	1
+#define SERIAL_TYPE_CALLOUT	2
+#endif
+
+#define NR_PORTS 1
+#define PDC_DUMMY_BUF 2048
+
+static struct tty_struct *pdc_drv_table[NR_PORTS];
+static struct termios *pdc_drv_termios[NR_PORTS];
+static struct termios *pdc_drv_termios_locked[NR_PORTS];
+
+/*
+ * tmp_buf is used as a temporary buffer by serial_write.  We need to
+ * lock it in case the copy_from_user blocks while swapping in a page,
+ * and some other program tries to do a serial write at the same time.
+ * Since the lock will only come under contention when the system is
+ * swapping and available memory is low, it makes sense to share one
+ * buffer across all the serial ports, since it significantly saves
+ * memory if large numbers of serial ports are open.
+ */
+static unsigned char *tmp_buf;
+#ifdef DECLARE_MUTEX
+static DECLARE_MUTEX(tmp_buf_sem);
+#else
+static struct semaphore tmp_buf_sem = MUTEX;
+#endif
+
+/*
+ * ------------------------------------------------------------
+ * pdc_stop() and pdc_start()
+ *
+ * This routines are called before setting or resetting tty->stopped.
+ * They enable or disable transmitter interrupts, as necessary.
+ * ------------------------------------------------------------
+ */
+static void
+pdc_stop(struct tty_struct *tty)
+{
+}
+
+static void
+pdc_start(struct tty_struct *tty)
+{
+}
+
+/*
+ * ----------------------------------------------------------------------
+ *
+ * Here starts the interrupt handling routines.  All of the following
+ * subroutines are declared as inline and are folded into
+ * rs_interrupt().  They were separated out for readability's sake.
+ *
+ * Note: rs_interrupt() is a "fast" interrupt, which means that it
+ * runs with interrupts turned off.  People who may want to modify
+ * rs_interrupt() should try to keep the interrupt handler as fast as
+ * possible.  After you are done making modifications, it is not a bad
+ * idea to do:
+ * 
+ * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
+ *
+ * and look at the resulting assemble code in serial.s.
+ *
+ * 				- Ted Ts'o (tytso@mit.edu), 7-Mar-93
+ * -----------------------------------------------------------------------
+ */
+
+static void
+receive_chars(struct async_struct *info, int *status, struct pt_regs *regs)
+{
+	struct tty_struct *tty = info->tty;
+	unsigned char ch;
+	int __ch;
+
+	while (1) {
+		__ch = pdc_console_poll_key(NULL);
+
+		if (__ch == -1)	/* no character available */
+			break;
+
+		ch = (unsigned char) ((unsigned) __ch & 0x000000ffu);
+
+		if (tty->flip.count >= TTY_FLIPBUF_SIZE)
+			continue;
+
+		*tty->flip.char_buf_ptr = ch;
+		*tty->flip.flag_buf_ptr = 0;
+
+		tty->flip.flag_buf_ptr++;
+		tty->flip.char_buf_ptr++;
+		tty->flip.count++;
+	}
+
+	tty_flip_buffer_push(tty);
+}
+
+static void
+pdc_drv_poll(unsigned long dummy)
+{
+	struct async_struct *info;
+	int status = 0;
+
+	info = pdc_drv_info;
+
+	if (!info || !info->tty || (pdc_drv_refcount == 0)) {
+		/* do nothing */
+	} else {
+		receive_chars(info, &status, NULL);
+		info->last_active = jiffies;
+	}
+
+	mod_timer(&pdc_drv_timer, jiffies + PDC_POLL_DELAY);
+}
+
+static void
+pdc_put_char(struct tty_struct *tty, unsigned char ch)
+{
+#ifdef PDC_DRV_DEBUG
+	printk(KERN_NOTICE "[%s] %c return\n", __FUNCTION__, ch);
+#endif
+	pdc_outc(ch);
+}
+
+static void
+pdc_flush_chars(struct tty_struct *tty)
+{
+	/* PCD console always flushed all characters */
+
+#ifdef PDC_DRV_DEBUG
+	printk(KERN_NOTICE "[%s] return\n", __FUNCTION__);
+#endif
+
+	/* nothing to do */
+}
+
+static int
+pdc_write(struct tty_struct *tty, int from_user,
+	  const unsigned char *buf, int count)
+{
+	char pdc_tmp_buf[PDC_DUMMY_BUF];
+	char *pdc_tmp_buf_ptr;
+	int len;
+	int ret = 0;
+
+#ifdef PDC_DRV_DEBUG
+	printk(KERN_NOTICE "[%s] entry\n", __FUNCTION__);
+#endif
+	while (count) {
+		if (count < PDC_DUMMY_BUF)
+			len = count;
+		else
+			len = PDC_DUMMY_BUF;
+
+		if (from_user) {
+			copy_from_user(pdc_tmp_buf, buf, len);
+			pdc_tmp_buf_ptr = pdc_tmp_buf;
+		} else
+			pdc_tmp_buf_ptr = (char *) buf;
+
+		while (len) {
+			pdc_outc(*pdc_tmp_buf_ptr);
+			buf++;
+			pdc_tmp_buf_ptr++;
+			ret++;
+			count--;
+			len--;
+		}
+	}
+#ifdef PDC_DRV_DEBUG
+	printk(KERN_NOTICE "[%s] return\n", __FUNCTION__);
+#endif
+	return ret;
+}
+
+static int
+pdc_write_room(struct tty_struct *tty)
+{
+#ifdef PDC_DRV_DEBUG
+	printk(KERN_NOTICE "[%s] entry\n", __FUNCTION__);
+#endif
+	return PDC_DUMMY_BUF;
+}
+
+static int
+pdc_chars_in_buffer(struct tty_struct *tty)
+{
+#ifdef PDC_DRV_DEBUG
+	printk(KERN_NOTICE "[%s] entry\n", __FUNCTION__);
+#endif
+	return 0;		/* no characters in buffer, always flushed ! */
+}
+
+static void
+pdc_flush_buffer(struct tty_struct *tty)
+{
+#ifdef PDC_DRV_DEBUG
+	printk(KERN_NOTICE "[%s] return\n", __FUNCTION__);
+#endif
+}
+
+/*
+ * This function is used to send a high-priority XON/XOFF character to
+ * the device
+ */
+static void
+pdc_send_xchar(struct tty_struct *tty, char ch)
+{
+}
+
+/*
+ * ------------------------------------------------------------
+ * pdc_throttle()
+ * 
+ * This routine is called by the upper-layer tty layer to signal that
+ * incoming characters should be throttled.
+ * ------------------------------------------------------------
+ */
+static void
+pdc_throttle(struct tty_struct *tty)
+{
+}
+
+static void
+pdc_unthrottle(struct tty_struct *tty)
+{
+}
+
+/*
+ * ------------------------------------------------------------
+ * pdc_ioctl() and friends
+ * ------------------------------------------------------------
+ */
+
+static void
+pdc_break(struct tty_struct *tty, int break_state)
+{
+}
+
+static int
+get_serial_info(struct async_struct * info,
+                           struct serial_struct * retinfo)
+{
+	struct serial_struct tmp;
+
+	if (!retinfo)
+		return -EFAULT;
+	memset(&tmp, 0, sizeof(tmp));
+	tmp.line = info->line;
+	tmp.port = info->line;
+	tmp.flags = info->flags;
+	tmp.close_delay = info->close_delay;
+	return copy_to_user(retinfo,&tmp,sizeof(*retinfo)) ? -EFAULT : 0;
+}
+
+static int get_modem_info(struct async_struct * info, unsigned int *value)
+{
+	unsigned int result = TIOCM_DTR|TIOCM_CAR|TIOCM_CTS|TIOCM_RTS;
+
+	return copy_to_user(value, &result, sizeof(int)) ? -EFAULT : 0;
+}
+
+static int get_lsr_info(struct async_struct * info, unsigned int *value)
+{
+	unsigned int result = TIOCSER_TEMT;
+
+	return copy_to_user(value, &result, sizeof(int)) ? -EFAULT : 0;
+}
+
+static int
+pdc_ioctl(struct tty_struct *tty, struct file *file,
+	  unsigned int cmd, unsigned long arg)
+{
+	struct async_struct *info = (struct async_struct *) tty->driver_data;
+
+	if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
+	    (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGSTRUCT) &&
+	    (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
+		if (tty->flags & (1 << TTY_IO_ERROR))
+			return -EIO;
+	}
+
+	switch (cmd) {
+	case TIOCMGET:
+		return get_modem_info(info, (unsigned int *) arg);
+	case TIOCMBIS:
+	case TIOCMBIC:
+	case TIOCMSET:
+		return 0;
+	case TIOCGSERIAL:
+		return get_serial_info(info, (struct serial_struct *) arg);
+	case TIOCSSERIAL:
+		return 0;
+	case TIOCSERCONFIG:
+		return 0;
+
+	case TIOCSERGETLSR:	/* Get line status register */
+		return get_lsr_info(info, (unsigned int *) arg);
+
+	case TIOCSERGSTRUCT:
+		if (copy_to_user((struct async_struct *) arg,
+				 info, sizeof (struct async_struct)))
+			return -EFAULT;
+		return 0;
+
+	case TIOCMIWAIT:
+		return 0;
+
+	case TIOCGICOUNT:
+		return 0;
+	case TIOCSERGWILD:
+	case TIOCSERSWILD:
+		/* "setserial -W" is called in Debian boot */
+		printk("TIOCSER?WILD ioctl obsolete, ignored.\n");
+		return 0;
+
+	default:
+		return -ENOIOCTLCMD;
+	}
+	return 0;
+}
+
+static void
+pdc_set_termios(struct tty_struct *tty, struct termios *old_termios)
+{
+
+#if 0				/* XXX CP, has to be checked, if there is stuff to do */
+	struct async_struct *info = (struct async_struct *) tty->driver_data;
+	unsigned long flags;
+	unsigned int cflag = tty->termios->c_cflag;
+
+	if ((cflag == old_termios->c_cflag)
+	    && (RELEVANT_IFLAG(tty->termios->c_iflag)
+		== RELEVANT_IFLAG(old_termios->c_iflag)))
+		return;
+#if 0
+	change_speed(info, old_termios);
+#endif
+	/* Handle turning off CRTSCTS */
+	if ((old_termios->c_cflag & CRTSCTS) &&
+	    !(tty->termios->c_cflag & CRTSCTS)) {
+		tty->hw_stopped = 0;
+		pdc_start(tty);
+	}
+#endif
+}
+
+/*
+ * ------------------------------------------------------------
+ * pdc_close()
+ * 
+ * This routine is called when the serial port gets closed.  First, we
+ * wait for the last remaining data to be sent.  Then, we unlink its
+ * async structure from the interrupt chain if necessary, and we free
+ * that IRQ if nothing is left in the chain.
+ * ------------------------------------------------------------
+ */
+static void
+pdc_close(struct tty_struct *tty, struct file *filp)
+{
+	struct async_struct *info = (struct async_struct *) tty->driver_data;
+
+#ifdef PDC_DEBUG_OPEN
+	printk("pdc_close ttyB%d, count = %d\n", info->line, state->count);
+#endif
+	pdc_drv_refcount--;
+	if (pdc_drv_refcount > 0)
+		return;
+
+	info->flags |= ASYNC_CLOSING;
+
+	/*
+	 * Save the termios structure, since this port may have
+	 * separate termios for callout and dialin.
+	 */
+	if (info->flags & ASYNC_NORMAL_ACTIVE)
+		info->state->normal_termios = *tty->termios;
+	if (info->flags & ASYNC_CALLOUT_ACTIVE)
+		info->state->callout_termios = *tty->termios;
+
+	/*
+	 * At this point we stop accepting input.  To do this, we
+	 * disable the receive line status interrupts, and tell the
+	 * interrupt driver to stop checking the data ready bit in the
+	 * line status register.
+	 */
+
+	/* XXX CP: make mask for receive !!! */
+
+	if (tty->driver.flush_buffer)
+		tty->driver.flush_buffer(tty);
+	if (tty->ldisc.flush_buffer)
+		tty->ldisc.flush_buffer(tty);
+	tty->closing = 0;
+	info->event = 0;
+	info->tty = 0;
+	pdc_drv_info = NULL;
+	if (info->blocked_open) {
+		if (info->close_delay) {
+			set_current_state(TASK_INTERRUPTIBLE);
+			schedule_timeout(info->close_delay);
+		}
+		wake_up_interruptible(&info->open_wait);
+	}
+	info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CALLOUT_ACTIVE |
+			 ASYNC_CLOSING);
+	wake_up_interruptible(&info->close_wait);
+	MOD_DEC_USE_COUNT;
+}
+
+/*
+ * pdc_wait_until_sent() --- wait until the transmitter is empty
+ */
+static void
+pdc_wait_until_sent(struct tty_struct *tty, int timeout)
+{
+	/* we always send immideate */
+}
+
+/*
+ * pdc_hangup() --- called by tty_hangup() when a hangup is signaled.
+ */
+static void
+pdc_hangup(struct tty_struct *tty)
+{
+}
+
+/*
+ * ------------------------------------------------------------
+ * pdc_open() and friends
+ * ------------------------------------------------------------
+ */
+
+static int
+get_async_struct(int line, struct async_struct **ret_info)
+{
+	struct async_struct *info;
+
+	info = kmalloc(sizeof (struct async_struct), GFP_KERNEL);
+	if (!info) {
+		return -ENOMEM;
+	}
+	memset(info, 0, sizeof (struct async_struct));
+	init_waitqueue_head(&info->open_wait);
+	init_waitqueue_head(&info->close_wait);
+	init_waitqueue_head(&info->delta_msr_wait);
+	info->magic = SERIAL_MAGIC;
+	info->port = 0;
+	info->flags = 0;
+	info->io_type = 0;
+	info->iomem_base = 0;
+	info->iomem_reg_shift = 0;
+	info->xmit_fifo_size = PDC_DUMMY_BUF;
+	info->line = line;
+	info->tqueue.routine = NULL;
+	info->tqueue.data = info;
+	info->state = NULL;
+	*ret_info = info;
+	return 0;
+}
+
+/*
+ * This routine is called whenever a serial port is opened.  It
+ * enables interrupts for a serial port, linking in its async structure into
+ * the IRQ chain.   It also performs the serial-specific
+ * initialization for the tty structure.
+ */
+static int
+pdc_open(struct tty_struct *tty, struct file *filp)
+{
+	struct async_struct *info;
+	int retval, line;
+	unsigned long page;
+
+	MOD_INC_USE_COUNT;
+	line = MINOR(tty->device) - tty->driver.minor_start;
+	if ((line < 0) || (line >= NR_PORTS)) {
+		MOD_DEC_USE_COUNT;
+		return -ENODEV;
+	}
+	retval = get_async_struct(line, &info);
+	if (retval) {
+		MOD_DEC_USE_COUNT;
+		return retval;
+	}
+	tty->driver_data = info;
+	info->tty = tty;
+	pdc_drv_info = info;
+
+#ifdef PDC_DEBUG_OPEN
+	printk("pdc_open %s%d, count = %d\n", tty->driver.name, info->line,
+	       info->state->count);
+#endif
+	info->tty->low_latency = 0;
+	if (!tmp_buf) {
+		page = get_zeroed_page(GFP_KERNEL);
+		if (!page) {
+			MOD_DEC_USE_COUNT;
+			return -ENOMEM;
+		}
+		if (tmp_buf)
+			free_page(page);
+		else
+			tmp_buf = (unsigned char *) page;
+	}
+
+	info->session = current->session;
+	info->pgrp = current->pgrp;
+
+#ifdef PDC_DEBUG_OPEN
+	printk("pdc_open ttyB%d successful...", info->line);
+#endif
+	pdc_drv_refcount++;
+	return 0;
+}
+
+/*
+ * ---------------------------------------------------------------------
+ * pdc_init() and friends
+ *
+ * pdc_init() is called at boot-time to initialize the pdc driver.
+ * ---------------------------------------------------------------------
+ */
+
+static void
+show_pdc_drv_version(void)
+{
+	printk(KERN_INFO "%s version %s%s (%s), %s\n", pdc_drv_name,
+	       pdc_drv_version, LOCAL_VERSTRING, pdc_drv_revdate, AUTHOR);
+}
+
+/*
+ * The serial driver boot-time initialization code!
+ */
+static int __init
+pdc_drv_init(void)
+{
+	init_timer(&pdc_drv_timer);
+	pdc_drv_timer.function = pdc_drv_poll;
+	mod_timer(&pdc_drv_timer, jiffies + PDC_POLL_DELAY);
+
+	show_pdc_drv_version();
+
+	/* Initialize the tty_driver structure */
+
+	memset(&pdc_drv_driver, 0, sizeof (struct tty_driver));
+	pdc_drv_driver.magic = TTY_DRIVER_MAGIC;
+	pdc_drv_driver.driver_name = "pdc_console";
+#ifdef CONFIG_DEVFS_FS
+	pdc_drv_driver.name = "ttb/%d";
+#else
+	pdc_drv_driver.name = "ttyB";
+#endif
+	pdc_drv_driver.major = PDCCONS_MAJOR;
+	pdc_drv_driver.minor_start = 0;
+	pdc_drv_driver.num = NR_PORTS;
+	pdc_drv_driver.type = TTY_DRIVER_TYPE_SERIAL;
+	pdc_drv_driver.subtype = SERIAL_TYPE_NORMAL;
+	pdc_drv_driver.init_termios = tty_std_termios;
+	pdc_drv_driver.init_termios.c_cflag =
+	    B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+	pdc_drv_driver.flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
+	pdc_drv_driver.refcount = &pdc_drv_refcount;
+	pdc_drv_driver.table = pdc_drv_table;
+	pdc_drv_driver.termios = pdc_drv_termios;
+	pdc_drv_driver.termios_locked = pdc_drv_termios_locked;
+
+	pdc_drv_driver.open = pdc_open;
+	pdc_drv_driver.close = pdc_close;
+	pdc_drv_driver.write = pdc_write;
+	pdc_drv_driver.put_char = pdc_put_char;
+	pdc_drv_driver.flush_chars = pdc_flush_chars;
+	pdc_drv_driver.write_room = pdc_write_room;
+	pdc_drv_driver.chars_in_buffer = pdc_chars_in_buffer;
+	pdc_drv_driver.flush_buffer = pdc_flush_buffer;
+	pdc_drv_driver.ioctl = pdc_ioctl;
+	pdc_drv_driver.throttle = pdc_throttle;
+	pdc_drv_driver.unthrottle = pdc_unthrottle;
+	pdc_drv_driver.set_termios = pdc_set_termios;
+	pdc_drv_driver.stop = pdc_stop;
+	pdc_drv_driver.start = pdc_start;
+	pdc_drv_driver.hangup = pdc_hangup;
+	pdc_drv_driver.break_ctl = pdc_break;
+	pdc_drv_driver.send_xchar = pdc_send_xchar;
+	pdc_drv_driver.wait_until_sent = pdc_wait_until_sent;
+	pdc_drv_driver.read_proc = NULL;
+
+	if (tty_register_driver(&pdc_drv_driver))
+		panic("Couldn't register pdc_console driver\n");
+
+	return 0;
+}
+
+static void __exit
+pdc_fini(void)
+{
+	int e1;
+
+	if ((e1 = tty_unregister_driver(&pdc_drv_driver)))
+		printk("pdc_console: failed to unregister pdc_drv driver (%d)\n",
+		       e1);
+}
+
+module_init(pdc_drv_init);
+module_exit(pdc_fini);
+MODULE_DESCRIPTION("PDC Software Console");
+MODULE_AUTHOR(AUTHOR);