[deliverable/linux.git] / net / irda / ircomm / ircomm_param.c

/*********************************************************************
 *
 * Filename:      ircomm_param.c
 * Version:       1.0
 * Description:   Parameter handling for the IrCOMM protocol
 * Status:        Experimental.
 * Author:        Dag Brattli <dagb@cs.uit.no>
 * Created at:    Mon Jun  7 10:25:11 1999
 * Modified at:   Sun Jan 30 14:32:03 2000
 * Modified by:   Dag Brattli <dagb@cs.uit.no>
 *
 *     Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
 *
 *     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.
 *
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *     GNU General Public License for more details.
 *
 *     You should have received a copy of the GNU General Public License
 *     along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 ********************************************************************/

#include <linux/gfp.h>
#include <linux/workqueue.h>
#include <linux/interrupt.h>

#include <net/irda/irda.h>
#include <net/irda/parameters.h>

#include <net/irda/ircomm_core.h>
#include <net/irda/ircomm_tty_attach.h>
#include <net/irda/ircomm_tty.h>

#include <net/irda/ircomm_param.h>

static int ircomm_param_service_type(void *instance, irda_param_t *param,
				     int get);
static int ircomm_param_port_type(void *instance, irda_param_t *param,
				  int get);
static int ircomm_param_port_name(void *instance, irda_param_t *param,
				  int get);
static int ircomm_param_service_type(void *instance, irda_param_t *param,
				     int get);
static int ircomm_param_data_rate(void *instance, irda_param_t *param,
				  int get);
static int ircomm_param_data_format(void *instance, irda_param_t *param,
				    int get);
static int ircomm_param_flow_control(void *instance, irda_param_t *param,
				     int get);
static int ircomm_param_xon_xoff(void *instance, irda_param_t *param, int get);
static int ircomm_param_enq_ack(void *instance, irda_param_t *param, int get);
static int ircomm_param_line_status(void *instance, irda_param_t *param,
				    int get);
static int ircomm_param_dte(void *instance, irda_param_t *param, int get);
static int ircomm_param_dce(void *instance, irda_param_t *param, int get);
static int ircomm_param_poll(void *instance, irda_param_t *param, int get);

static pi_minor_info_t pi_minor_call_table_common[] = {
	{ ircomm_param_service_type, PV_INT_8_BITS },
	{ ircomm_param_port_type,    PV_INT_8_BITS },
	{ ircomm_param_port_name,    PV_STRING }
};
static pi_minor_info_t pi_minor_call_table_non_raw[] = {
	{ ircomm_param_data_rate,    PV_INT_32_BITS | PV_BIG_ENDIAN },
	{ ircomm_param_data_format,  PV_INT_8_BITS },
	{ ircomm_param_flow_control, PV_INT_8_BITS },
	{ ircomm_param_xon_xoff,     PV_INT_16_BITS },
	{ ircomm_param_enq_ack,      PV_INT_16_BITS },
	{ ircomm_param_line_status,  PV_INT_8_BITS }
};
static pi_minor_info_t pi_minor_call_table_9_wire[] = {
	{ ircomm_param_dte,          PV_INT_8_BITS },
	{ ircomm_param_dce,          PV_INT_8_BITS },
	{ ircomm_param_poll,         PV_NO_VALUE },
};

static pi_major_info_t pi_major_call_table[] = {
	{ pi_minor_call_table_common,  3 },
	{ pi_minor_call_table_non_raw, 6 },
	{ pi_minor_call_table_9_wire,  3 }
/* 	{ pi_minor_call_table_centronics }  */
};

pi_param_info_t ircomm_param_info = { pi_major_call_table, 3, 0x0f, 4 };

/*
 * Function ircomm_param_request (self, pi, flush)
 *
 *    Queue a parameter for the control channel
 *
 */
