[linux-block.git] / drivers / tty / ipwireless / tty.c

// SPDX-License-Identifier: GPL-2.0
/*
 * IPWireless 3G PCMCIA Network Driver
 *
 * Original code
 *   by Stephen Blackheath <stephen@blacksapphire.com>,
 *      Ben Martel <benm@symmetric.co.nz>
 *
 * Copyrighted as follows:
 *   Copyright (C) 2004 by Symmetric Systems Ltd (NZ)
 *
 * Various driver changes and rewrites, port to new kernels
 *   Copyright (C) 2006-2007 Jiri Kosina
 *
 * Misc code cleanups and updates
 *   Copyright (C) 2007 David Sterba
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/ppp_defs.h>
#include <linux/if.h>
#include <linux/ppp-ioctl.h>
#include <linux/sched.h>
#include <linux/serial.h>
#include <linux/slab.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/uaccess.h>

#include "tty.h"
#include "network.h"
#include "hardware.h"
#include "main.h"

#define IPWIRELESS_PCMCIA_START 	(0)
#define IPWIRELESS_PCMCIA_MINORS	(24)
#define IPWIRELESS_PCMCIA_MINOR_RANGE	(8)

#define TTYTYPE_MODEM    (0)
#define TTYTYPE_MONITOR  (1)
#define TTYTYPE_RAS_RAW  (2)

struct ipw_tty {
	struct tty_port port;
	int index;
	struct ipw_hardware *hardware;
	unsigned int channel_idx;
	unsigned int secondary_channel_idx;
	int tty_type;
	struct ipw_network *network;
	unsigned int control_lines;
	struct mutex ipw_tty_mutex;
	int tx_bytes_queued;
	int closing;
};

static struct ipw_tty *ttys[IPWIRELESS_PCMCIA_MINORS];

static struct tty_driver *ipw_tty_driver;

static char *tty_type_name(int tty_type)
{
	static char *channel_names[] = {
		"modem",
		"monitor",
		"RAS-raw"
	};

	return channel_names[tty_type];
}

static struct ipw_tty *get_tty(int index)
{
	/*
	 * The 'ras_raw' channel is only available when 'loopback' mode
	 * is enabled.
	 * Number of minor starts with 16 (_RANGE * _RAS_RAW).
	 */
	if (!ipwireless_loopback && index >=
			 IPWIRELESS_PCMCIA_MINOR_RANGE * TTYTYPE_RAS_RAW)
		return NULL;

	return ttys[index];
}

static int ipw_open(struct tty_struct *linux_tty, struct file *filp)
{
	struct ipw_tty *tty = get_tty(linux_tty->index);

	if (!tty)
		return -ENODEV;

	mutex_lock(&tty->ipw_tty_mutex);
	if (tty->port.count == 0)
		tty->tx_bytes_queued = 0;

	tty->port.count++;

	tty->port.tty = linux_tty;
	linux_tty->driver_data = tty;
	tty->port.low_latency = 1;

	if (tty->tty_type == TTYTYPE_MODEM)
		ipwireless_ppp_open(tty->network);

	mutex_unlock(&tty->ipw_tty_mutex);

	return 0;
}

static void do_ipw_close(struct ipw_tty *tty)
{
	tty->port.count--;

	if (tty->port.count == 0) {
		struct tty_struct *linux_tty = tty->port.tty;

		if (linux_tty != NULL) {
			tty->port.tty = NULL;
			linux_tty->driver_data = NULL;

			if (tty->tty_type == TTYTYPE_MODEM)
				ipwireless_ppp_close(tty->network);
		}
	}
}

static void ipw_hangup(struct tty_struct *linux_tty)
{
	struct ipw_tty *tty = linux_tty->driver_data;

	if (!tty)
		return;

	mutex_lock(&tty->ipw_tty_mutex);
	if (tty->port.count == 0) {
		mutex_unlock(&tty->ipw_tty_mutex);
		return;
	}

	do_ipw_close(tty);

	mutex_unlock(&tty->ipw_tty_mutex);
}

static void ipw_close(struct tty_struct *linux_tty, struct file *filp)
{
	ipw_hangup(linux_tty);
}

/* Take data received from hardware, and send it out the tty */
void ipwireless_tty_received(struct ipw_tty *tty, unsigned char *data,
			unsigned int length)
{
	int work = 0;

	mutex_lock(&tty->ipw_tty_mutex);

	if (!tty->port.count) {
		mutex_unlock(&tty->ipw_tty_mutex);
		return;
	}
	mutex_unlock(&tty->ipw_tty_mutex);

	work = tty_insert_flip_string(&tty->port, data, length);

	if (work != length)
		printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
				": %d chars not inserted to flip buffer!\n",
				length - work);

	if (work)
		tty_flip_buffer_push(&tty->port);
}

static void ipw_write_packet_sent_callback(void *callback_data,
					   unsigned int packet_length)
{
	struct ipw_tty *tty = callback_data;

	/*
	 * Packet has been sent, so we subtract the number of bytes from our
	 * tally of outstanding TX bytes.
	 */
	tty->tx_bytes_queued -= packet_length;
}

