[net-next-2.6.git] / drivers / isdn / gigaset / interface.c

/*
 * interface to user space for the gigaset driver
 *
 * Copyright (c) 2004 by Hansjoerg Lipp <hjlipp@web.de>
 *
 * =====================================================================
 *    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; either version 2 of
 *    the License, or (at your option) any later version.
 * =====================================================================
 */

#include "gigaset.h"
#include <linux/gigaset_dev.h>
#include <linux/tty_flip.h>

/*** our ioctls ***/

static int if_lock(struct cardstate *cs, int *arg)
{
	int cmd = *arg;

	gig_dbg(DEBUG_IF, "%u: if_lock (%d)", cs->minor_index, cmd);

	if (cmd > 1)
		return -EINVAL;

	if (cmd < 0) {
		*arg = cs->mstate == MS_LOCKED;
		return 0;
	}

	if (!cmd && cs->mstate == MS_LOCKED && cs->connected) {
		cs->ops->set_modem_ctrl(cs, 0, TIOCM_DTR|TIOCM_RTS);
		cs->ops->baud_rate(cs, B115200);
		cs->ops->set_line_ctrl(cs, CS8);
		cs->control_state = TIOCM_DTR|TIOCM_RTS;
	}

	cs->waiting = 1;
	if (!gigaset_add_event(cs, &cs->at_state, EV_IF_LOCK,
			       NULL, cmd, NULL)) {
		cs->waiting = 0;
		return -ENOMEM;
	}
	gigaset_schedule_event(cs);

	wait_event(cs->waitqueue, !cs->waiting);

	if (cs->cmd_result >= 0) {
		*arg = cs->cmd_result;
		return 0;
	}

	return cs->cmd_result;
}

static int if_version(struct cardstate *cs, unsigned arg[4])
{
	static const unsigned version[4] = GIG_VERSION;
	static const unsigned compat[4] = GIG_COMPAT;
	unsigned cmd = arg[0];

	gig_dbg(DEBUG_IF, "%u: if_version (%d)", cs->minor_index, cmd);

	switch (cmd) {
	case GIGVER_DRIVER:
		memcpy(arg, version, sizeof version);
		return 0;
	case GIGVER_COMPAT:
		memcpy(arg, compat, sizeof compat);
		return 0;
	case GIGVER_FWBASE:
		cs->waiting = 1;
		if (!gigaset_add_event(cs, &cs->at_state, EV_IF_VER,
				       NULL, 0, arg)) {
			cs->waiting = 0;
			return -ENOMEM;
		}
		gigaset_schedule_event(cs);

		wait_event(cs->waitqueue, !cs->waiting);

		if (cs->cmd_result >= 0)
			return 0;

		return cs->cmd_result;
	default:
		return -EINVAL;
	}
}

static int if_config(struct cardstate *cs, int *arg)
{
	gig_dbg(DEBUG_IF, "%u: if_config (%d)", cs->minor_index, *arg);

	if (*arg != 1)
		return -EINVAL;

	if (cs->mstate != MS_LOCKED)
		return -EBUSY;

	if (!cs->connected) {
		pr_err("%s: not connected\n", __func__);
		return -ENODEV;
	}

	*arg = 0;
	return gigaset_enterconfigmode(cs);
}

/*** the terminal driver ***/
/* stolen from usbserial and some other tty drivers */

static int  if_open(struct tty_struct *tty, struct file *filp);
static void if_close(struct tty_struct *tty, struct file *filp);
static int  if_ioctl(struct tty_struct *tty, struct file *file,
		     unsigned int cmd, unsigned long arg);
static int  if_write_room(struct tty_struct *tty);
static int  if_chars_in_buffer(struct tty_struct *tty);
static void if_throttle(struct tty_struct *tty);
static void if_unthrottle(struct tty_struct *tty);
static void if_set_termios(struct tty_struct *tty, struct ktermios *old);
static int  if_tiocmget(struct tty_struct *tty, struct file *file);
static int  if_tiocmset(struct tty_struct *tty, struct file *file,
			unsigned int set, unsigned int clear);
static int  if_write(struct tty_struct *tty,
		     const unsigned char *buf, int count);

static const struct tty_operations if_ops = {
	.open =			if_open,
	.close =		if_close,
	.ioctl =		if_ioctl,
	.write =		if_write,
	.write_room =		if_write_room,
	.chars_in_buffer =	if_chars_in_buffer,
	.set_termios =		if_set_termios,
	.throttle =		if_throttle,
	.unthrottle =		if_unthrottle,
	.tiocmget =		if_tiocmget,
	.tiocmset =		if_tiocmset,
};

static int if_open(struct tty_struct *tty, struct file *filp)
{
	struct cardstate *cs;
	unsigned long flags;

	gig_dbg(DEBUG_IF, "%d+%d: %s()",
		tty->driver->minor_start, tty->index, __func__);

	tty->driver_data = NULL;

	cs = gigaset_get_cs_by_tty(tty);
	if (!cs || !try_module_get(cs->driver->owner))
		return -ENODEV;

	if (mutex_lock_interruptible(&cs->mutex))
		return -ERESTARTSYS;
	tty->driver_data = cs;

	++cs->open_count;

	if (cs->open_count == 1) {
		spin_lock_irqsave(&cs->lock, flags);
		cs->tty = tty;
		spin_unlock_irqrestore(&cs->lock, flags);
		tty->low_latency = 1;
	}

	mutex_unlock(&cs->mutex);
	return 0;
}

static void if_close(struct tty_struct *tty, struct file *filp)
{
	struct cardstate *cs;
	unsigned long flags;

	cs = (struct cardstate *) tty->driver_data;
	if (!cs) {
		pr_err("%s: no cardstate\n", __func__);
		return;
	}

	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);

	mutex_lock(&cs->mutex);

	if (!cs->connected)
		gig_dbg(DEBUG_IF, "not connected");	/* nothing to do */
	else if (!cs->open_count)
		dev_warn(cs->dev, "%s: device not opened\n", __func__);
	else {
		if (!--cs->open_count) {
			spin_lock_irqsave(&cs->lock, flags);
			cs->tty = NULL;
			spin_unlock_irqrestore(&cs->lock, flags);
		}
	}

	mutex_unlock(&cs->mutex);

	module_put(cs->driver->owner);
}

