[mirror_ubuntu-kernels.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.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;
	}

	gig_dbg(DEBUG_CMD, "scheduling IF_LOCK");
	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;
		}

		gig_dbg(DEBUG_CMD, "scheduling IF_VER");
		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; // FIXME -EINTR?
	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; //FIXME test
	}

	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; // FIXME -EINTR?

	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_ANY, "%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; // FIXME -EINTR?

	// FIXME read from device?
	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; // FIXME -EINTR?

	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; // FIXME -EINTR?

	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; // FIXME -EINTR?

	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 = -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; // FIXME -EINTR?

	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->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 {
		//FIXME
	}

	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 {
		//FIXME
	}

	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;
	}

	// stolen from mct_u232.c
	iflag = tty->termios->c_iflag;
	cflag = tty->termios->c_cflag;
	old_cflag = old ? old->c_cflag : cflag; //FIXME?
	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 {
		dev_warn(cs->dev,
			 "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);
}

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);
	if ((tty = cs->tty) == NULL)
		gig_dbg(DEBUG_ANY, "receive on closed device");
	else {
		tty_buffer_request_room(tty, len);
		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;

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

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