static int ipw_write(struct tty_struct *linux_tty,
		     const unsigned char *buf, int count)
{
	struct ipw_tty *tty = linux_tty->driver_data;
	int room, ret;

	if (!tty)
		return -ENODEV;

	mutex_lock(&tty->ipw_tty_mutex);
	if (!tty->port.count) {
		mutex_unlock(&tty->ipw_tty_mutex);
		return -EINVAL;
	}

	room = IPWIRELESS_TX_QUEUE_SIZE - tty->tx_bytes_queued;
	if (room < 0)
		room = 0;
	/* Don't allow caller to write any more than we have room for */
	if (count > room)
		count = room;

	if (count == 0) {
		mutex_unlock(&tty->ipw_tty_mutex);
		return 0;
	}

	ret = ipwireless_send_packet(tty->hardware, IPW_CHANNEL_RAS,
			       buf, count,
			       ipw_write_packet_sent_callback, tty);
	if (ret == -1) {
		mutex_unlock(&tty->ipw_tty_mutex);
		return 0;
	}

	tty->tx_bytes_queued += count;
	mutex_unlock(&tty->ipw_tty_mutex);

	return count;
}

static int ipw_write_room(struct tty_struct *linux_tty)
{
	struct ipw_tty *tty = linux_tty->driver_data;
	int room;

	/* FIXME: Exactly how is the tty object locked here .. */
	if (!tty)
		return -ENODEV;

	if (!tty->port.count)
		return -EINVAL;

	room = IPWIRELESS_TX_QUEUE_SIZE - tty->tx_bytes_queued;
	if (room < 0)
		room = 0;

	return room;
}

static int ipwireless_get_serial_info(struct tty_struct *linux_tty,
				      struct serial_struct *ss)
{
	struct ipw_tty *tty = linux_tty->driver_data;

	if (!tty)
		return -ENODEV;

	if (!tty->port.count)
		return -EINVAL;

	ss->type = PORT_UNKNOWN;
	ss->line = tty->index;
	ss->baud_base = 115200;
	return 0;
}

static int ipwireless_set_serial_info(struct tty_struct *linux_tty,
				      struct serial_struct *ss)
{
	return 0;	/* Keeps the PCMCIA scripts happy. */
}

static int ipw_chars_in_buffer(struct tty_struct *linux_tty)
{
	struct ipw_tty *tty = linux_tty->driver_data;

	if (!tty)
		return 0;

	if (!tty->port.count)
		return 0;

	return tty->tx_bytes_queued;
}

static int get_control_lines(struct ipw_tty *tty)
{
	unsigned int my = tty->control_lines;
	unsigned int out = 0;

	if (my & IPW_CONTROL_LINE_RTS)
		out |= TIOCM_RTS;
	if (my & IPW_CONTROL_LINE_DTR)
		out |= TIOCM_DTR;
	if (my & IPW_CONTROL_LINE_CTS)
		out |= TIOCM_CTS;
	if (my & IPW_CONTROL_LINE_DSR)
		out |= TIOCM_DSR;
	if (my & IPW_CONTROL_LINE_DCD)
		out |= TIOCM_CD;

	return out;
}

static int set_control_lines(struct ipw_tty *tty, unsigned int set,
			     unsigned int clear)
{
	int ret;

	if (set & TIOCM_RTS) {
		ret = ipwireless_set_RTS(tty->hardware, tty->channel_idx, 1);
		if (ret)
			return ret;
		if (tty->secondary_channel_idx != -1) {
			ret = ipwireless_set_RTS(tty->hardware,
					  tty->secondary_channel_idx, 1);
			if (ret)
				return ret;
		}
	}
	if (set & TIOCM_DTR) {
		ret = ipwireless_set_DTR(tty->hardware, tty->channel_idx, 1);
		if (ret)
			return ret;
		if (tty->secondary_channel_idx != -1) {
			ret = ipwireless_set_DTR(tty->hardware,
					  tty->secondary_channel_idx, 1);
			if (ret)
				return ret;
		}
	}
	if (clear & TIOCM_RTS) {
		ret = ipwireless_set_RTS(tty->hardware, tty->channel_idx, 0);
		if (tty->secondary_channel_idx != -1) {
			ret = ipwireless_set_RTS(tty->hardware,
					  tty->secondary_channel_idx, 0);
			if (ret)
				return ret;
		}
	}
	if (clear & TIOCM_DTR) {
		ret = ipwireless_set_DTR(tty->hardware, tty->channel_idx, 0);
		if (tty->secondary_channel_idx != -1) {
			ret = ipwireless_set_DTR(tty->hardware,
					  tty->secondary_channel_idx, 0);
			if (ret)
				return ret;
		}
	}
	return 0;
}

static int ipw_tiocmget(struct tty_struct *linux_tty)
{
	struct ipw_tty *tty = linux_tty->driver_data;
	/* FIXME: Exactly how is the tty object locked here .. */

	if (!tty)
		return -ENODEV;

	if (!tty->port.count)
		return -EINVAL;

	return get_control_lines(tty);
}

static int
ipw_tiocmset(struct tty_struct *linux_tty,
	     unsigned int set, unsigned int clear)
{
	struct ipw_tty *tty = linux_tty->driver_data;
	/* FIXME: Exactly how is the tty object locked here .. */

	if (!tty)
		return -ENODEV;

	if (!tty->port.count)
		return -EINVAL;

	return set_control_lines(tty, set, clear);
}