int ircomm_param_request(struct ircomm_tty_cb *self, __u8 pi, int flush)
{
	unsigned long flags;
	struct sk_buff *skb;
	int count;

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);

	/* Make sure we don't send parameters for raw mode */
	if (self->service_type == IRCOMM_3_WIRE_RAW)
		return 0;

	spin_lock_irqsave(&self->spinlock, flags);

	skb = self->ctrl_skb;
	if (!skb) {
		skb = alloc_skb(256, GFP_ATOMIC);
		if (!skb) {
			spin_unlock_irqrestore(&self->spinlock, flags);
			return -ENOMEM;
		}

		skb_reserve(skb, self->max_header_size);
		self->ctrl_skb = skb;
	}
	/*
	 * Inserting is a little bit tricky since we don't know how much
	 * room we will need. But this should hopefully work OK
	 */
	count = irda_param_insert(self, pi, skb_tail_pointer(skb),
				  skb_tailroom(skb), &ircomm_param_info);
	if (count < 0) {
		net_warn_ratelimited("%s(), no room for parameter!\n",
				     __func__);
		spin_unlock_irqrestore(&self->spinlock, flags);
		return -1;
	}
	skb_put(skb, count);

	spin_unlock_irqrestore(&self->spinlock, flags);

	pr_debug("%s(), skb->len=%d\n", __func__ , skb->len);

	if (flush) {
		/* ircomm_tty_do_softint will take care of the rest */
		schedule_work(&self->tqueue);
	}

	return count;
}

/*
 * Function ircomm_param_service_type (self, buf, len)
 *
 *    Handle service type, this function will both be called after the LM-IAS
 *    query and then the remote device sends its initial parameters
 *
 */
static int ircomm_param_service_type(void *instance, irda_param_t *param,
				     int get)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
	__u8 service_type = (__u8) param->pv.i;

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);

	if (get) {
		param->pv.i = self->settings.service_type;
		return 0;
	}

	/* Find all common service types */
	service_type &= self->service_type;
	if (!service_type) {
		pr_debug("%s(), No common service type to use!\n", __func__);
		return -1;
	}
	pr_debug("%s(), services in common=%02x\n", __func__ ,
		 service_type);

	/*
	 * Now choose a preferred service type of those available
	 */
	if (service_type & IRCOMM_CENTRONICS)
		self->settings.service_type = IRCOMM_CENTRONICS;
	else if (service_type & IRCOMM_9_WIRE)
		self->settings.service_type = IRCOMM_9_WIRE;
	else if (service_type & IRCOMM_3_WIRE)
		self->settings.service_type = IRCOMM_3_WIRE;
	else if (service_type & IRCOMM_3_WIRE_RAW)
		self->settings.service_type = IRCOMM_3_WIRE_RAW;

	pr_debug("%s(), resulting service type=0x%02x\n", __func__ ,
		 self->settings.service_type);

	/*
	 * Now the line is ready for some communication. Check if we are a
	 * server, and send over some initial parameters.
	 * Client do it in ircomm_tty_state_setup().
	 * Note : we may get called from ircomm_tty_getvalue_confirm(),
	 * therefore before we even have open any socket. And self->client
	 * is initialised to TRUE only later. So, we check if the link is
	 * really initialised. - Jean II
	 */
	if ((self->max_header_size != IRCOMM_TTY_HDR_UNINITIALISED) &&
	    (!self->client) &&
	    (self->settings.service_type != IRCOMM_3_WIRE_RAW))
	{
		/* Init connection */
		ircomm_tty_send_initial_parameters(self);
		ircomm_tty_link_established(self);
	}

	return 0;
}

/*
 * Function ircomm_param_port_type (self, param)
 *
 *    The port type parameter tells if the devices are serial or parallel.
 *    Since we only advertise serial service, this parameter should only
 *    be equal to IRCOMM_SERIAL.
 */
static int ircomm_param_port_type(void *instance, irda_param_t *param, int get)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);

	if (get)
		param->pv.i = IRCOMM_SERIAL;
	else {
		self->settings.port_type = (__u8) param->pv.i;

		pr_debug("%s(), port type=%d\n", __func__ ,
			 self->settings.port_type);
	}
	return 0;
}

/*
 * Function ircomm_param_port_name (self, param)
 *
 *    Exchange port name
 *
 */
static int ircomm_param_port_name(void *instance, irda_param_t *param, int get)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);

	if (get) {
		pr_debug("%s(), not imp!\n", __func__);
	} else {
		pr_debug("%s(), port-name=%s\n", __func__ , param->pv.c);
		strncpy(self->settings.port_name, param->pv.c, 32);
	}

	return 0;
}