static int if_ioctl(struct tty_struct *tty, struct file *file,
		    unsigned int cmd, unsigned long arg)
{
	struct cardstate *cs;
	int retval = -ENODEV;
	int int_arg;
	unsigned char buf[6];
	unsigned version[4];

	cs = (struct cardstate *) tty->driver_data;
	if (!cs) {
		pr_err("%s: no cardstate\n", __func__);
		return -ENODEV;
	}

	gig_dbg(DEBUG_IF, "%u: %s(0x%x)", cs->minor_index, __func__, cmd);

	if (mutex_lock_interruptible(&cs->mutex))
		return -ERESTARTSYS;

	if (!cs->connected) {
		gig_dbg(DEBUG_IF, "not connected");
		retval = -ENODEV;
	} else if (!cs->open_count)
		dev_warn(cs->dev, "%s: device not opened\n", __func__);
	else {
		retval = 0;
		switch (cmd) {
		case GIGASET_REDIR:
			retval = get_user(int_arg, (int __user *) arg);
			if (retval >= 0)
				retval = if_lock(cs, &int_arg);
			if (retval >= 0)
				retval = put_user(int_arg, (int __user *) arg);
			break;
		case GIGASET_CONFIG:
			retval = get_user(int_arg, (int __user *) arg);
			if (retval >= 0)
				retval = if_config(cs, &int_arg);
			if (retval >= 0)
				retval = put_user(int_arg, (int __user *) arg);
			break;
		case GIGASET_BRKCHARS:
			retval = copy_from_user(&buf,
					(const unsigned char __user *) arg, 6)
				? -EFAULT : 0;
			if (retval >= 0) {
				gigaset_dbg_buffer(DEBUG_IF, "GIGASET_BRKCHARS",
						6, (const unsigned char *) arg);
				retval = cs->ops->brkchars(cs, buf);
			}
			break;
		case GIGASET_VERSION:
			retval = copy_from_user(version,
					(unsigned __user *) arg, sizeof version)
				? -EFAULT : 0;
			if (retval >= 0)
				retval = if_version(cs, version);
			if (retval >= 0)
				retval = copy_to_user((unsigned __user *) arg,
						      version, sizeof version)
					? -EFAULT : 0;
			break;
		default:
			gig_dbg(DEBUG_IF, "%s: arg not supported - 0x%04x",
				__func__, cmd);
			retval = -ENOIOCTLCMD;
		}
	}

	mutex_unlock(&cs->mutex);

	return retval;
}

static int if_tiocmget(struct tty_struct *tty, struct file *file)
{
	struct cardstate *cs;
	int retval;

	cs = (struct cardstate *) tty->driver_data;
	if (!cs) {
		pr_err("%s: no cardstate\n", __func__);
		return -ENODEV;
	}

	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);

	if (mutex_lock_interruptible(&cs->mutex))
		return -ERESTARTSYS;

	retval = cs->control_state & (TIOCM_RTS|TIOCM_DTR);

	mutex_unlock(&cs->mutex);

	return retval;
}

static int if_tiocmset(struct tty_struct *tty, struct file *file,
		       unsigned int set, unsigned int clear)
{
	struct cardstate *cs;
	int retval;
	unsigned mc;

	cs = (struct cardstate *) tty->driver_data;
	if (!cs) {
		pr_err("%s: no cardstate\n", __func__);
		return -ENODEV;
	}

	gig_dbg(DEBUG_IF, "%u: %s(0x%x, 0x%x)",
		cs->minor_index, __func__, set, clear);

	if (mutex_lock_interruptible(&cs->mutex))
		return -ERESTARTSYS;

	if (!cs->connected) {
		gig_dbg(DEBUG_IF, "not connected");
		retval = -ENODEV;
	} else {
		mc = (cs->control_state | set) & ~clear & (TIOCM_RTS|TIOCM_DTR);
		retval = cs->ops->set_modem_ctrl(cs, cs->control_state, mc);
		cs->control_state = mc;
	}

	mutex_unlock(&cs->mutex);

	return retval;
}

static int if_write(struct tty_struct *tty, const unsigned char *buf, int count)
{
	struct cardstate *cs;
	int retval = -ENODEV;

	cs = (struct cardstate *) tty->driver_data;
	if (!cs) {
		pr_err("%s: no cardstate\n", __func__);
		return -ENODEV;
	}

	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);

	if (mutex_lock_interruptible(&cs->mutex))
		return -ERESTARTSYS;

	if (!cs->connected) {
		gig_dbg(DEBUG_IF, "not connected");
		retval = -ENODEV;
	} else if (!cs->open_count)
		dev_warn(cs->dev, "%s: device not opened\n", __func__);
	else if (cs->mstate != MS_LOCKED) {
		dev_warn(cs->dev, "can't write to unlocked device\n");
		retval = -EBUSY;
	} else {
		retval = cs->ops->write_cmd(cs, buf, count,
					    &cs->if_wake_tasklet);
	}

	mutex_unlock(&cs->mutex);

	return retval;
}

static int if_write_room(struct tty_struct *tty)
{
	struct cardstate *cs;
	int retval = -ENODEV;

	cs = (struct cardstate *) tty->driver_data;
	if (!cs) {
		pr_err("%s: no cardstate\n", __func__);
		return -ENODEV;
	}

	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);

	if (mutex_lock_interruptible(&cs->mutex))
		return -ERESTARTSYS;

	if (!cs->connected) {
		gig_dbg(DEBUG_IF, "not connected");
		retval = -ENODEV;
	} else if (!cs->open_count)
		dev_warn(cs->dev, "%s: device not opened\n", __func__);
	else if (cs->mstate != MS_LOCKED) {
		dev_warn(cs->dev, "can't write to unlocked device\n");
		retval = -EBUSY;
	} else
		retval = cs->ops->write_room(cs);

	mutex_unlock(&cs->mutex);

	return retval;
}

static int if_chars_in_buffer(struct tty_struct *tty)
{
	struct cardstate *cs;
	int retval = 0;

	cs = (struct cardstate *) tty->driver_data;
	if (!cs) {
		pr_err("%s: no cardstate\n", __func__);
		return 0;
	}

	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);

	mutex_lock(&cs->mutex);

	if (!cs->connected)
		gig_dbg(DEBUG_IF, "not connected");
	else if (!cs->open_count)
		dev_warn(cs->dev, "%s: device not opened\n", __func__);
	else if (cs->mstate != MS_LOCKED)
		dev_warn(cs->dev, "can't write to unlocked device\n");
	else
		retval = cs->ops->chars_in_buffer(cs);

	mutex_unlock(&cs->mutex);

	return retval;
}