static int ipw_ioctl(struct tty_struct *linux_tty,
		     unsigned int cmd, unsigned long arg)
{
	struct ipw_tty *tty = linux_tty->driver_data;

	if (!tty)
		return -ENODEV;

	if (!tty->port.count)
		return -EINVAL;

	/* FIXME: Exactly how is the tty object locked here .. */
	if (tty->tty_type == TTYTYPE_MODEM) {
		switch (cmd) {
		case PPPIOCGCHAN:
			{
				int chan = ipwireless_ppp_channel_index(
							tty->network);

				if (chan < 0)
					return -ENODEV;
				if (put_user(chan, (int __user *) arg))
					return -EFAULT;
			}
			return 0;

		case PPPIOCGUNIT:
			{
				int unit = ipwireless_ppp_unit_number(
						tty->network);

				if (unit < 0)
					return -ENODEV;
				if (put_user(unit, (int __user *) arg))
					return -EFAULT;
			}
			return 0;

		case FIONREAD:
			{
				int val = 0;

				if (put_user(val, (int __user *) arg))
					return -EFAULT;
			}
			return 0;
		case TCFLSH:
			return tty_perform_flush(linux_tty, arg);
		}
	}
	return -ENOIOCTLCMD;
}

static int add_tty(int j,
		    struct ipw_hardware *hardware,
		    struct ipw_network *network, int channel_idx,
		    int secondary_channel_idx, int tty_type)
{
	ttys[j] = kzalloc(sizeof(struct ipw_tty), GFP_KERNEL);
	if (!ttys[j])
		return -ENOMEM;
	ttys[j]->index = j;
	ttys[j]->hardware = hardware;
	ttys[j]->channel_idx = channel_idx;
	ttys[j]->secondary_channel_idx = secondary_channel_idx;
	ttys[j]->network = network;
	ttys[j]->tty_type = tty_type;
	mutex_init(&ttys[j]->ipw_tty_mutex);
	tty_port_init(&ttys[j]->port);

	tty_port_register_device(&ttys[j]->port, ipw_tty_driver, j, NULL);
	ipwireless_associate_network_tty(network, channel_idx, ttys[j]);

	if (secondary_channel_idx != -1)
		ipwireless_associate_network_tty(network,
						 secondary_channel_idx,
						 ttys[j]);
	/* check if we provide raw device (if loopback is enabled) */
	if (get_tty(j))
		printk(KERN_INFO IPWIRELESS_PCCARD_NAME
		       ": registering %s device ttyIPWp%d\n",
		       tty_type_name(tty_type), j);

	return 0;
}

struct ipw_tty *ipwireless_tty_create(struct ipw_hardware *hardware,
				      struct ipw_network *network)
{
	int i, j;

	for (i = 0; i < IPWIRELESS_PCMCIA_MINOR_RANGE; i++) {
		int allfree = 1;

		for (j = i; j < IPWIRELESS_PCMCIA_MINORS;
				j += IPWIRELESS_PCMCIA_MINOR_RANGE)
			if (ttys[j] != NULL) {
				allfree = 0;
				break;
			}

		if (allfree) {
			j = i;

			if (add_tty(j, hardware, network,
					IPW_CHANNEL_DIALLER, IPW_CHANNEL_RAS,
					TTYTYPE_MODEM))
				return NULL;

			j += IPWIRELESS_PCMCIA_MINOR_RANGE;
			if (add_tty(j, hardware, network,
					IPW_CHANNEL_DIALLER, -1,
					TTYTYPE_MONITOR))
				return NULL;

			j += IPWIRELESS_PCMCIA_MINOR_RANGE;
			if (add_tty(j, hardware, network,
					IPW_CHANNEL_RAS, -1,
					TTYTYPE_RAS_RAW))
				return NULL;

			return ttys[i];
		}
	}
	return NULL;
}

/*
 * Must be called before ipwireless_network_free().
 */
void ipwireless_tty_free(struct ipw_tty *tty)
{
	int j;
	struct ipw_network *network = ttys[tty->index]->network;

	for (j = tty->index; j < IPWIRELESS_PCMCIA_MINORS;
			j += IPWIRELESS_PCMCIA_MINOR_RANGE) {
		struct ipw_tty *ttyj = ttys[j];

		if (ttyj) {
			mutex_lock(&ttyj->ipw_tty_mutex);
			if (get_tty(j))
				printk(KERN_INFO IPWIRELESS_PCCARD_NAME
				       ": deregistering %s device ttyIPWp%d\n",
				       tty_type_name(ttyj->tty_type), j);
			ttyj->closing = 1;
			if (ttyj->port.tty != NULL) {
				mutex_unlock(&ttyj->ipw_tty_mutex);
				tty_vhangup(ttyj->port.tty);
				/* FIXME: Exactly how is the tty object locked here
				   against a parallel ioctl etc */
				/* FIXME2: hangup does not mean all processes
				 * are gone */
				mutex_lock(&ttyj->ipw_tty_mutex);
			}
			while (ttyj->port.count)
				do_ipw_close(ttyj);
			ipwireless_disassociate_network_ttys(network,
							     ttyj->channel_idx);
			tty_unregister_device(ipw_tty_driver, j);
			tty_port_destroy(&ttyj->port);
			ttys[j] = NULL;
			mutex_unlock(&ttyj->ipw_tty_mutex);
			kfree(ttyj);
		}
	}
}

static const struct tty_operations tty_ops = {
	.open = ipw_open,
	.close = ipw_close,
	.hangup = ipw_hangup,
	.write = ipw_write,
	.write_room = ipw_write_room,
	.ioctl = ipw_ioctl,
	.chars_in_buffer = ipw_chars_in_buffer,
	.tiocmget = ipw_tiocmget,
	.tiocmset = ipw_tiocmset,
	.set_serial = ipwireless_set_serial_info,
	.get_serial = ipwireless_get_serial_info,
};