/*
 * Function ircomm_param_data_rate (self, param)
 *
 *    Exchange data rate to be used in this settings
 *
 */
static int ircomm_param_data_rate(void *instance, irda_param_t *param, int get)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);

	if (get)
		param->pv.i = self->settings.data_rate;
	else
		self->settings.data_rate = param->pv.i;

	pr_debug("%s(), data rate = %d\n", __func__ , param->pv.i);

	return 0;
}

/*
 * Function ircomm_param_data_format (self, param)
 *
 *    Exchange data format to be used in this settings
 *
 */
static int ircomm_param_data_format(void *instance, irda_param_t *param,
				    int get)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);

	if (get)
		param->pv.i = self->settings.data_format;
	else
		self->settings.data_format = (__u8) param->pv.i;

	return 0;
}

/*
 * Function ircomm_param_flow_control (self, param)
 *
 *    Exchange flow control settings to be used in this settings
 *
 */
static int ircomm_param_flow_control(void *instance, irda_param_t *param,
				     int get)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);

	if (get)
		param->pv.i = self->settings.flow_control;
	else
		self->settings.flow_control = (__u8) param->pv.i;

	pr_debug("%s(), flow control = 0x%02x\n", __func__ , (__u8)param->pv.i);

	return 0;
}

/*
 * Function ircomm_param_xon_xoff (self, param)
 *
 *    Exchange XON/XOFF characters
 *
 */
static int ircomm_param_xon_xoff(void *instance, irda_param_t *param, int get)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);

	if (get) {
		param->pv.i = self->settings.xonxoff[0];
		param->pv.i |= self->settings.xonxoff[1] << 8;
	} else {
		self->settings.xonxoff[0] = (__u16) param->pv.i & 0xff;
		self->settings.xonxoff[1] = (__u16) param->pv.i >> 8;
	}

	pr_debug("%s(), XON/XOFF = 0x%02x,0x%02x\n", __func__ ,
		 param->pv.i & 0xff, param->pv.i >> 8);

	return 0;
}

/*
 * Function ircomm_param_enq_ack (self, param)
 *
 *    Exchange ENQ/ACK characters
 *
 */
static int ircomm_param_enq_ack(void *instance, irda_param_t *param, int get)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);

	if (get) {
		param->pv.i = self->settings.enqack[0];
		param->pv.i |= self->settings.enqack[1] << 8;
	} else {
		self->settings.enqack[0] = (__u16) param->pv.i & 0xff;
		self->settings.enqack[1] = (__u16) param->pv.i >> 8;
	}

	pr_debug("%s(), ENQ/ACK = 0x%02x,0x%02x\n", __func__ ,
		 param->pv.i & 0xff, param->pv.i >> 8);

	return 0;
}

/*
 * Function ircomm_param_line_status (self, param)
 *
 *
 *
 */
static int ircomm_param_line_status(void *instance, irda_param_t *param,
				    int get)
{
	pr_debug("%s(), not impl.\n", __func__);

	return 0;
}

/*
 * Function ircomm_param_dte (instance, param)
 *
 *    If we get here, there must be some sort of null-modem connection, and
 *    we are probably working in server mode as well.
 */
static int ircomm_param_dte(void *instance, irda_param_t *param, int get)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
	__u8 dte;

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);

	if (get)
		param->pv.i = self->settings.dte;
	else {
		dte = (__u8) param->pv.i;

		self->settings.dce = 0;

		if (dte & IRCOMM_DELTA_DTR)
			self->settings.dce |= (IRCOMM_DELTA_DSR|
					      IRCOMM_DELTA_RI |
					      IRCOMM_DELTA_CD);
		if (dte & IRCOMM_DTR)
			self->settings.dce |= (IRCOMM_DSR|
					      IRCOMM_RI |
					      IRCOMM_CD);

		if (dte & IRCOMM_DELTA_RTS)
			self->settings.dce |= IRCOMM_DELTA_CTS;
		if (dte & IRCOMM_RTS)
			self->settings.dce |= IRCOMM_CTS;

		/* Take appropriate actions */
		ircomm_tty_check_modem_status(self);

		/* Null modem cable emulator */
		self->settings.null_modem = TRUE;
	}

	return 0;
}