static void if_throttle(struct tty_struct *tty)
{
	struct cardstate *cs;

	cs = (struct cardstate *) tty->driver_data;
	if (!cs) {
		pr_err("%s: no cardstate\n", __func__);
		return;
	}

	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);

	mutex_lock(&cs->mutex);

	if (!cs->connected)
		gig_dbg(DEBUG_IF, "not connected");	/* nothing to do */
	else if (!cs->open_count)
		dev_warn(cs->dev, "%s: device not opened\n", __func__);
	else
		gig_dbg(DEBUG_IF, "%s: not implemented\n", __func__);

	mutex_unlock(&cs->mutex);
}

static void if_unthrottle(struct tty_struct *tty)
{
	struct cardstate *cs;

	cs = (struct cardstate *) tty->driver_data;
	if (!cs) {
		pr_err("%s: no cardstate\n", __func__);
		return;
	}

	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);

	mutex_lock(&cs->mutex);

	if (!cs->connected)
		gig_dbg(DEBUG_IF, "not connected");	/* nothing to do */
	else if (!cs->open_count)
		dev_warn(cs->dev, "%s: device not opened\n", __func__);
	else
		gig_dbg(DEBUG_IF, "%s: not implemented\n", __func__);

	mutex_unlock(&cs->mutex);
}

static void if_set_termios(struct tty_struct *tty, struct ktermios *old)
{
	struct cardstate *cs;
	unsigned int iflag;
	unsigned int cflag;
	unsigned int old_cflag;
	unsigned int control_state, new_state;

	cs = (struct cardstate *) tty->driver_data;
	if (!cs) {
		pr_err("%s: no cardstate\n", __func__);
		return;
	}

	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);

	mutex_lock(&cs->mutex);

	if (!cs->connected) {
		gig_dbg(DEBUG_IF, "not connected");
		goto out;
	}

	if (!cs->open_count) {
		dev_warn(cs->dev, "%s: device not opened\n", __func__);
		goto out;
	}

	iflag = tty->termios->c_iflag;
	cflag = tty->termios->c_cflag;
	old_cflag = old ? old->c_cflag : cflag;
	gig_dbg(DEBUG_IF, "%u: iflag %x cflag %x old %x",
		cs->minor_index, iflag, cflag, old_cflag);

	/* get a local copy of the current port settings */
	control_state = cs->control_state;

	/*
	 * Update baud rate.
	 * Do not attempt to cache old rates and skip settings,
	 * disconnects screw such tricks up completely.
	 * Premature optimization is the root of all evil.
	 */

	/* reassert DTR and (maybe) RTS on transition from B0 */
	if ((old_cflag & CBAUD) == B0) {
		new_state = control_state | TIOCM_DTR;
		/* don't set RTS if using hardware flow control */
		if (!(old_cflag & CRTSCTS))
			new_state |= TIOCM_RTS;
		gig_dbg(DEBUG_IF, "%u: from B0 - set DTR%s",
			cs->minor_index,
			(new_state & TIOCM_RTS) ? " only" : "/RTS");
		cs->ops->set_modem_ctrl(cs, control_state, new_state);
		control_state = new_state;
	}

	cs->ops->baud_rate(cs, cflag & CBAUD);

	if ((cflag & CBAUD) == B0) {
		/* Drop RTS and DTR */
		gig_dbg(DEBUG_IF, "%u: to B0 - drop DTR/RTS", cs->minor_index);
		new_state = control_state & ~(TIOCM_DTR | TIOCM_RTS);
		cs->ops->set_modem_ctrl(cs, control_state, new_state);
		control_state = new_state;
	}

	/*
	 * Update line control register (LCR)
	 */

	cs->ops->set_line_ctrl(cs, cflag);

	/* save off the modified port settings */
	cs->control_state = control_state;

out:
	mutex_unlock(&cs->mutex);
}


/* wakeup tasklet for the write operation */
static void if_wake(unsigned long data)
{
	struct cardstate *cs = (struct cardstate *) data;

	if (cs->tty)
		tty_wakeup(cs->tty);
}

/*** interface to common ***/

void gigaset_if_init(struct cardstate *cs)
{
	struct gigaset_driver *drv;

	drv = cs->driver;
	if (!drv->have_tty)
		return;

	tasklet_init(&cs->if_wake_tasklet, if_wake, (unsigned long) cs);

	mutex_lock(&cs->mutex);
	cs->tty_dev = tty_register_device(drv->tty, cs->minor_index, NULL);

	if (!IS_ERR(cs->tty_dev))
		dev_set_drvdata(cs->tty_dev, cs);
	else {
		pr_warning("could not register device to the tty subsystem\n");
		cs->tty_dev = NULL;
	}
	mutex_unlock(&cs->mutex);
}

void gigaset_if_free(struct cardstate *cs)
{
	struct gigaset_driver *drv;

	drv = cs->driver;
	if (!drv->have_tty)
		return;

	tasklet_disable(&cs->if_wake_tasklet);
	tasklet_kill(&cs->if_wake_tasklet);
	cs->tty_dev = NULL;
	tty_unregister_device(drv->tty, cs->minor_index);
}

/**
 * gigaset_if_receive() - pass a received block of data to the tty device
 * @cs:		device descriptor structure.
 * @buffer:	received data.
 * @len:	number of bytes received.
 *
 * Called by asyncdata/isocdata if a block of data received from the
 * device must be sent to userspace through the ttyG* device.
 */
void gigaset_if_receive(struct cardstate *cs,
			unsigned char *buffer, size_t len)
{
	unsigned long flags;
	struct tty_struct *tty;

	spin_lock_irqsave(&cs->lock, flags);
	tty = cs->tty;
	if (tty == NULL)
		gig_dbg(DEBUG_IF, "receive on closed device");
	else {
		tty_insert_flip_string(tty, buffer, len);
		tty_flip_buffer_push(tty);
	}
	spin_unlock_irqrestore(&cs->lock, flags);
}
EXPORT_SYMBOL_GPL(gigaset_if_receive);

