summaryrefslogtreecommitdiffstats
path: root/tty
diff options
context:
space:
mode:
Diffstat (limited to 'tty')
-rw-r--r--tty/Makefile41
-rw-r--r--tty/tiny_serial.c291
-rw-r--r--tty/tiny_tty.c591
3 files changed, 923 insertions, 0 deletions
diff --git a/tty/Makefile b/tty/Makefile
new file mode 100644
index 0000000..f5b8592
--- /dev/null
+++ b/tty/Makefile
@@ -0,0 +1,41 @@
+# Comment/uncomment the following line to disable/enable debugging
+#DEBUG = y
+
+
+# Add your debugging flag (or not) to CFLAGS
+ifeq ($(DEBUG),y)
+ DEBFLAGS = -O -g -DSCULL_DEBUG # "-O" is needed to expand inlines
+else
+ DEBFLAGS = -O2
+endif
+
+CFLAGS += $(DEBFLAGS)
+CFLAGS += -I..
+
+ifneq ($(KERNELRELEASE),)
+# call from kernel build system
+
+obj-m := tiny_tty.o tiny_serial.o
+
+else
+
+KERNELDIR ?= /lib/modules/$(shell uname -r)/build
+PWD := $(shell pwd)
+
+default:
+ $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
+
+endif
+
+
+
+clean:
+ rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
+
+depend .depend dep:
+ $(CC) $(CFLAGS) -M *.c > .depend
+
+
+ifeq (.depend,$(wildcard .depend))
+include .depend
+endif
diff --git a/tty/tiny_serial.c b/tty/tiny_serial.c
new file mode 100644
index 0000000..1ae7a43
--- /dev/null
+++ b/tty/tiny_serial.c
@@ -0,0 +1,291 @@
+/*
+ * Tiny Serial driver
+ *
+ * Copyright (C) 2002-2004 Greg Kroah-Hartman (greg@kroah.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 2 of the License.
+ *
+ * This driver shows how to create a minimal serial driver. It does not rely on
+ * any backing hardware, but creates a timer that emulates data being received
+ * from some kind of hardware.
+ */
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/serial.h>
+#include <linux/serial_core.h>
+#include <linux/module.h>
+
+
+#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>"
+#define DRIVER_DESC "Tiny serial driver"
+
+/* Module information */
+MODULE_AUTHOR( DRIVER_AUTHOR );
+MODULE_DESCRIPTION( DRIVER_DESC );
+MODULE_LICENSE("GPL");
+
+#define DELAY_TIME HZ * 2 /* 2 seconds per character */
+#define TINY_DATA_CHARACTER 't'
+
+#define TINY_SERIAL_MAJOR 240 /* experimental range */
+#define TINY_SERIAL_MINORS 1 /* only have one minor */
+#define UART_NR 1 /* only use one port */
+
+#define TINY_SERIAL_NAME "ttytiny"
+
+#define MY_NAME TINY_SERIAL_NAME
+
+static struct timer_list *timer;
+
+static void tiny_stop_tx(struct uart_port *port, unsigned int tty_stop)
+{
+}
+
+static void tiny_stop_rx(struct uart_port *port)
+{
+}
+
+static void tiny_enable_ms(struct uart_port *port)
+{
+}
+
+static void tiny_tx_chars(struct uart_port *port)
+{
+ struct circ_buf *xmit = &port->info->xmit;
+ int count;
+
+ if (port->x_char) {
+ pr_debug("wrote %2x", port->x_char);
+ port->icount.tx++;
+ port->x_char = 0;
+ return;
+ }
+ if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
+ tiny_stop_tx(port, 0);
+ return;
+ }
+
+ count = port->fifosize >> 1;
+ do {
+ pr_debug("wrote %2x", xmit->buf[xmit->tail]);
+ xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
+ port->icount.tx++;
+ if (uart_circ_empty(xmit))
+ break;
+ } while (--count > 0);
+
+ if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
+ uart_write_wakeup(port);
+
+ if (uart_circ_empty(xmit))
+ tiny_stop_tx(port, 0);
+}
+
+static void tiny_start_tx(struct uart_port *port, unsigned int tty_start)
+{
+}
+
+static void tiny_timer(unsigned long data)
+{
+ struct uart_port *port;
+ struct tty_struct *tty;
+
+
+ port = (struct uart_port *)data;
+ if (!port)
+ return;
+ if (!port->info)
+ return;
+ tty = port->info->tty;
+ if (!tty)
+ return;
+
+ /* add one character to the tty port */
+ /* this doesn't actually push the data through unless tty->low_latency is set */
+ tty_insert_flip_char(tty, TINY_DATA_CHARACTER, 0);
+
+ tty_flip_buffer_push(tty);
+
+ /* resubmit the timer again */
+ timer->expires = jiffies + DELAY_TIME;
+ add_timer(timer);
+
+ /* see if we have any data to transmit */
+ tiny_tx_chars(port);
+}
+
+static unsigned int tiny_tx_empty(struct uart_port *port)
+{
+ return 0;
+}
+
+static unsigned int tiny_get_mctrl(struct uart_port *port)
+{
+ return 0;
+}
+
+static void tiny_set_mctrl(struct uart_port *port, unsigned int mctrl)
+{
+}
+
+static void tiny_break_ctl(struct uart_port *port, int break_state)
+{
+}
+
+static void tiny_set_termios(struct uart_port *port,
+ struct termios *new, struct termios *old)
+{
+ int baud, quot, cflag = new->c_cflag;
+ /* get the byte size */
+ switch (cflag & CSIZE) {
+ case CS5:
+ printk(KERN_DEBUG " - data bits = 5\n");
+ break;
+ case CS6:
+ printk(KERN_DEBUG " - data bits = 6\n");
+ break;
+ case CS7:
+ printk(KERN_DEBUG " - data bits = 7\n");
+ break;
+ default: // CS8
+ printk(KERN_DEBUG " - data bits = 8\n");
+ break;
+ }
+
+ /* determine the parity */
+ if (cflag & PARENB)
+ if (cflag & PARODD)
+ pr_debug(" - parity = odd\n");
+ else
+ pr_debug(" - parity = even\n");
+ else
+ pr_debug(" - parity = none\n");
+
+ /* figure out the stop bits requested */
+ if (cflag & CSTOPB)
+ pr_debug(" - stop bits = 2\n");
+ else
+ pr_debug(" - stop bits = 1\n");
+
+ /* figure out the flow control settings */
+ if (cflag & CRTSCTS)
+ pr_debug(" - RTS/CTS is enabled\n");
+ else
+ pr_debug(" - RTS/CTS is disabled\n");
+
+ /* Set baud rate */
+ baud = uart_get_baud_rate(port, new, old, 0, port->uartclk/16);
+ quot = uart_get_divisor(port, baud);
+
+ //UART_PUT_DIV_LO(port, (quot & 0xff));
+ //UART_PUT_DIV_HI(port, ((quot & 0xf00) >> 8));
+}
+
+static int tiny_startup(struct uart_port *port)
+{
+ /* this is the first time this port is opened */
+ /* do any hardware initialization needed here */
+
+ /* create our timer and submit it */
+ if (!timer) {
+ timer = kmalloc(sizeof(*timer), GFP_KERNEL);
+ if (!timer)
+ return -ENOMEM;
+ }
+ timer->data = (unsigned long)port;
+ timer->expires = jiffies + DELAY_TIME;
+ timer->function = tiny_timer;
+ add_timer(timer);
+ return 0;
+}
+
+static void tiny_shutdown(struct uart_port *port)
+{
+ /* The port is being closed by the last user. */
+ /* Do any hardware specific stuff here */
+
+ /* shut down our timer */
+ del_timer(timer);
+}
+
+static const char *tiny_type(struct uart_port *port)
+{
+ return "tinytty";
+}
+
+static void tiny_release_port(struct uart_port *port)
+{
+
+}
+
+static int tiny_request_port(struct uart_port *port)
+{
+ return 0;
+}
+
+static void tiny_config_port(struct uart_port *port, int flags)
+{
+}
+
+static int tiny_verify_port(struct uart_port *port, struct serial_struct *ser)
+{
+ return 0;
+}
+
+static struct uart_ops tiny_ops = {
+ .tx_empty = tiny_tx_empty,
+ .set_mctrl = tiny_set_mctrl,
+ .get_mctrl = tiny_get_mctrl,
+ .stop_tx = tiny_stop_tx,
+ .start_tx = tiny_start_tx,
+ .stop_rx = tiny_stop_rx,
+ .enable_ms = tiny_enable_ms,
+ .break_ctl = tiny_break_ctl,
+ .startup = tiny_startup,
+ .shutdown = tiny_shutdown,
+ .set_termios = tiny_set_termios,
+ .type = tiny_type,
+ .release_port = tiny_release_port,
+ .request_port = tiny_request_port,
+ .config_port = tiny_config_port,
+ .verify_port = tiny_verify_port,
+};
+
+static struct uart_port tiny_port = {
+ .ops = &tiny_ops,
+};
+
+static struct uart_driver tiny_reg = {
+ .owner = THIS_MODULE,
+ .driver_name = TINY_SERIAL_NAME,
+ .dev_name = TINY_SERIAL_NAME,
+ .major = TINY_SERIAL_MAJOR,
+ .minor = TINY_SERIAL_MINORS,
+ .nr = UART_NR,
+};
+
+static int __init tiny_init(void)
+{
+ int result;
+
+ printk(KERN_INFO "Tiny serial driver loaded\n");
+
+ result = uart_register_driver(&tiny_reg);
+ if (result)
+ return result;
+
+ result = uart_add_one_port(&tiny_reg, &tiny_port);
+ if (result)
+ uart_unregister_driver(&tiny_reg);
+
+ return result;
+}
+
+module_init(tiny_init);
diff --git a/tty/tiny_tty.c b/tty/tiny_tty.c
new file mode 100644
index 0000000..778b207
--- /dev/null
+++ b/tty/tiny_tty.c
@@ -0,0 +1,591 @@
+/*
+ * Tiny TTY driver
+ *
+ * Copyright (C) 2002-2004 Greg Kroah-Hartman (greg@kroah.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 2 of the License.
+ *
+ * This driver shows how to create a minimal tty driver. It does not rely on
+ * any backing hardware, but creates a timer that emulates data being received
+ * from some kind of hardware.
+ */
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/wait.h>
+#include <linux/tty.h>
+#include <linux/tty_driver.h>
+#include <linux/tty_flip.h>
+#include <linux/serial.h>
+#include <asm/uaccess.h>
+
+
+#define DRIVER_VERSION "v2.0"
+#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>"
+#define DRIVER_DESC "Tiny TTY driver"
+
+/* Module information */
+MODULE_AUTHOR( DRIVER_AUTHOR );
+MODULE_DESCRIPTION( DRIVER_DESC );
+MODULE_LICENSE("GPL");
+
+#define DELAY_TIME HZ * 2 /* 2 seconds per character */
+#define TINY_DATA_CHARACTER 't'
+
+#define TINY_TTY_MAJOR 240 /* experimental range */
+#define TINY_TTY_MINORS 4 /* only have 4 devices */
+
+struct tiny_serial {
+ struct tty_struct *tty; /* pointer to the tty for this device */
+ int open_count; /* number of times this port has been opened */
+ struct semaphore sem; /* locks this structure */
+ struct timer_list *timer;
+
+ /* for tiocmget and tiocmset functions */
+ int msr; /* MSR shadow */
+ int mcr; /* MCR shadow */
+
+ /* for ioctl fun */
+ struct serial_struct serial;
+ wait_queue_head_t wait;
+ struct async_icount icount;
+};
+
+static struct tiny_serial *tiny_table[TINY_TTY_MINORS]; /* initially all NULL */
+
+
+static void tiny_timer(unsigned long timer_data)
+{
+ struct tiny_serial *tiny = (struct tiny_serial *)timer_data;
+ struct tty_struct *tty;
+ int i;
+ char data[1] = {TINY_DATA_CHARACTER};
+ int data_size = 1;
+
+ if (!tiny)
+ return;
+
+ tty = tiny->tty;
+
+ /* send the data to the tty layer for users to read. This doesn't
+ * actually push the data through unless tty->low_latency is set */
+ for (i = 0; i < data_size; ++i) {
+ if (tty->flip.count >= TTY_FLIPBUF_SIZE)
+ tty_flip_buffer_push(tty);
+ tty_insert_flip_char(tty, data[i], TTY_NORMAL);
+ }
+ tty_flip_buffer_push(tty);
+
+ /* resubmit the timer again */
+ tiny->timer->expires = jiffies + DELAY_TIME;
+ add_timer(tiny->timer);
+}
+
+static int tiny_open(struct tty_struct *tty, struct file *file)
+{
+ struct tiny_serial *tiny;
+ struct timer_list *timer;
+ int index;
+
+ /* initialize the pointer in case something fails */
+ tty->driver_data = NULL;
+
+ /* get the serial object associated with this tty pointer */
+ index = tty->index;
+ tiny = tiny_table[index];
+ if (tiny == NULL) {
+ /* first time accessing this device, let's create it */
+ tiny = kmalloc(sizeof(*tiny), GFP_KERNEL);
+ if (!tiny)
+ return -ENOMEM;
+
+ init_MUTEX(&tiny->sem);
+ tiny->open_count = 0;
+ tiny->timer = NULL;
+
+ tiny_table[index] = tiny;
+ }
+
+ down(&tiny->sem);
+
+ /* save our structure within the tty structure */
+ tty->driver_data = tiny;
+ tiny->tty = tty;
+
+ ++tiny->open_count;
+ if (tiny->open_count == 1) {
+ /* this is the first time this port is opened */
+ /* do any hardware initialization needed here */
+
+ /* create our timer and submit it */
+ if (!tiny->timer) {
+ timer = kmalloc(sizeof(*timer), GFP_KERNEL);
+ if (!timer) {
+ up(&tiny->sem);
+ return -ENOMEM;
+ }
+ tiny->timer = timer;
+ }
+ tiny->timer->data = (unsigned long )tiny;
+ tiny->timer->expires = jiffies + DELAY_TIME;
+ tiny->timer->function = tiny_timer;
+ add_timer(tiny->timer);
+ }
+
+ up(&tiny->sem);
+ return 0;
+}
+
+static void do_close(struct tiny_serial *tiny)
+{
+ down(&tiny->sem);
+
+ if (!tiny->open_count) {
+ /* port was never opened */
+ goto exit;
+ }
+
+ --tiny->open_count;
+ if (tiny->open_count <= 0) {
+ /* The port is being closed by the last user. */
+ /* Do any hardware specific stuff here */
+
+ /* shut down our timer */
+ del_timer(tiny->timer);
+ }
+exit:
+ up(&tiny->sem);
+}
+
+static void tiny_close(struct tty_struct *tty, struct file *file)
+{
+ struct tiny_serial *tiny = tty->driver_data;
+
+ if (tiny)
+ do_close(tiny);
+}
+
+static int tiny_write(struct tty_struct *tty,
+ const unsigned char *buffer, int count)
+{
+ struct tiny_serial *tiny = tty->driver_data;
+ int i;
+ int retval = -EINVAL;
+
+ if (!tiny)
+ return -ENODEV;
+
+ down(&tiny->sem);
+
+ if (!tiny->open_count)
+ /* port was not opened */
+ goto exit;
+
+ /* fake sending the data out a hardware port by
+ * writing it to the kernel debug log.
+ */
+ printk(KERN_DEBUG "%s - ", __FUNCTION__);
+ for (i = 0; i < count; ++i)
+ printk("%02x ", buffer[i]);
+ printk("\n");
+
+exit:
+ up(&tiny->sem);
+ return retval;
+}
+
+static int tiny_write_room(struct tty_struct *tty)
+{
+ struct tiny_serial *tiny = tty->driver_data;
+ int room = -EINVAL;
+
+ if (!tiny)
+ return -ENODEV;
+
+ down(&tiny->sem);
+
+ if (!tiny->open_count) {
+ /* port was not opened */
+ goto exit;
+ }
+
+ /* calculate how much room is left in the device */
+ room = 255;
+
+exit:
+ up(&tiny->sem);
+ return room;
+}
+
+#define RELEVANT_IFLAG(iflag) ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
+
+static void tiny_set_termios(struct tty_struct *tty, struct termios *old_termios)
+{
+ unsigned int cflag;
+
+ cflag = tty->termios->c_cflag;
+
+ /* check that they really want us to change something */
+ if (old_termios) {
+ if ((cflag == old_termios->c_cflag) &&
+ (RELEVANT_IFLAG(tty->termios->c_iflag) ==
+ RELEVANT_IFLAG(old_termios->c_iflag))) {
+ printk(KERN_DEBUG " - nothing to change...\n");
+ return;
+ }
+ }
+
+ /* get the byte size */
+ switch (cflag & CSIZE) {
+ case CS5:
+ printk(KERN_DEBUG " - data bits = 5\n");
+ break;
+ case CS6:
+ printk(KERN_DEBUG " - data bits = 6\n");
+ break;
+ case CS7:
+ printk(KERN_DEBUG " - data bits = 7\n");
+ break;
+ default:
+ case CS8:
+ printk(KERN_DEBUG " - data bits = 8\n");
+ break;
+ }
+
+ /* determine the parity */
+ if (cflag & PARENB)
+ if (cflag & PARODD)
+ printk(KERN_DEBUG " - parity = odd\n");
+ else
+ printk(KERN_DEBUG " - parity = even\n");
+ else
+ printk(KERN_DEBUG " - parity = none\n");
+
+ /* figure out the stop bits requested */
+ if (cflag & CSTOPB)
+ printk(KERN_DEBUG " - stop bits = 2\n");
+ else
+ printk(KERN_DEBUG " - stop bits = 1\n");
+
+ /* figure out the hardware flow control settings */
+ if (cflag & CRTSCTS)
+ printk(KERN_DEBUG " - RTS/CTS is enabled\n");
+ else
+ printk(KERN_DEBUG " - RTS/CTS is disabled\n");
+
+ /* determine software flow control */
+ /* if we are implementing XON/XOFF, set the start and
+ * stop character in the device */
+ if (I_IXOFF(tty) || I_IXON(tty)) {
+ unsigned char stop_char = STOP_CHAR(tty);
+ unsigned char start_char = START_CHAR(tty);
+
+ /* if we are implementing INBOUND XON/XOFF */
+ if (I_IXOFF(tty))
+ printk(KERN_DEBUG " - INBOUND XON/XOFF is enabled, "
+ "XON = %2x, XOFF = %2x", start_char, stop_char);
+ else
+ printk(KERN_DEBUG" - INBOUND XON/XOFF is disabled");
+
+ /* if we are implementing OUTBOUND XON/XOFF */
+ if (I_IXON(tty))
+ printk(KERN_DEBUG" - OUTBOUND XON/XOFF is enabled, "
+ "XON = %2x, XOFF = %2x", start_char, stop_char);
+ else
+ printk(KERN_DEBUG" - OUTBOUND XON/XOFF is disabled");
+ }
+
+ /* get the baud rate wanted */
+ printk(KERN_DEBUG " - baud rate = %d", tty_get_baud_rate(tty));
+}
+
+/* Our fake UART values */
+#define MCR_DTR 0x01
+#define MCR_RTS 0x02
+#define MCR_LOOP 0x04
+#define MSR_CTS 0x08
+#define MSR_CD 0x10
+#define MSR_RI 0x20
+#define MSR_DSR 0x40
+
+static int tiny_tiocmget(struct tty_struct *tty, struct file *file)
+{
+ struct tiny_serial *tiny = tty->driver_data;
+
+ unsigned int result = 0;
+ unsigned int msr = tiny->msr;
+ unsigned int mcr = tiny->mcr;
+
+ result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0) | /* DTR is set */
+ ((mcr & MCR_RTS) ? TIOCM_RTS : 0) | /* RTS is set */
+ ((mcr & MCR_LOOP) ? TIOCM_LOOP : 0) | /* LOOP is set */
+ ((msr & MSR_CTS) ? TIOCM_CTS : 0) | /* CTS is set */
+ ((msr & MSR_CD) ? TIOCM_CAR : 0) | /* Carrier detect is set*/
+ ((msr & MSR_RI) ? TIOCM_RI : 0) | /* Ring Indicator is set */
+ ((msr & MSR_DSR) ? TIOCM_DSR : 0); /* DSR is set */
+
+ return result;
+}
+
+static int tiny_tiocmset(struct tty_struct *tty, struct file *file,
+ unsigned int set, unsigned int clear)
+{
+ struct tiny_serial *tiny = tty->driver_data;
+ unsigned int mcr = tiny->mcr;
+
+ if (set & TIOCM_RTS)
+ mcr |= MCR_RTS;
+ if (set & TIOCM_DTR)
+ mcr |= MCR_RTS;
+
+ if (clear & TIOCM_RTS)
+ mcr &= ~MCR_RTS;
+ if (clear & TIOCM_DTR)
+ mcr &= ~MCR_RTS;
+
+ /* set the new MCR value in the device */
+ tiny->mcr = mcr;
+ return 0;
+}
+
+static int tiny_read_proc(char *page, char **start, off_t off, int count,
+ int *eof, void *data)
+{
+ struct tiny_serial *tiny;
+ off_t begin = 0;
+ int length = 0;
+ int i;
+
+ length += sprintf(page, "tinyserinfo:1.0 driver:%s\n", DRIVER_VERSION);
+ for (i = 0; i < TINY_TTY_MINORS && length < PAGE_SIZE; ++i) {
+ tiny = tiny_table[i];
+ if (tiny == NULL)
+ continue;
+
+ length += sprintf(page+length, "%d\n", i);
+ if ((length + begin) > (off + count))
+ goto done;
+ if ((length + begin) < off) {
+ begin += length;
+ length = 0;
+ }
+ }
+ *eof = 1;
+done:
+ if (off >= (length + begin))
+ return 0;
+ *start = page + (off-begin);
+ return (count < begin+length-off) ? count : begin + length-off;
+}
+
+#define tiny_ioctl tiny_ioctl_tiocgserial
+static int tiny_ioctl(struct tty_struct *tty, struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct tiny_serial *tiny = tty->driver_data;
+
+ if (cmd == TIOCGSERIAL) {
+ struct serial_struct tmp;
+
+ if (!arg)
+ return -EFAULT;
+
+ memset(&tmp, 0, sizeof(tmp));
+
+ tmp.type = tiny->serial.type;
+ tmp.line = tiny->serial.line;
+ tmp.port = tiny->serial.port;
+ tmp.irq = tiny->serial.irq;
+ tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
+ tmp.xmit_fifo_size = tiny->serial.xmit_fifo_size;
+ tmp.baud_base = tiny->serial.baud_base;
+ tmp.close_delay = 5*HZ;
+ tmp.closing_wait = 30*HZ;
+ tmp.custom_divisor = tiny->serial.custom_divisor;
+ tmp.hub6 = tiny->serial.hub6;
+ tmp.io_type = tiny->serial.io_type;
+
+ if (copy_to_user((void __user *)arg, &tmp, sizeof(struct serial_struct)))
+ return -EFAULT;
+ return 0;
+ }
+ return -ENOIOCTLCMD;
+}
+#undef tiny_ioctl
+
+#define tiny_ioctl tiny_ioctl_tiocmiwait
+static int tiny_ioctl(struct tty_struct *tty, struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct tiny_serial *tiny = tty->driver_data;
+
+ if (cmd == TIOCMIWAIT) {
+ DECLARE_WAITQUEUE(wait, current);
+ struct async_icount cnow;
+ struct async_icount cprev;
+
+ cprev = tiny->icount;
+ while (1) {
+ add_wait_queue(&tiny->wait, &wait);
+ set_current_state(TASK_INTERRUPTIBLE);
+ schedule();
+ remove_wait_queue(&tiny->wait, &wait);
+
+ /* see if a signal woke us up */
+ if (signal_pending(current))
+ return -ERESTARTSYS;
+
+ cnow = tiny->icount;
+ if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
+ cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
+ return -EIO; /* no change => error */
+ if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
+ ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
+ ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
+ ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
+ return 0;
+ }
+ cprev = cnow;
+ }
+
+ }
+ return -ENOIOCTLCMD;
+}
+#undef tiny_ioctl
+
+#define tiny_ioctl tiny_ioctl_tiocgicount
+static int tiny_ioctl(struct tty_struct *tty, struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct tiny_serial *tiny = tty->driver_data;
+
+ if (cmd == TIOCGICOUNT) {
+ struct async_icount cnow = tiny->icount;
+ struct serial_icounter_struct icount;
+
+ icount.cts = cnow.cts;
+ icount.dsr = cnow.dsr;
+ icount.rng = cnow.rng;
+ icount.dcd = cnow.dcd;
+ icount.rx = cnow.rx;
+ icount.tx = cnow.tx;
+ icount.frame = cnow.frame;
+ icount.overrun = cnow.overrun;
+ icount.parity = cnow.parity;
+ icount.brk = cnow.brk;
+ icount.buf_overrun = cnow.buf_overrun;
+
+ if (copy_to_user((void __user *)arg, &icount, sizeof(icount)))
+ return -EFAULT;
+ return 0;
+ }
+ return -ENOIOCTLCMD;
+}
+#undef tiny_ioctl
+
+/* the real tiny_ioctl function. The above is done to get the small functions in the book */
+static int tiny_ioctl(struct tty_struct *tty, struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ switch (cmd) {
+ case TIOCGSERIAL:
+ return tiny_ioctl_tiocgserial(tty, file, cmd, arg);
+ case TIOCMIWAIT:
+ return tiny_ioctl_tiocmiwait(tty, file, cmd, arg);
+ case TIOCGICOUNT:
+ return tiny_ioctl_tiocgicount(tty, file, cmd, arg);
+ }
+
+ return -ENOIOCTLCMD;
+}
+
+static struct tty_operations serial_ops = {
+ .open = tiny_open,
+ .close = tiny_close,
+ .write = tiny_write,
+ .write_room = tiny_write_room,
+ .set_termios = tiny_set_termios,
+};
+
+static struct tty_driver *tiny_tty_driver;
+
+static int __init tiny_init(void)
+{
+ int retval;
+ int i;
+
+ /* allocate the tty driver */
+ tiny_tty_driver = alloc_tty_driver(TINY_TTY_MINORS);
+ if (!tiny_tty_driver)
+ return -ENOMEM;
+
+ /* initialize the tty driver */
+ tiny_tty_driver->owner = THIS_MODULE;
+ tiny_tty_driver->driver_name = "tiny_tty";
+ tiny_tty_driver->name = "ttty";
+ tiny_tty_driver->devfs_name = "tts/ttty%d";
+ tiny_tty_driver->major = TINY_TTY_MAJOR,
+ tiny_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
+ tiny_tty_driver->subtype = SERIAL_TYPE_NORMAL,
+ tiny_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS,
+ tiny_tty_driver->init_termios = tty_std_termios;
+ tiny_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+ tty_set_operations(tiny_tty_driver, &serial_ops);
+
+ /* hack to make the book purty, yet still use these functions in the
+ * real driver. They really should be set up in the serial_ops
+ * structure above... */
+ tiny_tty_driver->read_proc = tiny_read_proc;
+ tiny_tty_driver->tiocmget = tiny_tiocmget;
+ tiny_tty_driver->tiocmset = tiny_tiocmset;
+ tiny_tty_driver->ioctl = tiny_ioctl;
+
+ /* register the tty driver */
+ retval = tty_register_driver(tiny_tty_driver);
+ if (retval) {
+ printk(KERN_ERR "failed to register tiny tty driver");
+ put_tty_driver(tiny_tty_driver);
+ return retval;
+ }
+
+ for (i = 0; i < TINY_TTY_MINORS; ++i)
+ tty_register_device(tiny_tty_driver, i, NULL);
+
+ printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION);
+ return retval;
+}
+
+static void __exit tiny_exit(void)
+{
+ struct tiny_serial *tiny;
+ int i;
+
+ for (i = 0; i < TINY_TTY_MINORS; ++i)
+ tty_unregister_device(tiny_tty_driver, i);
+ tty_unregister_driver(tiny_tty_driver);
+
+ /* shut down all of the timers and free the memory */
+ for (i = 0; i < TINY_TTY_MINORS; ++i) {
+ tiny = tiny_table[i];
+ if (tiny) {
+ /* close the port */
+ while (tiny->open_count)
+ do_close(tiny);
+
+ /* shut down our timer and free the memory */
+ del_timer(tiny->timer);
+ kfree(tiny->timer);
+ kfree(tiny);
+ tiny_table[i] = NULL;
+ }
+ }
+}
+
+module_init(tiny_init);
+module_exit(tiny_exit);
generated by cgit v1.2.1-18-gbd029 (git 2.20.0) at 2025-06-15 12:36:46 +0000