/*
 * Function ircomm_param_dce (instance, param)
 *
 *
 *
 */
static int ircomm_param_dce(void *instance, irda_param_t *param, int get)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
	__u8 dce;

	pr_debug("%s(), dce = 0x%02x\n", __func__ , (__u8)param->pv.i);

	dce = (__u8) param->pv.i;

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);

	self->settings.dce = dce;

	/* Check if any of the settings have changed */
	if (dce & 0x0f) {
		if (dce & IRCOMM_DELTA_CTS) {
			pr_debug("%s(), CTS\n", __func__);
		}
	}

	ircomm_tty_check_modem_status(self);

	return 0;
}

/*
 * Function ircomm_param_poll (instance, param)
 *
 *    Called when the peer device is polling for the line settings
 *
 */
static int ircomm_param_poll(void *instance, irda_param_t *param, int get)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);

	/* Poll parameters are always of length 0 (just a signal) */
	if (!get) {
		/* Respond with DTE line settings */
		ircomm_param_request(self, IRCOMM_DTE, TRUE);
	}
	return 0;
}
Commit	Line	Data
1da177e4	1	/*********************************************************************
6819bc2e	2	*
1da177e4 LT	3	* Filename: ircomm_param.c
	4	* Version: 1.0
	5	* Description: Parameter handling for the IrCOMM protocol
	6	* Status: Experimental.
	7	* Author: Dag Brattli <dagb@cs.uit.no>
	8	* Created at: Mon Jun 7 10:25:11 1999
	9	* Modified at: Sun Jan 30 14:32:03 2000
	10	* Modified by: Dag Brattli <dagb@cs.uit.no>
6819bc2e	11	*
1da177e4	12	* Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
6819bc2e YH	13	*
	14	* This program is free software; you can redistribute it and/or
	15	* modify it under the terms of the GNU General Public License as
	16	* published by the Free Software Foundation; either version 2 of
1da177e4	17	* the License, or (at your option) any later version.
6819bc2e	18	*
1da177e4 LT	19	* This program is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	* GNU General Public License for more details.
6819bc2e YH	23	*
6819bc2e YH	24	* You should have received a copy of the GNU General Public License
d3770509	25	* along with this program; if not, see <http://www.gnu.org/licenses/>.
6819bc2e	26	*
1da177e4 LT	27	********************************************************************/
1da177e4 LT	28
5a0e3ad6	29	#include <linux/gfp.h>
1da177e4 LT	30	#include <linux/workqueue.h>
	31	#include <linux/interrupt.h>
	32
	33	#include <net/irda/irda.h>
	34	#include <net/irda/parameters.h>
	35
	36	#include <net/irda/ircomm_core.h>
	37	#include <net/irda/ircomm_tty_attach.h>
	38	#include <net/irda/ircomm_tty.h>
	39
	40	#include <net/irda/ircomm_param.h>
	41
6819bc2e	42	static int ircomm_param_service_type(void instance, irda_param_t param,
1da177e4	43	int get);
6819bc2e	44	static int ircomm_param_port_type(void instance, irda_param_t param,
1da177e4	45	int get);
6819bc2e	46	static int ircomm_param_port_name(void instance, irda_param_t param,
1da177e4	47	int get);
6819bc2e	48	static int ircomm_param_service_type(void instance, irda_param_t param,
1da177e4	49	int get);
6819bc2e	50	static int ircomm_param_data_rate(void instance, irda_param_t param,
1da177e4	51	int get);
6819bc2e	52	static int ircomm_param_data_format(void instance, irda_param_t param,
1da177e4	53	int get);
6819bc2e	54	static int ircomm_param_flow_control(void instance, irda_param_t param,
1da177e4 LT	55	int get);
	56	static int ircomm_param_xon_xoff(void instance, irda_param_t param, int get);
	57	static int ircomm_param_enq_ack(void instance, irda_param_t param, int get);