int ipwireless_tty_init(void)
{
	int result;

	ipw_tty_driver = alloc_tty_driver(IPWIRELESS_PCMCIA_MINORS);
	if (!ipw_tty_driver)
		return -ENOMEM;

	ipw_tty_driver->driver_name = IPWIRELESS_PCCARD_NAME;
	ipw_tty_driver->name = "ttyIPWp";
	ipw_tty_driver->major = 0;
	ipw_tty_driver->minor_start = IPWIRELESS_PCMCIA_START;
	ipw_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
	ipw_tty_driver->subtype = SERIAL_TYPE_NORMAL;
	ipw_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
	ipw_tty_driver->init_termios = tty_std_termios;
	ipw_tty_driver->init_termios.c_cflag =
	    B9600 | CS8 | CREAD | HUPCL | CLOCAL;
	ipw_tty_driver->init_termios.c_ispeed = 9600;
	ipw_tty_driver->init_termios.c_ospeed = 9600;
	tty_set_operations(ipw_tty_driver, &tty_ops);
	result = tty_register_driver(ipw_tty_driver);
	if (result) {
		printk(KERN_ERR IPWIRELESS_PCCARD_NAME
		       ": failed to register tty driver\n");
		put_tty_driver(ipw_tty_driver);
		return result;
	}

	return 0;
}

void ipwireless_tty_release(void)
{
	int ret;

	ret = tty_unregister_driver(ipw_tty_driver);
	put_tty_driver(ipw_tty_driver);
	if (ret != 0)
		printk(KERN_ERR IPWIRELESS_PCCARD_NAME
			": tty_unregister_driver failed with code %d\n", ret);
}

int ipwireless_tty_is_modem(struct ipw_tty *tty)
{
	return tty->tty_type == TTYTYPE_MODEM;
}