/* gigaset_if_initdriver
 * Initialize tty interface.
 * parameters:
 *	drv		Driver
 *	procname	Name of the driver (e.g. for /proc/tty/drivers)
 *	devname		Name of the device files (prefix without minor number)
 */
void gigaset_if_initdriver(struct gigaset_driver *drv, const char *procname,
			   const char *devname)
{
	unsigned minors = drv->minors;
	int ret;
	struct tty_driver *tty;

	drv->have_tty = 0;

	drv->tty = tty = alloc_tty_driver(minors);
	if (tty == NULL)
		goto enomem;

	tty->magic =		TTY_DRIVER_MAGIC,
	tty->major =		GIG_MAJOR,
	tty->type =		TTY_DRIVER_TYPE_SERIAL,
	tty->subtype =		SERIAL_TYPE_NORMAL,
	tty->flags =		TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;

	tty->driver_name =	procname;
	tty->name =		devname;
	tty->minor_start =	drv->minor;
	tty->num =		drv->minors;

	tty->owner =		THIS_MODULE;

	tty->init_termios          = tty_std_termios;
	tty->init_termios.c_cflag  = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
	tty_set_operations(tty, &if_ops);

	ret = tty_register_driver(tty);
	if (ret < 0) {
		pr_err("error %d registering tty driver\n", ret);
		goto error;
	}
	gig_dbg(DEBUG_IF, "tty driver initialized");
	drv->have_tty = 1;
	return;

enomem:
	pr_err("out of memory\n");
error:
	if (drv->tty)
		put_tty_driver(drv->tty);
}

void gigaset_if_freedriver(struct gigaset_driver *drv)
{
	if (!drv->have_tty)
		return;

	drv->have_tty = 0;
	tty_unregister_driver(drv->tty);
	put_tty_driver(drv->tty);
}
Commit	Line	Data
ee8a4b7f HL	1	/*
	2	* interface to user space for the gigaset driver
	3	*
	4	* Copyright (c) 2004 by Hansjoerg Lipp <hjlipp@web.de>
	5	*
	6	* =====================================================================
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License as
	9	* published by the Free Software Foundation; either version 2 of
	10	* the License, or (at your option) any later version.
	11	* =====================================================================
ee8a4b7f HL	12	*/
	13
	14	#include "gigaset.h"
	15	#include <linux/gigaset_dev.h>
ee8a4b7f HL	16	#include <linux/tty_flip.h>
	17
	18	/* our ioctls */
	19
	20	static int if_lock(struct cardstate cs, int arg)
	21	{
	22	int cmd = *arg;
	23
784d5858	24	gig_dbg(DEBUG_IF, "%u: if_lock (%d)", cs->minor_index, cmd);
ee8a4b7f HL	25
	26	if (cmd > 1)
	27	return -EINVAL;
	28
	29	if (cmd < 0) {
9d4bee2b	30	*arg = cs->mstate == MS_LOCKED;
ee8a4b7f HL	31	return 0;
	32	}
	33
9d4bee2b	34	if (!cmd && cs->mstate == MS_LOCKED && cs->connected) {
ee8a4b7f HL	35	cs->ops->set_modem_ctrl(cs, 0, TIOCM_DTR\|TIOCM_RTS);
	36	cs->ops->baud_rate(cs, B115200);
	37	cs->ops->set_line_ctrl(cs, CS8);
	38	cs->control_state = TIOCM_DTR\|TIOCM_RTS;
	39	}
	40
	41	cs->waiting = 1;
	42	if (!gigaset_add_event(cs, &cs->at_state, EV_IF_LOCK,
784d5858	43	NULL, cmd, NULL)) {
ee8a4b7f HL	44	cs->waiting = 0;
	45	return -ENOMEM;
	46	}
ee8a4b7f HL	47	gigaset_schedule_event(cs);
	48
	49	wait_event(cs->waitqueue, !cs->waiting);
	50
	51	if (cs->cmd_result >= 0) {
	52	*arg = cs->cmd_result;
	53	return 0;
	54	}
	55
	56	return cs->cmd_result;
	57	}
	58
	59	static int if_version(struct cardstate *cs, unsigned arg[4])
	60	{
	61	static const unsigned version[4] = GIG_VERSION;
	62	static const unsigned compat[4] = GIG_COMPAT;
	63	unsigned cmd = arg[0];
	64
784d5858	65	gig_dbg(DEBUG_IF, "%u: if_version (%d)", cs->minor_index, cmd);
ee8a4b7f HL	66
	67	switch (cmd) {
	68	case GIGVER_DRIVER:
	69	memcpy(arg, version, sizeof version);
	70	return 0;
	71	case GIGVER_COMPAT:
	72	memcpy(arg, compat, sizeof compat);
	73	return 0;
	74	case GIGVER_FWBASE:
	75	cs->waiting = 1;
	76	if (!gigaset_add_event(cs, &cs->at_state, EV_IF_VER,
784d5858	77	NULL, 0, arg)) {
ee8a4b7f HL	78	cs->waiting = 0;
	79	return -ENOMEM;
	80	}
ee8a4b7f HL	81	gigaset_schedule_event(cs);
	82
	83	wait_event(cs->waitqueue, !cs->waiting);
	84
	85	if (cs->cmd_result >= 0)
	86	return 0;
	87
	88	return cs->cmd_result;
	89	default:
	90	return -EINVAL;
	91	}
	92	}
	93
	94	static int if_config(struct cardstate cs, int arg)
	95	{
784d5858	96	gig_dbg(DEBUG_IF, "%u: if_config (%d)", cs->minor_index, *arg);
ee8a4b7f HL	97
	98	if (*arg != 1)
	99	return -EINVAL;
	100
9d4bee2b	101	if (cs->mstate != MS_LOCKED)
ee8a4b7f HL	102	return -EBUSY;
ee8a4b7f HL	103
69049cc8	104	if (!cs->connected) {
c8770dca	105	pr_err("%s: not connected\n", __func__);
69049cc8 TS	106	return -ENODEV;
	107	}
	108
ee8a4b7f HL	109	*arg = 0;
	110	return gigaset_enterconfigmode(cs);
	111	}
	112
	113	/* the terminal driver */
	114	/* stolen from usbserial and some other tty drivers */
	115
	116	static int if_open(struct tty_struct tty, struct file filp);
	117	static void if_close(struct tty_struct tty, struct file filp);
	118	static int if_ioctl(struct tty_struct tty, struct file file,
784d5858	119	unsigned int cmd, unsigned long arg);
ee8a4b7f HL	120	static int if_write_room(struct tty_struct *tty);
	121	static int if_chars_in_buffer(struct tty_struct *tty);
	122	static void if_throttle(struct tty_struct *tty);
	123	static void if_unthrottle(struct tty_struct *tty);