6819bc2e	58	static int ircomm_param_line_status(void instance, irda_param_t param,
1da177e4 LT	59	int get);
	60	static int ircomm_param_dte(void instance, irda_param_t param, int get);
	61	static int ircomm_param_dce(void instance, irda_param_t param, int get);
	62	static int ircomm_param_poll(void instance, irda_param_t param, int get);
	63
	64	static pi_minor_info_t pi_minor_call_table_common[] = {
	65	{ ircomm_param_service_type, PV_INT_8_BITS },
	66	{ ircomm_param_port_type, PV_INT_8_BITS },
	67	{ ircomm_param_port_name, PV_STRING }
	68	};
	69	static pi_minor_info_t pi_minor_call_table_non_raw[] = {
	70	{ ircomm_param_data_rate, PV_INT_32_BITS \| PV_BIG_ENDIAN },
	71	{ ircomm_param_data_format, PV_INT_8_BITS },
	72	{ ircomm_param_flow_control, PV_INT_8_BITS },
	73	{ ircomm_param_xon_xoff, PV_INT_16_BITS },
	74	{ ircomm_param_enq_ack, PV_INT_16_BITS },
	75	{ ircomm_param_line_status, PV_INT_8_BITS }
	76	};
	77	static pi_minor_info_t pi_minor_call_table_9_wire[] = {
	78	{ ircomm_param_dte, PV_INT_8_BITS },
	79	{ ircomm_param_dce, PV_INT_8_BITS },
	80	{ ircomm_param_poll, PV_NO_VALUE },
	81	};
	82
	83	static pi_major_info_t pi_major_call_table[] = {
	84	{ pi_minor_call_table_common, 3 },
	85	{ pi_minor_call_table_non_raw, 6 },
6819bc2e	86	{ pi_minor_call_table_9_wire, 3 }
1da177e4 LT	87	/* { pi_minor_call_table_centronics } */
	88	};
	89
	90	pi_param_info_t ircomm_param_info = { pi_major_call_table, 3, 0x0f, 4 };
	91
	92	/*
	93	* Function ircomm_param_request (self, pi, flush)
	94	*
	95	* Queue a parameter for the control channel
	96	*
	97	*/
	98	int ircomm_param_request(struct ircomm_tty_cb *self, __u8 pi, int flush)
	99	{
1da177e4 LT	100	unsigned long flags;
	101	struct sk_buff *skb;
	102	int count;
	103
1da177e4 LT	104	IRDA_ASSERT(self != NULL, return -1;);
	105	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
	106
1da177e4 LT	107	/* Make sure we don't send parameters for raw mode */
	108	if (self->service_type == IRCOMM_3_WIRE_RAW)
	109	return 0;
	110
	111	spin_lock_irqsave(&self->spinlock, flags);
	112
6819bc2e	113	skb = self->ctrl_skb;
1da177e4	114	if (!skb) {
485fb2c9	115	skb = alloc_skb(256, GFP_ATOMIC);
1da177e4 LT	116	if (!skb) {
	117	spin_unlock_irqrestore(&self->spinlock, flags);
	118	return -ENOMEM;
	119	}
6819bc2e	120
1da177e4 LT	121	skb_reserve(skb, self->max_header_size);
	122	self->ctrl_skb = skb;
	123	}
6819bc2e	124	/*
1da177e4	125	* Inserting is a little bit tricky since we don't know how much
6819bc2e	126	* room we will need. But this should hopefully work OK
1da177e4	127	*/
27a884dc ACM	128	count = irda_param_insert(self, pi, skb_tail_pointer(skb),
27a884dc ACM	129	skb_tailroom(skb), &ircomm_param_info);
1da177e4	130	if (count < 0) {
6c91023d JP	131	net_warn_ratelimited("%s(), no room for parameter!\n",
6c91023d JP	132	__func__);
1da177e4 LT	133	spin_unlock_irqrestore(&self->spinlock, flags);
	134	return -1;
	135	}
	136	skb_put(skb, count);
	137
	138	spin_unlock_irqrestore(&self->spinlock, flags);
	139
955a9d20	140	pr_debug("%s(), skb->len=%d\n", __func__ , skb->len);
1da177e4 LT	141
	142	if (flush) {
	143	/* ircomm_tty_do_softint will take care of the rest */
	144	schedule_work(&self->tqueue);
	145	}
	146
	147	return count;
	148	}
	149
	150	/*
	151	* Function ircomm_param_service_type (self, buf, len)
	152	*
	153	* Handle service type, this function will both be called after the LM-IAS
	154	* query and then the remote device sends its initial parameters
	155	*
	156	*/