void
ipwireless_tty_notify_control_line_change(struct ipw_tty *tty,
					  unsigned int channel_idx,
					  unsigned int control_lines,
					  unsigned int changed_mask)
{
	unsigned int old_control_lines = tty->control_lines;

	tty->control_lines = (tty->control_lines & ~changed_mask)
		| (control_lines & changed_mask);

	/*
	 * If DCD is de-asserted, we close the tty so pppd can tell that we
	 * have gone offline.
	 */
	if ((old_control_lines & IPW_CONTROL_LINE_DCD)
			&& !(tty->control_lines & IPW_CONTROL_LINE_DCD)
			&& tty->port.tty) {
		tty_hangup(tty->port.tty);
	}
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
099dc4fb DS	2	/*
	3	* IPWireless 3G PCMCIA Network Driver
	4	*
	5	* Original code
	6	* by Stephen Blackheath <stephen@blacksapphire.com>,
	7	* Ben Martel <benm@symmetric.co.nz>
	8	*
	9	* Copyrighted as follows:
	10	* Copyright (C) 2004 by Symmetric Systems Ltd (NZ)
	11	*
	12	* Various driver changes and rewrites, port to new kernels
	13	* Copyright (C) 2006-2007 Jiri Kosina
	14	*
	15	* Misc code cleanups and updates
	16	* Copyright (C) 2007 David Sterba
	17	*/
	18
099dc4fb DS	19	#include <linux/kernel.h>
	20	#include <linux/module.h>
	21	#include <linux/mutex.h>
	22	#include <linux/ppp_defs.h>
	23	#include <linux/if.h>
4b32da2b	24	#include <linux/ppp-ioctl.h>
099dc4fb DS	25	#include <linux/sched.h>
	26	#include <linux/serial.h>
	27	#include <linux/slab.h>
	28	#include <linux/tty.h>
	29	#include <linux/tty_driver.h>
	30	#include <linux/tty_flip.h>
	31	#include <linux/uaccess.h>
099dc4fb DS	32
	33	#include "tty.h"
	34	#include "network.h"
	35	#include "hardware.h"
	36	#include "main.h"
	37
	38	#define IPWIRELESS_PCMCIA_START (0)
	39	#define IPWIRELESS_PCMCIA_MINORS (24)
	40	#define IPWIRELESS_PCMCIA_MINOR_RANGE (8)
	41
	42	#define TTYTYPE_MODEM (0)
	43	#define TTYTYPE_MONITOR (1)
	44	#define TTYTYPE_RAS_RAW (2)
	45
	46	struct ipw_tty {
7393af80	47	struct tty_port port;
099dc4fb DS	48	int index;
	49	struct ipw_hardware *hardware;
	50	unsigned int channel_idx;
	51	unsigned int secondary_channel_idx;
	52	int tty_type;
	53	struct ipw_network *network;
099dc4fb DS	54	unsigned int control_lines;
	55	struct mutex ipw_tty_mutex;
	56	int tx_bytes_queued;
	57	int closing;
	58	};
	59
	60	static struct ipw_tty *ttys[IPWIRELESS_PCMCIA_MINORS];
	61
	62	static struct tty_driver *ipw_tty_driver;
	63
	64	static char *tty_type_name(int tty_type)
	65	{
	66	static char *channel_names[] = {
	67	"modem",
	68	"monitor",
	69	"RAS-raw"
	70	};
	71
	72	return channel_names[tty_type];
	73	}
	74
ecaa3bda	75	static struct ipw_tty *get_tty(int index)
099dc4fb	76	{
ecaa3bda JS	77	/*
	78	* The 'ras_raw' channel is only available when 'loopback' mode
	79	* is enabled.
	80	* Number of minor starts with 16 (_RANGE * _RAS_RAW).
	81	*/
	82	if (!ipwireless_loopback && index >=
	83	IPWIRELESS_PCMCIA_MINOR_RANGE * TTYTYPE_RAS_RAW)
099dc4fb	84	return NULL;
ecaa3bda JS	85
ecaa3bda JS	86	return ttys[index];
099dc4fb DS	87	}
	88
	89	static int ipw_open(struct tty_struct linux_tty, struct file filp)
	90	{
ecaa3bda	91	struct ipw_tty *tty = get_tty(linux_tty->index);
099dc4fb DS	92
	93	if (!tty)
	94	return -ENODEV;
	95
	96	mutex_lock(&tty->ipw_tty_mutex);
7393af80	97	if (tty->port.count == 0)
099dc4fb DS	98	tty->tx_bytes_queued = 0;
099dc4fb DS	99
7393af80	100	tty->port.count++;
099dc4fb	101
19ef1b71	102	tty->port.tty = linux_tty;
099dc4fb	103	linux_tty->driver_data = tty;
d6c53c0e	104	tty->port.low_latency = 1;
099dc4fb DS	105
	106	if (tty->tty_type == TTYTYPE_MODEM)
	107	ipwireless_ppp_open(tty->network);
	108
	109	mutex_unlock(&tty->ipw_tty_mutex);
	110
	111	return 0;
	112	}
	113
	114	static void do_ipw_close(struct ipw_tty *tty)
	115	{
7393af80	116	tty->port.count--;
099dc4fb	117
7393af80	118	if (tty->port.count == 0) {
19ef1b71	119	struct tty_struct *linux_tty = tty->port.tty;
099dc4fb DS	120
099dc4fb DS	121	if (linux_tty != NULL) {
19ef1b71	122	tty->port.tty = NULL;
099dc4fb DS	123	linux_tty->driver_data = NULL;
	124
	125	if (tty->tty_type == TTYTYPE_MODEM)
	126	ipwireless_ppp_close(tty->network);
	127	}
	128	}
	129	}
	130
	131	static void ipw_hangup(struct tty_struct *linux_tty)
	132	{
	133	struct ipw_tty *tty = linux_tty->driver_data;
	134
	135	if (!tty)
	136	return;
	137
	138	mutex_lock(&tty->ipw_tty_mutex);
7393af80	139	if (tty->port.count == 0) {
099dc4fb DS	140	mutex_unlock(&tty->ipw_tty_mutex);
	141	return;
	142	}
	143
	144	do_ipw_close(tty);
	145
	146	mutex_unlock(&tty->ipw_tty_mutex);
	147	}
	148
	149	static void ipw_close(struct tty_struct linux_tty, struct file filp)
	150	{
	151	ipw_hangup(linux_tty);
	152	}
	153
	154	/* Take data received from hardware, and send it out the tty */
	155	void ipwireless_tty_received(struct ipw_tty tty, unsigned char data,
	156	unsigned int length)
	157	{
099dc4fb DS	158	int work = 0;
	159
	160	mutex_lock(&tty->ipw_tty_mutex);
099dc4fb	161
7393af80	162	if (!tty->port.count) {
099dc4fb DS	163	mutex_unlock(&tty->ipw_tty_mutex);
	164	return;
	165	}
	166	mutex_unlock(&tty->ipw_tty_mutex);
	167
05c7cd39	168	work = tty_insert_flip_string(&tty->port, data, length);
099dc4fb DS	169
	170	if (work != length)
	171	printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
	172	": %d chars not inserted to flip buffer!\n",
	173	length - work);
	174
099dc4fb	175	if (work)
2e124b4a	176	tty_flip_buffer_push(&tty->port);
099dc4fb DS	177	}
	178
	179	static void ipw_write_packet_sent_callback(void *callback_data,
	180	unsigned int packet_length)
	181	{
	182	struct ipw_tty *tty = callback_data;
	183
	184	/*
	185	* Packet has been sent, so we subtract the number of bytes from our
	186	* tally of outstanding TX bytes.
	187	*/
	188	tty->tx_bytes_queued -= packet_length;
	189	}
	190
	191	static int ipw_write(struct tty_struct *linux_tty,
	192	const unsigned char *buf, int count)
	193	{
	194	struct ipw_tty *tty = linux_tty->driver_data;
	195	int room, ret;
	196
	197	if (!tty)
	198	return -ENODEV;
	199
	200	mutex_lock(&tty->ipw_tty_mutex);
7393af80	201	if (!tty->port.count) {
099dc4fb DS	202	mutex_unlock(&tty->ipw_tty_mutex);
	203	return -EINVAL;
	204	}
	205
	206	room = IPWIRELESS_TX_QUEUE_SIZE - tty->tx_bytes_queued;
	207	if (room < 0)
	208	room = 0;
	209	/* Don't allow caller to write any more than we have room for */
	210	if (count > room)
	211	count = room;
	212
	213	if (count == 0) {
	214	mutex_unlock(&tty->ipw_tty_mutex);
	215	return 0;
	216	}
	217
	218	ret = ipwireless_send_packet(tty->hardware, IPW_CHANNEL_RAS,
ff3e990e	219	buf, count,
099dc4fb DS	220	ipw_write_packet_sent_callback, tty);
	221	if (ret == -1) {
	222	mutex_unlock(&tty->ipw_tty_mutex);
	223	return 0;
	224	}
	225
	226	tty->tx_bytes_queued += count;
	227	mutex_unlock(&tty->ipw_tty_mutex);
	228
	229	return count;
	230	}
	231
	232	static int ipw_write_room(struct tty_struct *linux_tty)
	233	{
	234	struct ipw_tty *tty = linux_tty->driver_data;
	235	int room;
	236
5aaa70a8	237	/* FIXME: Exactly how is the tty object locked here .. */
099dc4fb DS	238	if (!tty)
	239	return -ENODEV;
	240
7393af80	241	if (!tty->port.count)
099dc4fb DS	242	return -EINVAL;
	243
	244	room = IPWIRELESS_TX_QUEUE_SIZE - tty->tx_bytes_queued;
	245	if (room < 0)
	246	room = 0;
	247
	248	return room;
	249	}
	250