606d099c	124	static void if_set_termios(struct tty_struct tty, struct ktermios old);
ee8a4b7f HL	125	static int if_tiocmget(struct tty_struct tty, struct file file);
ee8a4b7f HL	126	static int if_tiocmset(struct tty_struct tty, struct file file,
784d5858	127	unsigned int set, unsigned int clear);
ee8a4b7f	128	static int if_write(struct tty_struct *tty,
784d5858	129	const unsigned char *buf, int count);
ee8a4b7f	130
b68e31d0	131	static const struct tty_operations if_ops = {
ee8a4b7f HL	132	.open = if_open,
	133	.close = if_close,
	134	.ioctl = if_ioctl,
	135	.write = if_write,
	136	.write_room = if_write_room,
	137	.chars_in_buffer = if_chars_in_buffer,
	138	.set_termios = if_set_termios,
	139	.throttle = if_throttle,
	140	.unthrottle = if_unthrottle,
ee8a4b7f HL	141	.tiocmget = if_tiocmget,
	142	.tiocmset = if_tiocmset,
	143	};
	144
	145	static int if_open(struct tty_struct tty, struct file filp)
	146	{
	147	struct cardstate *cs;
	148	unsigned long flags;
	149
784d5858 TS	150	gig_dbg(DEBUG_IF, "%d+%d: %s()",
784d5858 TS	151	tty->driver->minor_start, tty->index, __func__);
ee8a4b7f HL	152
	153	tty->driver_data = NULL;
	154
	155	cs = gigaset_get_cs_by_tty(tty);
e468c048	156	if (!cs \|\| !try_module_get(cs->driver->owner))
ee8a4b7f HL	157	return -ENODEV;
ee8a4b7f HL	158
abfd1dc7	159	if (mutex_lock_interruptible(&cs->mutex))
d9ba9c91	160	return -ERESTARTSYS;
ee8a4b7f HL	161	tty->driver_data = cs;
	162
	163	++cs->open_count;
	164
	165	if (cs->open_count == 1) {
	166	spin_lock_irqsave(&cs->lock, flags);
	167	cs->tty = tty;
	168	spin_unlock_irqrestore(&cs->lock, flags);
d9ba9c91	169	tty->low_latency = 1;
ee8a4b7f HL	170	}
ee8a4b7f HL	171
abfd1dc7	172	mutex_unlock(&cs->mutex);
ee8a4b7f HL	173	return 0;
	174	}
	175
	176	static void if_close(struct tty_struct tty, struct file filp)
	177	{
	178	struct cardstate *cs;
	179	unsigned long flags;
	180
	181	cs = (struct cardstate *) tty->driver_data;
	182	if (!cs) {
c8770dca	183	pr_err("%s: no cardstate\n", __func__);
ee8a4b7f HL	184	return;
	185	}
	186
784d5858	187	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
ee8a4b7f	188
abfd1dc7	189	mutex_lock(&cs->mutex);
ee8a4b7f	190
51370e5b TS	191	if (!cs->connected)
	192	gig_dbg(DEBUG_IF, "not connected"); /* nothing to do */
	193	else if (!cs->open_count)
5002779d	194	dev_warn(cs->dev, "%s: device not opened\n", __func__);
ee8a4b7f HL	195	else {
	196	if (!--cs->open_count) {
	197	spin_lock_irqsave(&cs->lock, flags);
	198	cs->tty = NULL;
	199	spin_unlock_irqrestore(&cs->lock, flags);
ee8a4b7f HL	200	}
	201	}
	202
abfd1dc7	203	mutex_unlock(&cs->mutex);
e468c048 TS	204
e468c048 TS	205	module_put(cs->driver->owner);
ee8a4b7f HL	206	}
	207
	208	static int if_ioctl(struct tty_struct tty, struct file file,
784d5858	209	unsigned int cmd, unsigned long arg)
ee8a4b7f HL	210	{
	211	struct cardstate *cs;
	212	int retval = -ENODEV;
	213	int int_arg;
	214	unsigned char buf[6];
	215	unsigned version[4];
	216
	217	cs = (struct cardstate *) tty->driver_data;
	218	if (!cs) {
c8770dca	219	pr_err("%s: no cardstate\n", __func__);
ee8a4b7f HL	220	return -ENODEV;
	221	}
	222
784d5858	223	gig_dbg(DEBUG_IF, "%u: %s(0x%x)", cs->minor_index, __func__, cmd);
ee8a4b7f	224
abfd1dc7	225	if (mutex_lock_interruptible(&cs->mutex))
d9ba9c91	226	return -ERESTARTSYS;
ee8a4b7f	227
51370e5b TS	228	if (!cs->connected) {
	229	gig_dbg(DEBUG_IF, "not connected");
	230	retval = -ENODEV;
	231	} else if (!cs->open_count)
5002779d	232	dev_warn(cs->dev, "%s: device not opened\n", __func__);
ee8a4b7f HL	233	else {
	234	retval = 0;
	235	switch (cmd) {
	236	case GIGASET_REDIR:
	237	retval = get_user(int_arg, (int __user *) arg);
	238	if (retval >= 0)
	239	retval = if_lock(cs, &int_arg);
	240	if (retval >= 0)
	241	retval = put_user(int_arg, (int __user *) arg);
	242	break;
	243	case GIGASET_CONFIG:
	244	retval = get_user(int_arg, (int __user *) arg);
	245	if (retval >= 0)
	246	retval = if_config(cs, &int_arg);
	247	if (retval >= 0)
	248	retval = put_user(int_arg, (int __user *) arg);
	249	break;
	250	case GIGASET_BRKCHARS:
ee8a4b7f	251	retval = copy_from_user(&buf,
784d5858 TS	252	(const unsigned char __user *) arg, 6)
784d5858 TS	253	? -EFAULT : 0;
01371500 TS	254	if (retval >= 0) {
	255	gigaset_dbg_buffer(DEBUG_IF, "GIGASET_BRKCHARS",
	256	6, (const unsigned char *) arg);
ee8a4b7f	257	retval = cs->ops->brkchars(cs, buf);
01371500	258	}
ee8a4b7f HL	259	break;
ee8a4b7f HL	260	case GIGASET_VERSION:
917f5085	261	retval = copy_from_user(version,
784d5858 TS	262	(unsigned __user *) arg, sizeof version)
784d5858 TS	263	? -EFAULT : 0;
ee8a4b7f HL	264	if (retval >= 0)
	265	retval = if_version(cs, version);
	266	if (retval >= 0)
917f5085	267	retval = copy_to_user((unsigned __user *) arg,
784d5858 TS	268	version, sizeof version)
784d5858 TS	269	? -EFAULT : 0;
ee8a4b7f	270	break;
784d5858	271	default:
1528b18f	272	gig_dbg(DEBUG_IF, "%s: arg not supported - 0x%04x",
784d5858	273	__func__, cmd);
ee8a4b7f HL	274	retval = -ENOIOCTLCMD;
	275	}
	276	}
	277
abfd1dc7	278	mutex_unlock(&cs->mutex);
ee8a4b7f HL	279
	280	return retval;
	281	}
	282
	283	static int if_tiocmget(struct tty_struct tty, struct file file)
	284	{
	285	struct cardstate *cs;
	286	int retval;
	287
	288	cs = (struct cardstate *) tty->driver_data;
	289	if (!cs) {
c8770dca	290	pr_err("%s: no cardstate\n", __func__);
ee8a4b7f HL	291	return -ENODEV;
	292	}
	293
784d5858	294	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
ee8a4b7f	295
abfd1dc7	296	if (mutex_lock_interruptible(&cs->mutex))
d9ba9c91	297	return -ERESTARTSYS;
ee8a4b7f	298
ee8a4b7f HL	299	retval = cs->control_state & (TIOCM_RTS\|TIOCM_DTR);
ee8a4b7f HL	300
abfd1dc7	301	mutex_unlock(&cs->mutex);
ee8a4b7f HL	302
	303	return retval;
	304	}
	305
	306	static int if_tiocmset(struct tty_struct tty, struct file file,
784d5858	307	unsigned int set, unsigned int clear)
ee8a4b7f HL	308	{
	309	struct cardstate *cs;
	310	int retval;
	311	unsigned mc;
	312
	313	cs = (struct cardstate *) tty->driver_data;
	314	if (!cs) {
c8770dca	315	pr_err("%s: no cardstate\n", __func__);
ee8a4b7f HL	316	return -ENODEV;
	317	}
	318
784d5858 TS	319	gig_dbg(DEBUG_IF, "%u: %s(0x%x, 0x%x)",
784d5858 TS	320	cs->minor_index, __func__, set, clear);
ee8a4b7f	321
abfd1dc7	322	if (mutex_lock_interruptible(&cs->mutex))
d9ba9c91	323	return -ERESTARTSYS;
ee8a4b7f	324
69049cc8	325	if (!cs->connected) {
51370e5b	326	gig_dbg(DEBUG_IF, "not connected");
ee8a4b7f HL	327	retval = -ENODEV;
	328	} else {
	329	mc = (cs->control_state \| set) & ~clear & (TIOCM_RTS\|TIOCM_DTR);
	330	retval = cs->ops->set_modem_ctrl(cs, cs->control_state, mc);
	331	cs->control_state = mc;
	332	}
	333
abfd1dc7	334	mutex_unlock(&cs->mutex);
ee8a4b7f HL	335
	336	return retval;
	337	}
	338
	339	static int if_write(struct tty_struct tty, const unsigned char buf, int count)
	340	{
	341	struct cardstate *cs;
	342	int retval = -ENODEV;
	343
	344	cs = (struct cardstate *) tty->driver_data;
	345	if (!cs) {
c8770dca	346	pr_err("%s: no cardstate\n", __func__);
ee8a4b7f HL	347	return -ENODEV;
	348	}
	349
784d5858	350	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
ee8a4b7f	351
abfd1dc7	352	if (mutex_lock_interruptible(&cs->mutex))
d9ba9c91	353	return -ERESTARTSYS;
ee8a4b7f	354
51370e5b TS	355	if (!cs->connected) {
	356	gig_dbg(DEBUG_IF, "not connected");
	357	retval = -ENODEV;
	358	} else if (!cs->open_count)
5002779d	359	dev_warn(cs->dev, "%s: device not opened\n", __func__);
9d4bee2b	360	else if (cs->mstate != MS_LOCKED) {
5002779d	361	dev_warn(cs->dev, "can't write to unlocked device\n");
ee8a4b7f	362	retval = -EBUSY;
ee8a4b7f HL	363	} else {
ee8a4b7f HL	364	retval = cs->ops->write_cmd(cs, buf, count,
784d5858	365	&cs->if_wake_tasklet);
ee8a4b7f HL	366	}
ee8a4b7f HL	367
abfd1dc7	368	mutex_unlock(&cs->mutex);
ee8a4b7f HL	369
	370	return retval;
	371	}
	372
	373	static int if_write_room(struct tty_struct *tty)
	374	{
	375	struct cardstate *cs;
	376	int retval = -ENODEV;
	377
	378	cs = (struct cardstate *) tty->driver_data;
	379	if (!cs) {
c8770dca	380	pr_err("%s: no cardstate\n", __func__);
ee8a4b7f HL	381	return -ENODEV;
	382	}
	383
784d5858	384	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
ee8a4b7f	385
abfd1dc7	386	if (mutex_lock_interruptible(&cs->mutex))
d9ba9c91	387	return -ERESTARTSYS;
ee8a4b7f	388
51370e5b TS	389	if (!cs->connected) {
	390	gig_dbg(DEBUG_IF, "not connected");
	391	retval = -ENODEV;
	392	} else if (!cs->open_count)
5002779d	393	dev_warn(cs->dev, "%s: device not opened\n", __func__);
9d4bee2b	394	else if (cs->mstate != MS_LOCKED) {
5002779d	395	dev_warn(cs->dev, "can't write to unlocked device\n");
9d4bee2b	396	retval = -EBUSY;
ee8a4b7f HL	397	} else
	398	retval = cs->ops->write_room(cs);
	399
abfd1dc7	400	mutex_unlock(&cs->mutex);
ee8a4b7f HL	401
	402	return retval;
	403	}
	404
	405	static int if_chars_in_buffer(struct tty_struct *tty)
	406	{
	407	struct cardstate *cs;
a4304f2d	408	int retval = 0;
ee8a4b7f HL	409
	410	cs = (struct cardstate *) tty->driver_data;
	411	if (!cs) {
c8770dca	412	pr_err("%s: no cardstate\n", __func__);
a4304f2d	413	return 0;
ee8a4b7f HL	414	}
ee8a4b7f HL	415
784d5858	416	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
ee8a4b7f	417
a4304f2d	418	mutex_lock(&cs->mutex);
ee8a4b7f	419
a4304f2d	420	if (!cs->connected)
51370e5b	421	gig_dbg(DEBUG_IF, "not connected");
a4304f2d	422	else if (!cs->open_count)
5002779d	423	dev_warn(cs->dev, "%s: device not opened\n", __func__);
a4304f2d	424	else if (cs->mstate != MS_LOCKED)
5002779d	425	dev_warn(cs->dev, "can't write to unlocked device\n");
a4304f2d	426	else
ee8a4b7f HL	427	retval = cs->ops->chars_in_buffer(cs);
ee8a4b7f HL	428
abfd1dc7	429	mutex_unlock(&cs->mutex);
ee8a4b7f HL	430
	431	return retval;
	432	}
	433
	434	static void if_throttle(struct tty_struct *tty)
	435	{
	436	struct cardstate *cs;
	437
	438	cs = (struct cardstate *) tty->driver_data;
	439	if (!cs) {
c8770dca	440	pr_err("%s: no cardstate\n", __func__);
ee8a4b7f HL	441	return;
	442	}
	443
784d5858	444	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
ee8a4b7f	445
abfd1dc7	446	mutex_lock(&cs->mutex);
ee8a4b7f	447
51370e5b TS	448	if (!cs->connected)
	449	gig_dbg(DEBUG_IF, "not connected"); /* nothing to do */
	450	else if (!cs->open_count)
5002779d	451	dev_warn(cs->dev, "%s: device not opened\n", __func__);
d9ba9c91	452	else
1528b18f	453	gig_dbg(DEBUG_IF, "%s: not implemented\n", __func__);
ee8a4b7f	454
abfd1dc7	455	mutex_unlock(&cs->mutex);
ee8a4b7f HL	456	}
	457
	458	static void if_unthrottle(struct tty_struct *tty)
	459	{
	460	struct cardstate *cs;
	461
	462	cs = (struct cardstate *) tty->driver_data;
	463	if (!cs) {
c8770dca	464	pr_err("%s: no cardstate\n", __func__);
ee8a4b7f HL	465	return;
	466	}
	467
784d5858	468	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
ee8a4b7f	469
abfd1dc7	470	mutex_lock(&cs->mutex);
ee8a4b7f	471
51370e5b TS	472	if (!cs->connected)
	473	gig_dbg(DEBUG_IF, "not connected"); /* nothing to do */
	474	else if (!cs->open_count)
5002779d	475	dev_warn(cs->dev, "%s: device not opened\n", __func__);
d9ba9c91	476	else
1528b18f	477	gig_dbg(DEBUG_IF, "%s: not implemented\n", __func__);
ee8a4b7f	478
abfd1dc7	479	mutex_unlock(&cs->mutex);
ee8a4b7f HL	480	}
ee8a4b7f HL	481
606d099c	482	static void if_set_termios(struct tty_struct tty, struct ktermios old)
ee8a4b7f HL	483	{
	484	struct cardstate *cs;
	485	unsigned int iflag;
	486	unsigned int cflag;
	487	unsigned int old_cflag;
	488	unsigned int control_state, new_state;
	489
	490	cs = (struct cardstate *) tty->driver_data;
	491	if (!cs) {
c8770dca	492	pr_err("%s: no cardstate\n", __func__);
ee8a4b7f HL	493	return;
	494	}
	495
784d5858	496	gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
ee8a4b7f	497
abfd1dc7	498	mutex_lock(&cs->mutex);
ee8a4b7f	499
51370e5b TS	500	if (!cs->connected) {
51370e5b TS	501	gig_dbg(DEBUG_IF, "not connected");
ee8a4b7f HL	502	goto out;
	503	}
	504
51370e5b TS	505	if (!cs->open_count) {
51370e5b TS	506	dev_warn(cs->dev, "%s: device not opened\n", __func__);
ee8a4b7f HL	507	goto out;
	508	}
	509
ee8a4b7f HL	510	iflag = tty->termios->c_iflag;
ee8a4b7f HL	511	cflag = tty->termios->c_cflag;
d9ba9c91	512	old_cflag = old ? old->c_cflag : cflag;
784d5858 TS	513	gig_dbg(DEBUG_IF, "%u: iflag %x cflag %x old %x",
784d5858 TS	514	cs->minor_index, iflag, cflag, old_cflag);
ee8a4b7f HL	515
	516	/* get a local copy of the current port settings */
	517	control_state = cs->control_state;
	518
	519	/*
	520	* Update baud rate.
	521	* Do not attempt to cache old rates and skip settings,
	522	* disconnects screw such tricks up completely.
	523	* Premature optimization is the root of all evil.
	524	*/
	525
784d5858	526	/* reassert DTR and (maybe) RTS on transition from B0 */
ee8a4b7f HL	527	if ((old_cflag & CBAUD) == B0) {
	528	new_state = control_state \| TIOCM_DTR;
	529	/* don't set RTS if using hardware flow control */
	530	if (!(old_cflag & CRTSCTS))
	531	new_state \|= TIOCM_RTS;
784d5858 TS	532	gig_dbg(DEBUG_IF, "%u: from B0 - set DTR%s",
	533	cs->minor_index,
	534	(new_state & TIOCM_RTS) ? " only" : "/RTS");
ee8a4b7f HL	535	cs->ops->set_modem_ctrl(cs, control_state, new_state);
	536	control_state = new_state;
	537	}
	538
	539	cs->ops->baud_rate(cs, cflag & CBAUD);
	540
	541	if ((cflag & CBAUD) == B0) {
	542	/* Drop RTS and DTR */
784d5858	543	gig_dbg(DEBUG_IF, "%u: to B0 - drop DTR/RTS", cs->minor_index);
ee8a4b7f HL	544	new_state = control_state & ~(TIOCM_DTR \| TIOCM_RTS);
	545	cs->ops->set_modem_ctrl(cs, control_state, new_state);
	546	control_state = new_state;
	547	}
	548
	549	/*
	550	* Update line control register (LCR)
	551	*/
	552
	553	cs->ops->set_line_ctrl(cs, cflag);
	554
ee8a4b7f HL	555	/* save off the modified port settings */
	556	cs->control_state = control_state;
	557
	558	out:
abfd1dc7	559	mutex_unlock(&cs->mutex);
ee8a4b7f HL	560	}
	561
	562
	563	/* wakeup tasklet for the write operation */
	564	static void if_wake(unsigned long data)
	565	{
	566	struct cardstate cs = (struct cardstate ) data;
ee8a4b7f	567
b963a844 JS	568	if (cs->tty)
b963a844 JS	569	tty_wakeup(cs->tty);
ee8a4b7f HL	570	}
	571
	572	/* interface to common */
	573
	574	void gigaset_if_init(struct cardstate *cs)
	575	{
	576	struct gigaset_driver *drv;
	577
	578	drv = cs->driver;
	579	if (!drv->have_tty)
	580	return;
	581
5452fee2	582	tasklet_init(&cs->if_wake_tasklet, if_wake, (unsigned long) cs);
7435f50e TS	583
7435f50e TS	584	mutex_lock(&cs->mutex);
01107d34	585	cs->tty_dev = tty_register_device(drv->tty, cs->minor_index, NULL);
3dda4e37	586
01107d34 GKH	587	if (!IS_ERR(cs->tty_dev))
01107d34 GKH	588	dev_set_drvdata(cs->tty_dev, cs);
3dda4e37	589	else {
42e3d611	590	pr_warning("could not register device to the tty subsystem\n");
01107d34	591	cs->tty_dev = NULL;
3dda4e37	592	}
7435f50e	593	mutex_unlock(&cs->mutex);
ee8a4b7f HL	594	}
	595
	596	void gigaset_if_free(struct cardstate *cs)
	597	{
	598	struct gigaset_driver *drv;
	599
	600	drv = cs->driver;
	601	if (!drv->have_tty)
	602	return;
	603
	604	tasklet_disable(&cs->if_wake_tasklet);
	605	tasklet_kill(&cs->if_wake_tasklet);
01107d34	606	cs->tty_dev = NULL;
ee8a4b7f HL	607	tty_unregister_device(drv->tty, cs->minor_index);
	608	}
	609