6819bc2e	157	static int ircomm_param_service_type(void instance, irda_param_t param,
1da177e4 LT	158	int get)
	159	{
	160	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) instance;
	161	__u8 service_type = (__u8) param->pv.i;
	162
	163	IRDA_ASSERT(self != NULL, return -1;);
	164	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
	165
	166	if (get) {
	167	param->pv.i = self->settings.service_type;
	168	return 0;
	169	}
	170
	171	/* Find all common service types */
	172	service_type &= self->service_type;
	173	if (!service_type) {
955a9d20	174	pr_debug("%s(), No common service type to use!\n", __func__);
1da177e4 LT	175	return -1;
1da177e4 LT	176	}
955a9d20 JP	177	pr_debug("%s(), services in common=%02x\n", __func__ ,
955a9d20 JP	178	service_type);
1da177e4 LT	179
	180	/*
	181	* Now choose a preferred service type of those available
	182	*/
	183	if (service_type & IRCOMM_CENTRONICS)
	184	self->settings.service_type = IRCOMM_CENTRONICS;
	185	else if (service_type & IRCOMM_9_WIRE)
	186	self->settings.service_type = IRCOMM_9_WIRE;
	187	else if (service_type & IRCOMM_3_WIRE)
	188	self->settings.service_type = IRCOMM_3_WIRE;
	189	else if (service_type & IRCOMM_3_WIRE_RAW)
	190	self->settings.service_type = IRCOMM_3_WIRE_RAW;
	191
955a9d20 JP	192	pr_debug("%s(), resulting service type=0x%02x\n", __func__ ,
955a9d20 JP	193	self->settings.service_type);
1da177e4	194
6819bc2e	195	/*
1da177e4	196	* Now the line is ready for some communication. Check if we are a
6819bc2e	197	* server, and send over some initial parameters.
1da177e4 LT	198	* Client do it in ircomm_tty_state_setup().
	199	* Note : we may get called from ircomm_tty_getvalue_confirm(),
	200	* therefore before we even have open any socket. And self->client
	201	* is initialised to TRUE only later. So, we check if the link is
	202	* really initialised. - Jean II
	203	*/
	204	if ((self->max_header_size != IRCOMM_TTY_HDR_UNINITIALISED) &&
	205	(!self->client) &&
	206	(self->settings.service_type != IRCOMM_3_WIRE_RAW))
	207	{
	208	/* Init connection */
	209	ircomm_tty_send_initial_parameters(self);
	210	ircomm_tty_link_established(self);
	211	}
	212
	213	return 0;
	214	}
	215
	216	/*
	217	* Function ircomm_param_port_type (self, param)
	218	*
	219	* The port type parameter tells if the devices are serial or parallel.
	220	* Since we only advertise serial service, this parameter should only
	221	* be equal to IRCOMM_SERIAL.
	222	*/
	223	static int ircomm_param_port_type(void instance, irda_param_t param, int get)
	224	{
	225	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) instance;
	226
	227	IRDA_ASSERT(self != NULL, return -1;);
	228	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
6819bc2e	229
1da177e4 LT	230	if (get)
	231	param->pv.i = IRCOMM_SERIAL;
	232	else {
	233	self->settings.port_type = (__u8) param->pv.i;
	234
955a9d20 JP	235	pr_debug("%s(), port type=%d\n", __func__ ,
955a9d20 JP	236	self->settings.port_type);
1da177e4 LT	237	}
	238	return 0;
	239	}
	240
	241	/*
	242	* Function ircomm_param_port_name (self, param)
	243	*
	244	* Exchange port name
	245	*
	246	*/
	247	static int ircomm_param_port_name(void instance, irda_param_t param, int get)
	248	{
	249	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) instance;