a7b06fcf AV	251	static int ipwireless_get_serial_info(struct tty_struct *linux_tty,
a7b06fcf AV	252	struct serial_struct *ss)
099dc4fb	253	{
a7b06fcf	254	struct ipw_tty *tty = linux_tty->driver_data;
099dc4fb	255
a7b06fcf AV	256	if (!tty)
a7b06fcf AV	257	return -ENODEV;
fec4daec	258
a7b06fcf AV	259	if (!tty->port.count)
a7b06fcf AV	260	return -EINVAL;
099dc4fb	261
a7b06fcf AV	262	ss->type = PORT_UNKNOWN;
	263	ss->line = tty->index;
	264	ss->baud_base = 115200;
099dc4fb DS	265	return 0;
	266	}
	267
a7b06fcf AV	268	static int ipwireless_set_serial_info(struct tty_struct *linux_tty,
	269	struct serial_struct *ss)
	270	{
	271	return 0; /* Keeps the PCMCIA scripts happy. */
	272	}
	273
099dc4fb DS	274	static int ipw_chars_in_buffer(struct tty_struct *linux_tty)
	275	{
	276	struct ipw_tty *tty = linux_tty->driver_data;
	277
	278	if (!tty)
23198fda	279	return 0;
099dc4fb	280
7393af80	281	if (!tty->port.count)
23198fda	282	return 0;
099dc4fb DS	283
	284	return tty->tx_bytes_queued;
	285	}
	286
	287	static int get_control_lines(struct ipw_tty *tty)
	288	{
	289	unsigned int my = tty->control_lines;
	290	unsigned int out = 0;
	291
	292	if (my & IPW_CONTROL_LINE_RTS)
	293	out \|= TIOCM_RTS;
	294	if (my & IPW_CONTROL_LINE_DTR)
	295	out \|= TIOCM_DTR;
	296	if (my & IPW_CONTROL_LINE_CTS)
	297	out \|= TIOCM_CTS;
	298	if (my & IPW_CONTROL_LINE_DSR)
	299	out \|= TIOCM_DSR;
	300	if (my & IPW_CONTROL_LINE_DCD)
	301	out \|= TIOCM_CD;
	302
	303	return out;
	304	}
	305
	306	static int set_control_lines(struct ipw_tty *tty, unsigned int set,
	307	unsigned int clear)
	308	{
	309	int ret;
	310
	311	if (set & TIOCM_RTS) {
	312	ret = ipwireless_set_RTS(tty->hardware, tty->channel_idx, 1);
	313	if (ret)
	314	return ret;
	315	if (tty->secondary_channel_idx != -1) {
	316	ret = ipwireless_set_RTS(tty->hardware,
	317	tty->secondary_channel_idx, 1);
	318	if (ret)
	319	return ret;
	320	}
	321	}
	322	if (set & TIOCM_DTR) {
	323	ret = ipwireless_set_DTR(tty->hardware, tty->channel_idx, 1);
	324	if (ret)
	325	return ret;
	326	if (tty->secondary_channel_idx != -1) {
	327	ret = ipwireless_set_DTR(tty->hardware,
	328	tty->secondary_channel_idx, 1);
	329	if (ret)
	330	return ret;
	331	}
	332	}
	333	if (clear & TIOCM_RTS) {
	334	ret = ipwireless_set_RTS(tty->hardware, tty->channel_idx, 0);
	335	if (tty->secondary_channel_idx != -1) {
	336	ret = ipwireless_set_RTS(tty->hardware,
	337	tty->secondary_channel_idx, 0);
	338	if (ret)
	339	return ret;
	340	}
	341	}
	342	if (clear & TIOCM_DTR) {
	343	ret = ipwireless_set_DTR(tty->hardware, tty->channel_idx, 0);
	344	if (tty->secondary_channel_idx != -1) {
	345	ret = ipwireless_set_DTR(tty->hardware,
	346	tty->secondary_channel_idx, 0);
347	if (ret)
348	return ret;
349	}
350	}
351	return 0;
352	}
353
60b33c13	354	static int ipw_tiocmget(struct tty_struct *linux_tty)
099dc4fb DS	355	{
099dc4fb DS	356	struct ipw_tty *tty = linux_tty->driver_data;
5aaa70a8	357	/* FIXME: Exactly how is the tty object locked here .. */
099dc4fb DS	358
	359	if (!tty)
	360	return -ENODEV;
	361
7393af80	362	if (!tty->port.count)
099dc4fb DS	363	return -EINVAL;
	364
	365	return get_control_lines(tty);
	366	}
	367
	368	static int
20b9d177	369	ipw_tiocmset(struct tty_struct *linux_tty,
099dc4fb DS	370	unsigned int set, unsigned int clear)
	371	{
	372	struct ipw_tty *tty = linux_tty->driver_data;
5aaa70a8	373	/* FIXME: Exactly how is the tty object locked here .. */
099dc4fb DS	374
	375	if (!tty)
	376	return -ENODEV;
	377
7393af80	378	if (!tty->port.count)
099dc4fb DS	379	return -EINVAL;
	380
	381	return set_control_lines(tty, set, clear);
	382	}
	383