1cec9727 TS	610	/**
	611	* gigaset_if_receive() - pass a received block of data to the tty device
	612	* @cs: device descriptor structure.
	613	* @buffer: received data.
	614	* @len: number of bytes received.
	615	*
	616	* Called by asyncdata/isocdata if a block of data received from the
	617	* device must be sent to userspace through the ttyG* device.
	618	*/
ee8a4b7f	619	void gigaset_if_receive(struct cardstate *cs,
784d5858	620	unsigned char *buffer, size_t len)
ee8a4b7f HL	621	{
	622	unsigned long flags;
	623	struct tty_struct *tty;
	624
	625	spin_lock_irqsave(&cs->lock, flags);
d9ba9c91 TS	626	tty = cs->tty;
d9ba9c91 TS	627	if (tty == NULL)
1528b18f	628	gig_dbg(DEBUG_IF, "receive on closed device");
ee8a4b7f	629	else {
ee8a4b7f HL	630	tty_insert_flip_string(tty, buffer, len);
	631	tty_flip_buffer_push(tty);
	632	}
	633	spin_unlock_irqrestore(&cs->lock, flags);
	634	}
	635	EXPORT_SYMBOL_GPL(gigaset_if_receive);
	636
	637	/* gigaset_if_initdriver
	638	* Initialize tty interface.
	639	* parameters:
784d5858 TS	640	* drv Driver
	641	* procname Name of the driver (e.g. for /proc/tty/drivers)
	642	* devname Name of the device files (prefix without minor number)
ee8a4b7f HL	643	*/
ee8a4b7f HL	644	void gigaset_if_initdriver(struct gigaset_driver drv, const char procname,
f4eaa370	645	const char *devname)
ee8a4b7f HL	646	{
	647	unsigned minors = drv->minors;
	648	int ret;
	649	struct tty_driver *tty;
	650
	651	drv->have_tty = 0;
	652
d9ba9c91 TS	653	drv->tty = tty = alloc_tty_driver(minors);
d9ba9c91 TS	654	if (tty == NULL)
ee8a4b7f	655	goto enomem;
ee8a4b7f HL	656
	657	tty->magic = TTY_DRIVER_MAGIC,
	658	tty->major = GIG_MAJOR,
	659	tty->type = TTY_DRIVER_TYPE_SERIAL,
	660	tty->subtype = SERIAL_TYPE_NORMAL,
331b8319	661	tty->flags = TTY_DRIVER_REAL_RAW \| TTY_DRIVER_DYNAMIC_DEV;
ee8a4b7f HL	662
	663	tty->driver_name = procname;
	664	tty->name = devname;
	665	tty->minor_start = drv->minor;
	666	tty->num = drv->minors;
	667
	668	tty->owner = THIS_MODULE;
ee8a4b7f	669
d9ba9c91 TS	670	tty->init_termios = tty_std_termios;
d9ba9c91 TS	671	tty->init_termios.c_cflag = B9600 \| CS8 \| CREAD \| HUPCL \| CLOCAL;
ee8a4b7f HL	672	tty_set_operations(tty, &if_ops);
	673
	674	ret = tty_register_driver(tty);
	675	if (ret < 0) {
c8770dca	676	pr_err("error %d registering tty driver\n", ret);
ee8a4b7f HL	677	goto error;
ee8a4b7f HL	678	}
784d5858	679	gig_dbg(DEBUG_IF, "tty driver initialized");
ee8a4b7f HL	680	drv->have_tty = 1;
	681	return;
	682
	683	enomem:
c8770dca	684	pr_err("out of memory\n");
ee8a4b7f HL	685	error:
	686	if (drv->tty)
	687	put_tty_driver(drv->tty);
	688	}
	689
	690	void gigaset_if_freedriver(struct gigaset_driver *drv)
	691	{
	692	if (!drv->have_tty)
	693	return;
	694
	695	drv->have_tty = 0;
	696	tty_unregister_driver(drv->tty);
	697	put_tty_driver(drv->tty);
	698	}