6819bc2e	250
1da177e4 LT	251	IRDA_ASSERT(self != NULL, return -1;);
	252	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
	253
	254	if (get) {
955a9d20	255	pr_debug("%s(), not imp!\n", __func__);
1da177e4	256	} else {
955a9d20	257	pr_debug("%s(), port-name=%s\n", __func__ , param->pv.c);
1da177e4 LT	258	strncpy(self->settings.port_name, param->pv.c, 32);
	259	}
	260
	261	return 0;
	262	}
	263
	264	/*
	265	* Function ircomm_param_data_rate (self, param)
	266	*
	267	* Exchange data rate to be used in this settings
	268	*
	269	*/
	270	static int ircomm_param_data_rate(void instance, irda_param_t param, int get)
	271	{
	272	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) instance;
6819bc2e	273
1da177e4 LT	274	IRDA_ASSERT(self != NULL, return -1;);
	275	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
	276
	277	if (get)
	278	param->pv.i = self->settings.data_rate;
	279	else
	280	self->settings.data_rate = param->pv.i;
6819bc2e	281
955a9d20	282	pr_debug("%s(), data rate = %d\n", __func__ , param->pv.i);
1da177e4 LT	283
	284	return 0;
	285	}
	286
	287	/*
	288	* Function ircomm_param_data_format (self, param)
	289	*
	290	* Exchange data format to be used in this settings
	291	*
	292	*/
6819bc2e	293	static int ircomm_param_data_format(void instance, irda_param_t param,
1da177e4 LT	294	int get)
	295	{
	296	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) instance;
	297
	298	IRDA_ASSERT(self != NULL, return -1;);
	299	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
	300
	301	if (get)
	302	param->pv.i = self->settings.data_format;
	303	else
	304	self->settings.data_format = (__u8) param->pv.i;
6819bc2e	305
1da177e4 LT	306	return 0;
	307	}
	308
	309	/*
	310	* Function ircomm_param_flow_control (self, param)
	311	*
	312	* Exchange flow control settings to be used in this settings
	313	*
	314	*/
6819bc2e	315	static int ircomm_param_flow_control(void instance, irda_param_t param,
1da177e4 LT	316	int get)
	317	{
	318	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) instance;
	319
	320	IRDA_ASSERT(self != NULL, return -1;);
	321	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
6819bc2e	322
1da177e4 LT	323	if (get)
	324	param->pv.i = self->settings.flow_control;
	325	else
	326	self->settings.flow_control = (__u8) param->pv.i;
	327
955a9d20	328	pr_debug("%s(), flow control = 0x%02x\n", __func__ , (__u8)param->pv.i);
1da177e4 LT	329
	330	return 0;
	331	}
	332
	333	/*
	334	* Function ircomm_param_xon_xoff (self, param)
	335	*
	336	* Exchange XON/XOFF characters
	337	*
	338	*/
	339	static int ircomm_param_xon_xoff(void instance, irda_param_t param, int get)
	340	{
	341	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) instance;
	342
	343	IRDA_ASSERT(self != NULL, return -1;);
	344	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
6819bc2e	345
1da177e4 LT	346	if (get) {
	347	param->pv.i = self->settings.xonxoff[0];
	348	param->pv.i \|= self->settings.xonxoff[1] << 8;
	349	} else {
	350	self->settings.xonxoff[0] = (__u16) param->pv.i & 0xff;
	351	self->settings.xonxoff[1] = (__u16) param->pv.i >> 8;
	352	}
	353
955a9d20 JP	354	pr_debug("%s(), XON/XOFF = 0x%02x,0x%02x\n", __func__ ,
955a9d20 JP	355	param->pv.i & 0xff, param->pv.i >> 8);
1da177e4 LT	356
	357	return 0;
	358	}
	359
	360	/*
	361	* Function ircomm_param_enq_ack (self, param)
	362	*
	363	* Exchange ENQ/ACK characters
	364	*
	365	*/
	366	static int ircomm_param_enq_ack(void instance, irda_param_t param, int get)
	367	{
	368	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) instance;
	369
	370	IRDA_ASSERT(self != NULL, return -1;);
	371	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
6819bc2e	372
1da177e4 LT	373	if (get) {
	374	param->pv.i = self->settings.enqack[0];
	375	param->pv.i \|= self->settings.enqack[1] << 8;
	376	} else {
	377	self->settings.enqack[0] = (__u16) param->pv.i & 0xff;
	378	self->settings.enqack[1] = (__u16) param->pv.i >> 8;
	379	}
	380