6caa76b7	384	static int ipw_ioctl(struct tty_struct *linux_tty,
099dc4fb DS	385	unsigned int cmd, unsigned long arg)
	386	{
	387	struct ipw_tty *tty = linux_tty->driver_data;
	388
	389	if (!tty)
	390	return -ENODEV;
	391
7393af80	392	if (!tty->port.count)
099dc4fb DS	393	return -EINVAL;
099dc4fb DS	394
5aaa70a8	395	/* FIXME: Exactly how is the tty object locked here .. */
099dc4fb DS	396	if (tty->tty_type == TTYTYPE_MODEM) {
	397	switch (cmd) {
	398	case PPPIOCGCHAN:
	399	{
	400	int chan = ipwireless_ppp_channel_index(
	401	tty->network);
	402
	403	if (chan < 0)
	404	return -ENODEV;
	405	if (put_user(chan, (int __user *) arg))
	406	return -EFAULT;
	407	}
	408	return 0;
	409
	410	case PPPIOCGUNIT:
	411	{
	412	int unit = ipwireless_ppp_unit_number(
	413	tty->network);
	414
	415	if (unit < 0)
	416	return -ENODEV;
	417	if (put_user(unit, (int __user *) arg))
	418	return -EFAULT;
	419	}
	420	return 0;
	421
099dc4fb DS	422	case FIONREAD:
	423	{
	424	int val = 0;
	425
	426	if (put_user(val, (int __user *) arg))
	427	return -EFAULT;
	428	}
	429	return 0;
5aaa70a8 AC	430	case TCFLSH:
5aaa70a8 AC	431	return tty_perform_flush(linux_tty, arg);
099dc4fb DS	432	}
099dc4fb DS	433	}
6caa76b7	434	return -ENOIOCTLCMD;
099dc4fb DS	435	}
099dc4fb DS	436
b498ada6	437	static int add_tty(int j,
099dc4fb DS	438	struct ipw_hardware *hardware,
	439	struct ipw_network *network, int channel_idx,
	440	int secondary_channel_idx, int tty_type)
	441	{
	442	ttys[j] = kzalloc(sizeof(struct ipw_tty), GFP_KERNEL);
	443	if (!ttys[j])
	444	return -ENOMEM;
	445	ttys[j]->index = j;
	446	ttys[j]->hardware = hardware;
	447	ttys[j]->channel_idx = channel_idx;
	448	ttys[j]->secondary_channel_idx = secondary_channel_idx;
	449	ttys[j]->network = network;
	450	ttys[j]->tty_type = tty_type;
	451	mutex_init(&ttys[j]->ipw_tty_mutex);
7393af80	452	tty_port_init(&ttys[j]->port);
099dc4fb	453
734cc178	454	tty_port_register_device(&ttys[j]->port, ipw_tty_driver, j, NULL);
099dc4fb DS	455	ipwireless_associate_network_tty(network, channel_idx, ttys[j]);
	456
	457	if (secondary_channel_idx != -1)
	458	ipwireless_associate_network_tty(network,
	459	secondary_channel_idx,
	460	ttys[j]);
e6df3cce JS	461	/* check if we provide raw device (if loopback is enabled) */
	462	if (get_tty(j))
	463	printk(KERN_INFO IPWIRELESS_PCCARD_NAME
	464	": registering %s device ttyIPWp%d\n",
	465	tty_type_name(tty_type), j);
	466
099dc4fb DS	467	return 0;
	468	}
	469
	470	struct ipw_tty ipwireless_tty_create(struct ipw_hardware hardware,
b498ada6	471	struct ipw_network *network)
099dc4fb DS	472	{
	473	int i, j;
	474
	475	for (i = 0; i < IPWIRELESS_PCMCIA_MINOR_RANGE; i++) {
	476	int allfree = 1;
	477
	478	for (j = i; j < IPWIRELESS_PCMCIA_MINORS;
	479	j += IPWIRELESS_PCMCIA_MINOR_RANGE)
	480	if (ttys[j] != NULL) {
	481	allfree = 0;
	482	break;
	483	}
	484
	485	if (allfree) {
	486	j = i;
	487
b498ada6	488	if (add_tty(j, hardware, network,
099dc4fb DS	489	IPW_CHANNEL_DIALLER, IPW_CHANNEL_RAS,
	490	TTYTYPE_MODEM))
	491	return NULL;
	492
	493	j += IPWIRELESS_PCMCIA_MINOR_RANGE;
b498ada6	494	if (add_tty(j, hardware, network,
099dc4fb DS	495	IPW_CHANNEL_DIALLER, -1,
	496	TTYTYPE_MONITOR))
	497	return NULL;
	498
	499	j += IPWIRELESS_PCMCIA_MINOR_RANGE;
b498ada6	500	if (add_tty(j, hardware, network,
099dc4fb DS	501	IPW_CHANNEL_RAS, -1,
	502	TTYTYPE_RAS_RAW))
	503	return NULL;
	504
099dc4fb DS	505	return ttys[i];
	506	}
	507	}
	508	return NULL;
	509	}
	510
	511	/*
	512	* Must be called before ipwireless_network_free().
	513	*/
	514	void ipwireless_tty_free(struct ipw_tty *tty)
	515	{
	516	int j;
	517	struct ipw_network *network = ttys[tty->index]->network;
	518
	519	for (j = tty->index; j < IPWIRELESS_PCMCIA_MINORS;
	520	j += IPWIRELESS_PCMCIA_MINOR_RANGE) {
	521	struct ipw_tty *ttyj = ttys[j];
	522
	523	if (ttyj) {
	524	mutex_lock(&ttyj->ipw_tty_mutex);
e6df3cce JS	525	if (get_tty(j))
	526	printk(KERN_INFO IPWIRELESS_PCCARD_NAME
	527	": deregistering %s device ttyIPWp%d\n",
	528	tty_type_name(ttyj->tty_type), j);
099dc4fb	529	ttyj->closing = 1;
19ef1b71	530	if (ttyj->port.tty != NULL) {
099dc4fb	531	mutex_unlock(&ttyj->ipw_tty_mutex);
19ef1b71	532	tty_vhangup(ttyj->port.tty);
5aaa70a8 AC	533	/* FIXME: Exactly how is the tty object locked here
5aaa70a8 AC	534	against a parallel ioctl etc */
de3a60a3 JS	535	/* FIXME2: hangup does not mean all processes
de3a60a3 JS	536	* are gone */
099dc4fb DS	537	mutex_lock(&ttyj->ipw_tty_mutex);
099dc4fb DS	538	}
7393af80	539	while (ttyj->port.count)
099dc4fb DS	540	do_ipw_close(ttyj);
	541	ipwireless_disassociate_network_ttys(network,
	542	ttyj->channel_idx);
	543	tty_unregister_device(ipw_tty_driver, j);
191c5f10	544	tty_port_destroy(&ttyj->port);
099dc4fb DS	545	ttys[j] = NULL;
	546	mutex_unlock(&ttyj->ipw_tty_mutex);
	547	kfree(ttyj);
	548	}
	549	}
	550	}
	551