955a9d20 JP	381	pr_debug("%s(), ENQ/ACK = 0x%02x,0x%02x\n", __func__ ,
955a9d20 JP	382	param->pv.i & 0xff, param->pv.i >> 8);
1da177e4 LT	383
	384	return 0;
	385	}
	386
	387	/*
	388	* Function ircomm_param_line_status (self, param)
	389	*
6819bc2e	390	*
1da177e4 LT	391	*
1da177e4 LT	392	*/
6819bc2e	393	static int ircomm_param_line_status(void instance, irda_param_t param,
1da177e4 LT	394	int get)
1da177e4 LT	395	{
955a9d20	396	pr_debug("%s(), not impl.\n", __func__);
1da177e4 LT	397
	398	return 0;
	399	}
	400
	401	/*
	402	* Function ircomm_param_dte (instance, param)
	403	*
	404	* If we get here, there must be some sort of null-modem connection, and
	405	* we are probably working in server mode as well.
	406	*/
	407	static int ircomm_param_dte(void instance, irda_param_t param, int get)
	408	{
	409	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) instance;
	410	__u8 dte;
	411
	412	IRDA_ASSERT(self != NULL, return -1;);
	413	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
	414
	415	if (get)
	416	param->pv.i = self->settings.dte;
	417	else {
	418	dte = (__u8) param->pv.i;
	419
	420	self->settings.dce = 0;
6819bc2e	421
1da177e4 LT	422	if (dte & IRCOMM_DELTA_DTR)
	423	self->settings.dce \|= (IRCOMM_DELTA_DSR\|
	424	IRCOMM_DELTA_RI \|
	425	IRCOMM_DELTA_CD);
	426	if (dte & IRCOMM_DTR)
	427	self->settings.dce \|= (IRCOMM_DSR\|
	428	IRCOMM_RI \|
	429	IRCOMM_CD);
6819bc2e	430
1da177e4 LT	431	if (dte & IRCOMM_DELTA_RTS)
	432	self->settings.dce \|= IRCOMM_DELTA_CTS;
	433	if (dte & IRCOMM_RTS)
	434	self->settings.dce \|= IRCOMM_CTS;
	435
	436	/* Take appropriate actions */
	437	ircomm_tty_check_modem_status(self);
	438
	439	/* Null modem cable emulator */
	440	self->settings.null_modem = TRUE;
	441	}
	442
	443	return 0;
	444	}
	445
	446	/*
	447	* Function ircomm_param_dce (instance, param)
	448	*
6819bc2e	449	*
1da177e4 LT	450	*
	451	*/
	452	static int ircomm_param_dce(void instance, irda_param_t param, int get)
	453	{
	454	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) instance;
	455	__u8 dce;
	456
955a9d20	457	pr_debug("%s(), dce = 0x%02x\n", __func__ , (__u8)param->pv.i);
1da177e4 LT	458
	459	dce = (__u8) param->pv.i;
	460
	461	IRDA_ASSERT(self != NULL, return -1;);
	462	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
	463
	464	self->settings.dce = dce;
	465
	466	/* Check if any of the settings have changed */
	467	if (dce & 0x0f) {
	468	if (dce & IRCOMM_DELTA_CTS) {
955a9d20	469	pr_debug("%s(), CTS\n", __func__);
1da177e4 LT	470	}
	471	}
	472
	473	ircomm_tty_check_modem_status(self);
	474
	475	return 0;
	476	}
	477
	478	/*
	479	* Function ircomm_param_poll (instance, param)
	480	*
	481	* Called when the peer device is polling for the line settings
	482	*
	483	*/
	484	static int ircomm_param_poll(void instance, irda_param_t param, int get)
	485	{
	486	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) instance;
	487
	488	IRDA_ASSERT(self != NULL, return -1;);
	489	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
	490
cc53ded2	491	/* Poll parameters are always of length 0 (just a signal) */
1da177e4 LT	492	if (!get) {
	493	/* Respond with DTE line settings */
	494	ircomm_param_request(self, IRCOMM_DTE, TRUE);
	495	}
	496	return 0;
	497	}
	498
	499
	500
	501
	502