1cceefd3	552	static const struct tty_operations tty_ops = {
099dc4fb DS	553	.open = ipw_open,
	554	.close = ipw_close,
	555	.hangup = ipw_hangup,
	556	.write = ipw_write,
	557	.write_room = ipw_write_room,
	558	.ioctl = ipw_ioctl,
	559	.chars_in_buffer = ipw_chars_in_buffer,
	560	.tiocmget = ipw_tiocmget,
	561	.tiocmset = ipw_tiocmset,
a7b06fcf AV	562	.set_serial = ipwireless_set_serial_info,
a7b06fcf AV	563	.get_serial = ipwireless_get_serial_info,
099dc4fb DS	564	};
	565
	566	int ipwireless_tty_init(void)
	567	{
	568	int result;
	569
	570	ipw_tty_driver = alloc_tty_driver(IPWIRELESS_PCMCIA_MINORS);
	571	if (!ipw_tty_driver)
	572	return -ENOMEM;
	573
099dc4fb DS	574	ipw_tty_driver->driver_name = IPWIRELESS_PCCARD_NAME;
	575	ipw_tty_driver->name = "ttyIPWp";
	576	ipw_tty_driver->major = 0;
	577	ipw_tty_driver->minor_start = IPWIRELESS_PCMCIA_START;
	578	ipw_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
	579	ipw_tty_driver->subtype = SERIAL_TYPE_NORMAL;
	580	ipw_tty_driver->flags = TTY_DRIVER_REAL_RAW \| TTY_DRIVER_DYNAMIC_DEV;
	581	ipw_tty_driver->init_termios = tty_std_termios;
	582	ipw_tty_driver->init_termios.c_cflag =
	583	B9600 \| CS8 \| CREAD \| HUPCL \| CLOCAL;
	584	ipw_tty_driver->init_termios.c_ispeed = 9600;
	585	ipw_tty_driver->init_termios.c_ospeed = 9600;
	586	tty_set_operations(ipw_tty_driver, &tty_ops);
	587	result = tty_register_driver(ipw_tty_driver);
	588	if (result) {
	589	printk(KERN_ERR IPWIRELESS_PCCARD_NAME
	590	": failed to register tty driver\n");
	591	put_tty_driver(ipw_tty_driver);
	592	return result;
	593	}
	594
	595	return 0;
	596	}
	597
	598	void ipwireless_tty_release(void)
	599	{
	600	int ret;
	601
	602	ret = tty_unregister_driver(ipw_tty_driver);
	603	put_tty_driver(ipw_tty_driver);
	604	if (ret != 0)
	605	printk(KERN_ERR IPWIRELESS_PCCARD_NAME
	606	": tty_unregister_driver failed with code %d\n", ret);
	607	}
	608
	609	int ipwireless_tty_is_modem(struct ipw_tty *tty)
	610	{
	611	return tty->tty_type == TTYTYPE_MODEM;
	612	}
	613
	614	void
	615	ipwireless_tty_notify_control_line_change(struct ipw_tty *tty,
	616	unsigned int channel_idx,
	617	unsigned int control_lines,
	618	unsigned int changed_mask)
	619	{
	620	unsigned int old_control_lines = tty->control_lines;
	621
	622	tty->control_lines = (tty->control_lines & ~changed_mask)
	623	\| (control_lines & changed_mask);
	624
	625	/*
	626	* If DCD is de-asserted, we close the tty so pppd can tell that we
	627	* have gone offline.
	628	*/
	629	if ((old_control_lines & IPW_CONTROL_LINE_DCD)
	630	&& !(tty->control_lines & IPW_CONTROL_LINE_DCD)
19ef1b71 JS	631	&& tty->port.tty) {
19ef1b71 JS	632	tty_hangup(tty->port.tty);
099dc4fb DS	633	}
	634	}
	635