[deliverable/linux.git] / net / bluetooth / cmtp / capi.c

/*
   CMTP implementation for Linux Bluetooth stack (BlueZ).
   Copyright (C) 2002-2003 Marcel Holtmann <marcel@holtmann.org>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
   SOFTWARE IS DISCLAIMED.
*/

#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/fcntl.h>
#include <linux/skbuff.h>
#include <linux/socket.h>
#include <linux/ioctl.h>
#include <linux/file.h>
#include <linux/wait.h>
#include <net/sock.h>

#include <linux/isdn/capilli.h>
#include <linux/isdn/capicmd.h>
#include <linux/isdn/capiutil.h>

#include "cmtp.h"

#define CAPI_INTEROPERABILITY		0x20

#define CAPI_INTEROPERABILITY_REQ	CAPICMD(CAPI_INTEROPERABILITY, CAPI_REQ)
#define CAPI_INTEROPERABILITY_CONF	CAPICMD(CAPI_INTEROPERABILITY, CAPI_CONF)
#define CAPI_INTEROPERABILITY_IND	CAPICMD(CAPI_INTEROPERABILITY, CAPI_IND)
#define CAPI_INTEROPERABILITY_RESP	CAPICMD(CAPI_INTEROPERABILITY, CAPI_RESP)

#define CAPI_INTEROPERABILITY_REQ_LEN	(CAPI_MSG_BASELEN + 2)
#define CAPI_INTEROPERABILITY_CONF_LEN	(CAPI_MSG_BASELEN + 4)
#define CAPI_INTEROPERABILITY_IND_LEN	(CAPI_MSG_BASELEN + 2)
#define CAPI_INTEROPERABILITY_RESP_LEN	(CAPI_MSG_BASELEN + 2)

#define CAPI_FUNCTION_REGISTER		0
#define CAPI_FUNCTION_RELEASE		1
#define CAPI_FUNCTION_GET_PROFILE	2
#define CAPI_FUNCTION_GET_MANUFACTURER	3
#define CAPI_FUNCTION_GET_VERSION	4
#define CAPI_FUNCTION_GET_SERIAL_NUMBER	5
#define CAPI_FUNCTION_MANUFACTURER	6
#define CAPI_FUNCTION_LOOPBACK		7


#define CMTP_MSGNUM	1
#define CMTP_APPLID	2
#define CMTP_MAPPING	3

static struct cmtp_application *cmtp_application_add(struct cmtp_session *session, __u16 appl)
{
	struct cmtp_application *app = kzalloc(sizeof(*app), GFP_KERNEL);

	BT_DBG("session %p application %p appl %d", session, app, appl);

	if (!app)
		return NULL;

	app->state = BT_OPEN;
	app->appl = appl;

	list_add_tail(&app->list, &session->applications);

	return app;
}

static void cmtp_application_del(struct cmtp_session *session, struct cmtp_application *app)
{
	BT_DBG("session %p application %p", session, app);

	if (app) {
		list_del(&app->list);
		kfree(app);
	}
}

static struct cmtp_application *cmtp_application_get(struct cmtp_session *session, int pattern, __u16 value)
{
	struct cmtp_application *app;
	struct list_head *p, *n;

	list_for_each_safe(p, n, &session->applications) {
		app = list_entry(p, struct cmtp_application, list);
		switch (pattern) {
		case CMTP_MSGNUM:
			if (app->msgnum == value)
				return app;
			break;
		case CMTP_APPLID:
			if (app->appl == value)
				return app;
			break;
		case CMTP_MAPPING:
			if (app->mapping == value)
				return app;
			break;
		}
	}

	return NULL;
}

static int cmtp_msgnum_get(struct cmtp_session *session)
{
	session->msgnum++;

	if ((session->msgnum & 0xff) > 200)
		session->msgnum = CMTP_INITIAL_MSGNUM + 1;

	return session->msgnum;
}

static void cmtp_send_capimsg(struct cmtp_session *session, struct sk_buff *skb)
{
	struct cmtp_scb *scb = (void *) skb->cb;

	BT_DBG("session %p skb %p len %d", session, skb, skb->len);

	scb->id = -1;
	scb->data = (CAPIMSG_COMMAND(skb->data) == CAPI_DATA_B3);

	skb_queue_tail(&session->transmit, skb);

	cmtp_schedule(session);
}

static void cmtp_send_interopmsg(struct cmtp_session *session,
					__u8 subcmd, __u16 appl, __u16 msgnum,
					__u16 function, unsigned char *buf, int len)
{
	struct sk_buff *skb;
	unsigned char *s;

	BT_DBG("session %p subcmd 0x%02x appl %d msgnum %d", session, subcmd, appl, msgnum);

	if (!(skb = alloc_skb(CAPI_MSG_BASELEN + 6 + len, GFP_ATOMIC))) {
		BT_ERR("Can't allocate memory for interoperability packet");
		return;
	}

	s = skb_put(skb, CAPI_MSG_BASELEN + 6 + len);

	capimsg_setu16(s, 0, CAPI_MSG_BASELEN + 6 + len);
	capimsg_setu16(s, 2, appl);
	capimsg_setu8 (s, 4, CAPI_INTEROPERABILITY);
	capimsg_setu8 (s, 5, subcmd);
	capimsg_setu16(s, 6, msgnum);

	/* Interoperability selector (Bluetooth Device Management) */
	capimsg_setu16(s, 8, 0x0001);

	capimsg_setu8 (s, 10, 3 + len);
	capimsg_setu16(s, 11, function);
	capimsg_setu8 (s, 13, len);

	if (len > 0)
		memcpy(s + 14, buf, len);

	cmtp_send_capimsg(session, skb);
}

static void cmtp_recv_interopmsg(struct cmtp_session *session, struct sk_buff *skb)
{
	struct capi_ctr *ctrl = &session->ctrl;
	struct cmtp_application *application;
	__u16 appl, msgnum, func, info;
	__u32 controller;

	BT_DBG("session %p skb %p len %d", session, skb, skb->len);

	switch (CAPIMSG_SUBCOMMAND(skb->data)) {
	case CAPI_CONF:
		if (skb->len < CAPI_MSG_BASELEN + 10)
			break;

		func = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 5);
		info = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 8);

		switch (func) {
		case CAPI_FUNCTION_REGISTER:
			msgnum = CAPIMSG_MSGID(skb->data);

			application = cmtp_application_get(session, CMTP_MSGNUM, msgnum);
			if (application) {
				application->state = BT_CONNECTED;
				application->msgnum = 0;
				application->mapping = CAPIMSG_APPID(skb->data);
				wake_up_interruptible(&session->wait);
			}

			break;

		case CAPI_FUNCTION_RELEASE:
			appl = CAPIMSG_APPID(skb->data);

			application = cmtp_application_get(session, CMTP_MAPPING, appl);
			if (application) {
				application->state = BT_CLOSED;
				application->msgnum = 0;
				wake_up_interruptible(&session->wait);
			}

			break;

		case CAPI_FUNCTION_GET_PROFILE:
			if (skb->len < CAPI_MSG_BASELEN + 11 + sizeof(capi_profile))
				break;

			controller = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 11);
			msgnum = CAPIMSG_MSGID(skb->data);

			if (!info && (msgnum == CMTP_INITIAL_MSGNUM)) {
				session->ncontroller = controller;
				wake_up_interruptible(&session->wait);
				break;
			}

			if (!info && ctrl) {
				memcpy(&ctrl->profile,
					skb->data + CAPI_MSG_BASELEN + 11,
					sizeof(capi_profile));
				session->state = BT_CONNECTED;
				capi_ctr_ready(ctrl);
			}

			break;

		case CAPI_FUNCTION_GET_MANUFACTURER:
			if (skb->len < CAPI_MSG_BASELEN + 15)
				break;

			controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 10);

			if (!info && ctrl) {
				int len = min_t(uint, CAPI_MANUFACTURER_LEN,
						skb->data[CAPI_MSG_BASELEN + 14]);

				memset(ctrl->manu, 0, CAPI_MANUFACTURER_LEN);
				strncpy(ctrl->manu,
					skb->data + CAPI_MSG_BASELEN + 15, len);
			}

			break;

		case CAPI_FUNCTION_GET_VERSION:
			if (skb->len < CAPI_MSG_BASELEN + 32)
				break;

			controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 12);

			if (!info && ctrl) {
				ctrl->version.majorversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 16);
				ctrl->version.minorversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 20);
				ctrl->version.majormanuversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 24);
				ctrl->version.minormanuversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 28);
			}

			break;

		case CAPI_FUNCTION_GET_SERIAL_NUMBER:
			if (skb->len < CAPI_MSG_BASELEN + 17)
				break;

			controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 12);

			if (!info && ctrl) {
				int len = min_t(uint, CAPI_SERIAL_LEN,
						skb->data[CAPI_MSG_BASELEN + 16]);

				memset(ctrl->serial, 0, CAPI_SERIAL_LEN);
				strncpy(ctrl->serial,
					skb->data + CAPI_MSG_BASELEN + 17, len);
			}

			break;
		}

		break;

	case CAPI_IND:
		if (skb->len < CAPI_MSG_BASELEN + 6)
			break;

		func = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 3);

		if (func == CAPI_FUNCTION_LOOPBACK) {
			int len = min_t(uint, skb->len - CAPI_MSG_BASELEN - 6,
						skb->data[CAPI_MSG_BASELEN + 5]);
			appl = CAPIMSG_APPID(skb->data);
			msgnum = CAPIMSG_MSGID(skb->data);
			cmtp_send_interopmsg(session, CAPI_RESP, appl, msgnum, func,
						skb->data + CAPI_MSG_BASELEN + 6, len);
		}

		break;
	}

	kfree_skb(skb);
}

void cmtp_recv_capimsg(struct cmtp_session *session, struct sk_buff *skb)
{
	struct capi_ctr *ctrl = &session->ctrl;
	struct cmtp_application *application;
	__u16 cmd, appl;
	__u32 contr;

	BT_DBG("session %p skb %p len %d", session, skb, skb->len);

	if (skb->len < CAPI_MSG_BASELEN)
		return;

	if (CAPIMSG_COMMAND(skb->data) == CAPI_INTEROPERABILITY) {
		cmtp_recv_interopmsg(session, skb);
		return;
	}

	if (session->flags & (1 << CMTP_LOOPBACK)) {
		kfree_skb(skb);
		return;
	}

	cmd = CAPICMD(CAPIMSG_COMMAND(skb->data), CAPIMSG_SUBCOMMAND(skb->data));
	appl = CAPIMSG_APPID(skb->data);
	contr = CAPIMSG_CONTROL(skb->data);

	application = cmtp_application_get(session, CMTP_MAPPING, appl);
	if (application) {
		appl = application->appl;
		CAPIMSG_SETAPPID(skb->data, appl);
	} else {
		BT_ERR("Can't find application with id %d", appl);
		kfree_skb(skb);
		return;
	}

	if ((contr & 0x7f) == 0x01) {
		contr = (contr & 0xffffff80) | session->num;
		CAPIMSG_SETCONTROL(skb->data, contr);
	}

	if (!ctrl) {
		BT_ERR("Can't find controller %d for message", session->num);
		kfree_skb(skb);
		return;
	}

	capi_ctr_handle_message(ctrl, appl, skb);
}

static int cmtp_load_firmware(struct capi_ctr *ctrl, capiloaddata *data)
{
	BT_DBG("ctrl %p data %p", ctrl, data);

	return 0;
}

static void cmtp_reset_ctr(struct capi_ctr *ctrl)
{
	struct cmtp_session *session = ctrl->driverdata;

	BT_DBG("ctrl %p", ctrl);

	capi_ctr_down(ctrl);

	atomic_inc(&session->terminate);
	cmtp_schedule(session);
}

static void cmtp_register_appl(struct capi_ctr *ctrl, __u16 appl, capi_register_params *rp)
{
	DECLARE_WAITQUEUE(wait, current);
	struct cmtp_session *session = ctrl->driverdata;
	struct cmtp_application *application;
	unsigned long timeo = CMTP_INTEROP_TIMEOUT;
	unsigned char buf[8];
	int err = 0, nconn, want = rp->level3cnt;

	BT_DBG("ctrl %p appl %d level3cnt %d datablkcnt %d datablklen %d",
		ctrl, appl, rp->level3cnt, rp->datablkcnt, rp->datablklen);

	application = cmtp_application_add(session, appl);
	if (!application) {
		BT_ERR("Can't allocate memory for new application");
		return;
	}

	if (want < 0)
		nconn = ctrl->profile.nbchannel * -want;
	else
		nconn = want;

	if (nconn == 0)
		nconn = ctrl->profile.nbchannel;

	capimsg_setu16(buf, 0, nconn);
	capimsg_setu16(buf, 2, rp->datablkcnt);
	capimsg_setu16(buf, 4, rp->datablklen);

	application->state = BT_CONFIG;
	application->msgnum = cmtp_msgnum_get(session);

	cmtp_send_interopmsg(session, CAPI_REQ, 0x0000, application->msgnum,
				CAPI_FUNCTION_REGISTER, buf, 6);

	add_wait_queue(&session->wait, &wait);
	while (1) {
		set_current_state(TASK_INTERRUPTIBLE);

		if (!timeo) {
			err = -EAGAIN;
			break;
		}

		if (application->state == BT_CLOSED) {
			err = -application->err;
			break;
		}

		if (application->state == BT_CONNECTED)
			break;

		if (signal_pending(current)) {
			err = -EINTR;
			break;
		}

		timeo = schedule_timeout(timeo);
	}
	set_current_state(TASK_RUNNING);
	remove_wait_queue(&session->wait, &wait);

	if (err) {
		cmtp_application_del(session, application);
		return;
	}
}

static void cmtp_release_appl(struct capi_ctr *ctrl, __u16 appl)
{
	struct cmtp_session *session = ctrl->driverdata;
	struct cmtp_application *application;

	BT_DBG("ctrl %p appl %d", ctrl, appl);

	application = cmtp_application_get(session, CMTP_APPLID, appl);
	if (!application) {
		BT_ERR("Can't find application");
		return;
	}

	application->msgnum = cmtp_msgnum_get(session);

	cmtp_send_interopmsg(session, CAPI_REQ, application->mapping, application->msgnum,
				CAPI_FUNCTION_RELEASE, NULL, 0);

	wait_event_interruptible_timeout(session->wait,
			(application->state == BT_CLOSED), CMTP_INTEROP_TIMEOUT);

	cmtp_application_del(session, application);
}

static u16 cmtp_send_message(struct capi_ctr *ctrl, struct sk_buff *skb)
{
	struct cmtp_session *session = ctrl->driverdata;
	struct cmtp_application *application;
	__u16 appl;
	__u32 contr;

	BT_DBG("ctrl %p skb %p", ctrl, skb);

	appl = CAPIMSG_APPID(skb->data);
	contr = CAPIMSG_CONTROL(skb->data);

	application = cmtp_application_get(session, CMTP_APPLID, appl);
	if ((!application) || (application->state != BT_CONNECTED)) {
		BT_ERR("Can't find application with id %d", appl);
		return CAPI_ILLAPPNR;
	}

	CAPIMSG_SETAPPID(skb->data, application->mapping);

	if ((contr & 0x7f) == session->num) {
		contr = (contr & 0xffffff80) | 0x01;
		CAPIMSG_SETCONTROL(skb->data, contr);
	}

	cmtp_send_capimsg(session, skb);

	return CAPI_NOERROR;
}

static char *cmtp_procinfo(struct capi_ctr *ctrl)
{
	return "CAPI Message Transport Protocol";
}

static int cmtp_proc_show(struct seq_file *m, void *v)
{
	struct capi_ctr *ctrl = m->private;
	struct cmtp_session *session = ctrl->driverdata;
	struct cmtp_application *app;
	struct list_head *p, *n;

	seq_printf(m, "%s\n\n", cmtp_procinfo(ctrl));
	seq_printf(m, "addr %s\n", session->name);
	seq_printf(m, "ctrl %d\n", session->num);

	list_for_each_safe(p, n, &session->applications) {
		app = list_entry(p, struct cmtp_application, list);
		seq_printf(m, "appl %d -> %d\n", app->appl, app->mapping);
	}

	return 0;
}

static int cmtp_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, cmtp_proc_show, PDE(inode)->data);
}

static const struct file_operations cmtp_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= cmtp_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

int cmtp_attach_device(struct cmtp_session *session)
{
	unsigned char buf[4];
	long ret;

	BT_DBG("session %p", session);

	capimsg_setu32(buf, 0, 0);

	cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, CMTP_INITIAL_MSGNUM,
				CAPI_FUNCTION_GET_PROFILE, buf, 4);

	ret = wait_event_interruptible_timeout(session->wait,
			session->ncontroller, CMTP_INTEROP_TIMEOUT);

	BT_INFO("Found %d CAPI controller(s) on device %s", session->ncontroller, session->name);

	if (!ret)
		return -ETIMEDOUT;

	if (!session->ncontroller)
		return -ENODEV;

	if (session->ncontroller > 1)
		BT_INFO("Setting up only CAPI controller 1");

	session->ctrl.owner      = THIS_MODULE;
	session->ctrl.driverdata = session;
	strcpy(session->ctrl.name, session->name);

	session->ctrl.driver_name   = "cmtp";
	session->ctrl.load_firmware = cmtp_load_firmware;
	session->ctrl.reset_ctr     = cmtp_reset_ctr;
	session->ctrl.register_appl = cmtp_register_appl;
	session->ctrl.release_appl  = cmtp_release_appl;
	session->ctrl.send_message  = cmtp_send_message;

	session->ctrl.procinfo      = cmtp_procinfo;
	session->ctrl.proc_fops = &cmtp_proc_fops;

	if (attach_capi_ctr(&session->ctrl) < 0) {
		BT_ERR("Can't attach new controller");
		return -EBUSY;
	}

	session->num = session->ctrl.cnr;

	BT_DBG("session %p num %d", session, session->num);

	capimsg_setu32(buf, 0, 1);

	cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
				CAPI_FUNCTION_GET_MANUFACTURER, buf, 4);

	cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
				CAPI_FUNCTION_GET_VERSION, buf, 4);

	cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
				CAPI_FUNCTION_GET_SERIAL_NUMBER, buf, 4);

	cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
				CAPI_FUNCTION_GET_PROFILE, buf, 4);

	return 0;
}

void cmtp_detach_device(struct cmtp_session *session)
{
	BT_DBG("session %p", session);

	detach_capi_ctr(&session->ctrl);
}
Commit	Line	Data
8e87d142	1	/*
1da177e4 LT	2	CMTP implementation for Linux Bluetooth stack (BlueZ).
	3	Copyright (C) 2002-2003 Marcel Holtmann <marcel@holtmann.org>
	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License version 2 as
	7	published by the Free Software Foundation;
	8
	9	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	10	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	11	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
	12	IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
8e87d142 YH	13	CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
	14	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	15	ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1da177e4 LT	16	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1da177e4 LT	17
8e87d142 YH	18	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
8e87d142 YH	19	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4 LT	20	SOFTWARE IS DISCLAIMED.
	21	*/
	22
1da177e4	23	#include <linux/module.h>
9a58a80a AD	24	#include <linux/proc_fs.h>
9a58a80a AD	25	#include <linux/seq_file.h>
1da177e4 LT	26	#include <linux/types.h>
	27	#include <linux/errno.h>
	28	#include <linux/kernel.h>
1da177e4 LT	29	#include <linux/sched.h>
	30	#include <linux/slab.h>
	31	#include <linux/poll.h>
	32	#include <linux/fcntl.h>
	33	#include <linux/skbuff.h>
	34	#include <linux/socket.h>
	35	#include <linux/ioctl.h>
	36	#include <linux/file.h>
	37	#include <linux/wait.h>
	38	#include <net/sock.h>
	39
	40	#include <linux/isdn/capilli.h>
	41	#include <linux/isdn/capicmd.h>
	42	#include <linux/isdn/capiutil.h>
	43
	44	#include "cmtp.h"
	45
1da177e4 LT	46	#define CAPI_INTEROPERABILITY 0x20
	47
	48	#define CAPI_INTEROPERABILITY_REQ CAPICMD(CAPI_INTEROPERABILITY, CAPI_REQ)
	49	#define CAPI_INTEROPERABILITY_CONF CAPICMD(CAPI_INTEROPERABILITY, CAPI_CONF)
	50	#define CAPI_INTEROPERABILITY_IND CAPICMD(CAPI_INTEROPERABILITY, CAPI_IND)
	51	#define CAPI_INTEROPERABILITY_RESP CAPICMD(CAPI_INTEROPERABILITY, CAPI_RESP)
	52
	53	#define CAPI_INTEROPERABILITY_REQ_LEN (CAPI_MSG_BASELEN + 2)
	54	#define CAPI_INTEROPERABILITY_CONF_LEN (CAPI_MSG_BASELEN + 4)
	55	#define CAPI_INTEROPERABILITY_IND_LEN (CAPI_MSG_BASELEN + 2)
	56	#define CAPI_INTEROPERABILITY_RESP_LEN (CAPI_MSG_BASELEN + 2)
	57
	58	#define CAPI_FUNCTION_REGISTER 0
	59	#define CAPI_FUNCTION_RELEASE 1
	60	#define CAPI_FUNCTION_GET_PROFILE 2
	61	#define CAPI_FUNCTION_GET_MANUFACTURER 3
	62	#define CAPI_FUNCTION_GET_VERSION 4
	63	#define CAPI_FUNCTION_GET_SERIAL_NUMBER 5
	64	#define CAPI_FUNCTION_MANUFACTURER 6
	65	#define CAPI_FUNCTION_LOOPBACK 7
	66
	67
	68	#define CMTP_MSGNUM 1
	69	#define CMTP_APPLID 2
	70	#define CMTP_MAPPING 3
	71
	72	static struct cmtp_application cmtp_application_add(struct cmtp_session session, __u16 appl)
	73	{
25ea6db0	74	struct cmtp_application app = kzalloc(sizeof(app), GFP_KERNEL);
1da177e4 LT	75
	76	BT_DBG("session %p application %p appl %d", session, app, appl);
	77
	78	if (!app)
	79	return NULL;
	80
1da177e4 LT	81	app->state = BT_OPEN;
	82	app->appl = appl;
	83
	84	list_add_tail(&app->list, &session->applications);
	85
	86	return app;
	87	}
	88
	89	static void cmtp_application_del(struct cmtp_session session, struct cmtp_application app)
	90	{
	91	BT_DBG("session %p application %p", session, app);
	92
	93	if (app) {
	94	list_del(&app->list);
	95	kfree(app);
	96	}
	97	}
	98
	99	static struct cmtp_application cmtp_application_get(struct cmtp_session session, int pattern, __u16 value)
	100	{
	101	struct cmtp_application *app;
	102	struct list_head p, n;
	103
	104	list_for_each_safe(p, n, &session->applications) {
	105	app = list_entry(p, struct cmtp_application, list);
	106	switch (pattern) {
	107	case CMTP_MSGNUM:
	108	if (app->msgnum == value)
	109	return app;
	110	break;
	111	case CMTP_APPLID:
	112	if (app->appl == value)
	113	return app;
	114	break;
	115	case CMTP_MAPPING:
	116	if (app->mapping == value)
	117	return app;
	118	break;
	119	}
	120	}
	121
	122	return NULL;
	123	}
	124
	125	static int cmtp_msgnum_get(struct cmtp_session *session)
	126	{
	127	session->msgnum++;
	128
	129	if ((session->msgnum & 0xff) > 200)
	130	session->msgnum = CMTP_INITIAL_MSGNUM + 1;
	131
	132	return session->msgnum;
	133	}
	134
	135	static void cmtp_send_capimsg(struct cmtp_session session, struct sk_buff skb)
	136	{
	137	struct cmtp_scb scb = (void ) skb->cb;
	138
	139	BT_DBG("session %p skb %p len %d", session, skb, skb->len);
	140
	141	scb->id = -1;
	142	scb->data = (CAPIMSG_COMMAND(skb->data) == CAPI_DATA_B3);
	143
	144	skb_queue_tail(&session->transmit, skb);
145
146	cmtp_schedule(session);
147	}
148
149	static void cmtp_send_interopmsg(struct cmtp_session *session,
150	__u8 subcmd, __u16 appl, __u16 msgnum,
151	__u16 function, unsigned char *buf, int len)
152	{
153	struct sk_buff *skb;
154	unsigned char *s;
155
156	BT_DBG("session %p subcmd 0x%02x appl %d msgnum %d", session, subcmd, appl, msgnum);
157
158	if (!(skb = alloc_skb(CAPI_MSG_BASELEN + 6 + len, GFP_ATOMIC))) {
159	BT_ERR("Can't allocate memory for interoperability packet");
160	return;
161	}
162
163	s = skb_put(skb, CAPI_MSG_BASELEN + 6 + len);
164
165	capimsg_setu16(s, 0, CAPI_MSG_BASELEN + 6 + len);
166	capimsg_setu16(s, 2, appl);
167	capimsg_setu8 (s, 4, CAPI_INTEROPERABILITY);
168	capimsg_setu8 (s, 5, subcmd);
169	capimsg_setu16(s, 6, msgnum);
170
171	/* Interoperability selector (Bluetooth Device Management) */
172	capimsg_setu16(s, 8, 0x0001);
173
174	capimsg_setu8 (s, 10, 3 + len);
175	capimsg_setu16(s, 11, function);
176	capimsg_setu8 (s, 13, len);
177
178	if (len > 0)
179	memcpy(s + 14, buf, len);
180
181	cmtp_send_capimsg(session, skb);
182	}
183
184	static void cmtp_recv_interopmsg(struct cmtp_session session, struct sk_buff skb)
185	{
186	struct capi_ctr *ctrl = &session->ctrl;
187	struct cmtp_application *application;
188	__u16 appl, msgnum, func, info;
189	__u32 controller;
190
191	BT_DBG("session %p skb %p len %d", session, skb, skb->len);
192
193	switch (CAPIMSG_SUBCOMMAND(skb->data)) {
194	case CAPI_CONF:
f4777569 MH	195	if (skb->len < CAPI_MSG_BASELEN + 10)
	196	break;
	197
1da177e4 LT	198	func = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 5);
	199	info = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 8);
	200
	201	switch (func) {
	202	case CAPI_FUNCTION_REGISTER:
	203	msgnum = CAPIMSG_MSGID(skb->data);
	204
	205	application = cmtp_application_get(session, CMTP_MSGNUM, msgnum);
	206	if (application) {
	207	application->state = BT_CONNECTED;
	208	application->msgnum = 0;
	209	application->mapping = CAPIMSG_APPID(skb->data);
	210	wake_up_interruptible(&session->wait);
	211	}
	212
	213	break;
	214
	215	case CAPI_FUNCTION_RELEASE:
	216	appl = CAPIMSG_APPID(skb->data);
	217
	218	application = cmtp_application_get(session, CMTP_MAPPING, appl);
	219	if (application) {
	220	application->state = BT_CLOSED;
	221	application->msgnum = 0;
	222	wake_up_interruptible(&session->wait);
	223	}
	224
	225	break;
	226
	227	case CAPI_FUNCTION_GET_PROFILE:
f4777569 MH	228	if (skb->len < CAPI_MSG_BASELEN + 11 + sizeof(capi_profile))
	229	break;
	230
1da177e4 LT	231	controller = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 11);
	232	msgnum = CAPIMSG_MSGID(skb->data);
	233
	234	if (!info && (msgnum == CMTP_INITIAL_MSGNUM)) {
	235	session->ncontroller = controller;
	236	wake_up_interruptible(&session->wait);
	237	break;
	238	}
	239
	240	if (!info && ctrl) {
	241	memcpy(&ctrl->profile,
	242	skb->data + CAPI_MSG_BASELEN + 11,
	243	sizeof(capi_profile));
	244	session->state = BT_CONNECTED;
	245	capi_ctr_ready(ctrl);
	246	}
	247
	248	break;
	249
	250	case CAPI_FUNCTION_GET_MANUFACTURER:
f4777569 MH	251	if (skb->len < CAPI_MSG_BASELEN + 15)
	252	break;
	253
1da177e4 LT	254	controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 10);
	255
	256	if (!info && ctrl) {
f4777569 MH	257	int len = min_t(uint, CAPI_MANUFACTURER_LEN,
	258	skb->data[CAPI_MSG_BASELEN + 14]);
	259
	260	memset(ctrl->manu, 0, CAPI_MANUFACTURER_LEN);
1da177e4	261	strncpy(ctrl->manu,
f4777569	262	skb->data + CAPI_MSG_BASELEN + 15, len);
1da177e4 LT	263	}
	264
	265	break;
	266
	267	case CAPI_FUNCTION_GET_VERSION:
f4777569 MH	268	if (skb->len < CAPI_MSG_BASELEN + 32)
	269	break;
	270
1da177e4 LT	271	controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 12);
	272
	273	if (!info && ctrl) {
	274	ctrl->version.majorversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 16);
	275	ctrl->version.minorversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 20);
	276	ctrl->version.majormanuversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 24);
	277	ctrl->version.minormanuversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 28);
	278	}
	279
	280	break;
	281
	282	case CAPI_FUNCTION_GET_SERIAL_NUMBER:
f4777569 MH	283	if (skb->len < CAPI_MSG_BASELEN + 17)
	284	break;
	285
1da177e4 LT	286	controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 12);
	287
	288	if (!info && ctrl) {
f4777569 MH	289	int len = min_t(uint, CAPI_SERIAL_LEN,
	290	skb->data[CAPI_MSG_BASELEN + 16]);
	291
1da177e4 LT	292	memset(ctrl->serial, 0, CAPI_SERIAL_LEN);
1da177e4 LT	293	strncpy(ctrl->serial,
f4777569	294	skb->data + CAPI_MSG_BASELEN + 17, len);
1da177e4 LT	295	}
	296
	297	break;
	298	}
	299
	300	break;
	301
	302	case CAPI_IND:
f4777569 MH	303	if (skb->len < CAPI_MSG_BASELEN + 6)
	304	break;
	305
1da177e4 LT	306	func = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 3);
	307
	308	if (func == CAPI_FUNCTION_LOOPBACK) {
f4777569 MH	309	int len = min_t(uint, skb->len - CAPI_MSG_BASELEN - 6,
f4777569 MH	310	skb->data[CAPI_MSG_BASELEN + 5]);
1da177e4 LT	311	appl = CAPIMSG_APPID(skb->data);
	312	msgnum = CAPIMSG_MSGID(skb->data);
	313	cmtp_send_interopmsg(session, CAPI_RESP, appl, msgnum, func,
f4777569	314	skb->data + CAPI_MSG_BASELEN + 6, len);
1da177e4 LT	315	}
	316
	317	break;
	318	}
	319
	320	kfree_skb(skb);
	321	}
	322
	323	void cmtp_recv_capimsg(struct cmtp_session session, struct sk_buff skb)
	324	{
	325	struct capi_ctr *ctrl = &session->ctrl;
	326	struct cmtp_application *application;
	327	__u16 cmd, appl;
	328	__u32 contr;
	329
	330	BT_DBG("session %p skb %p len %d", session, skb, skb->len);
	331
f4777569 MH	332	if (skb->len < CAPI_MSG_BASELEN)
	333	return;
	334
1da177e4 LT	335	if (CAPIMSG_COMMAND(skb->data) == CAPI_INTEROPERABILITY) {
	336	cmtp_recv_interopmsg(session, skb);
	337	return;
	338	}
	339
	340	if (session->flags & (1 << CMTP_LOOPBACK)) {
	341	kfree_skb(skb);
	342	return;
	343	}
	344
	345	cmd = CAPICMD(CAPIMSG_COMMAND(skb->data), CAPIMSG_SUBCOMMAND(skb->data));
	346	appl = CAPIMSG_APPID(skb->data);
	347	contr = CAPIMSG_CONTROL(skb->data);
	348
	349	application = cmtp_application_get(session, CMTP_MAPPING, appl);
	350	if (application) {
	351	appl = application->appl;
	352	CAPIMSG_SETAPPID(skb->data, appl);
	353	} else {
	354	BT_ERR("Can't find application with id %d", appl);
	355	kfree_skb(skb);
	356	return;
	357	}
	358
	359	if ((contr & 0x7f) == 0x01) {
	360	contr = (contr & 0xffffff80) \| session->num;
	361	CAPIMSG_SETCONTROL(skb->data, contr);
	362	}
	363
	364	if (!ctrl) {
	365	BT_ERR("Can't find controller %d for message", session->num);
	366	kfree_skb(skb);
	367	return;
	368	}
	369
	370	capi_ctr_handle_message(ctrl, appl, skb);
	371	}
	372
	373	static int cmtp_load_firmware(struct capi_ctr ctrl, capiloaddata data)
	374	{
	375	BT_DBG("ctrl %p data %p", ctrl, data);
	376
	377	return 0;
	378	}
	379
	380	static void cmtp_reset_ctr(struct capi_ctr *ctrl)
	381	{
	382	struct cmtp_session *session = ctrl->driverdata;
	383
	384	BT_DBG("ctrl %p", ctrl);
	385
4e329972	386	capi_ctr_down(ctrl);
1da177e4 LT	387
	388	atomic_inc(&session->terminate);
	389	cmtp_schedule(session);
	390	}
	391
	392	static void cmtp_register_appl(struct capi_ctr ctrl, __u16 appl, capi_register_params rp)
	393	{
	394	DECLARE_WAITQUEUE(wait, current);
	395	struct cmtp_session *session = ctrl->driverdata;
	396	struct cmtp_application *application;
	397	unsigned long timeo = CMTP_INTEROP_TIMEOUT;
	398	unsigned char buf[8];
	399	int err = 0, nconn, want = rp->level3cnt;
	400
	401	BT_DBG("ctrl %p appl %d level3cnt %d datablkcnt %d datablklen %d",
	402	ctrl, appl, rp->level3cnt, rp->datablkcnt, rp->datablklen);
	403
	404	application = cmtp_application_add(session, appl);
	405	if (!application) {
	406	BT_ERR("Can't allocate memory for new application");
	407	return;
	408	}
	409
	410	if (want < 0)
	411	nconn = ctrl->profile.nbchannel * -want;
	412	else
	413	nconn = want;
	414
	415	if (nconn == 0)
	416	nconn = ctrl->profile.nbchannel;
	417
	418	capimsg_setu16(buf, 0, nconn);
	419	capimsg_setu16(buf, 2, rp->datablkcnt);
	420	capimsg_setu16(buf, 4, rp->datablklen);
	421
	422	application->state = BT_CONFIG;
	423	application->msgnum = cmtp_msgnum_get(session);
	424
	425	cmtp_send_interopmsg(session, CAPI_REQ, 0x0000, application->msgnum,
	426	CAPI_FUNCTION_REGISTER, buf, 6);
	427
	428	add_wait_queue(&session->wait, &wait);
	429	while (1) {
	430	set_current_state(TASK_INTERRUPTIBLE);
	431
	432	if (!timeo) {
	433	err = -EAGAIN;
	434	break;
	435	}
	436
	437	if (application->state == BT_CLOSED) {
	438	err = -application->err;
	439	break;
	440	}
	441
	442	if (application->state == BT_CONNECTED)
	443	break;
	444
	445	if (signal_pending(current)) {
	446	err = -EINTR;
	447	break;
	448	}
	449
	450	timeo = schedule_timeout(timeo);
451	}
452	set_current_state(TASK_RUNNING);
453	remove_wait_queue(&session->wait, &wait);
454
455	if (err) {
456	cmtp_application_del(session, application);
457	return;
458	}
459	}
460
461	static void cmtp_release_appl(struct capi_ctr *ctrl, __u16 appl)
462	{
463	struct cmtp_session *session = ctrl->driverdata;
464	struct cmtp_application *application;
465
466	BT_DBG("ctrl %p appl %d", ctrl, appl);
467
468	application = cmtp_application_get(session, CMTP_APPLID, appl);
469	if (!application) {
470	BT_ERR("Can't find application");
471	return;
472	}
473
474	application->msgnum = cmtp_msgnum_get(session);
475
476	cmtp_send_interopmsg(session, CAPI_REQ, application->mapping, application->msgnum,
477	CAPI_FUNCTION_RELEASE, NULL, 0);
478
479	wait_event_interruptible_timeout(session->wait,
480	(application->state == BT_CLOSED), CMTP_INTEROP_TIMEOUT);
481
482	cmtp_application_del(session, application);
483	}
484
485	static u16 cmtp_send_message(struct capi_ctr ctrl, struct sk_buff skb)
486	{
487	struct cmtp_session *session = ctrl->driverdata;
488	struct cmtp_application *application;
489	__u16 appl;
490	__u32 contr;
491
492	BT_DBG("ctrl %p skb %p", ctrl, skb);
493
494	appl = CAPIMSG_APPID(skb->data);
495	contr = CAPIMSG_CONTROL(skb->data);
496
497	application = cmtp_application_get(session, CMTP_APPLID, appl);
498	if ((!application) \|\| (application->state != BT_CONNECTED)) {
499	BT_ERR("Can't find application with id %d", appl);
500	return CAPI_ILLAPPNR;
501	}
502
503	CAPIMSG_SETAPPID(skb->data, application->mapping);
504
505	if ((contr & 0x7f) == session->num) {
506	contr = (contr & 0xffffff80) \| 0x01;
507	CAPIMSG_SETCONTROL(skb->data, contr);
508	}
509
510	cmtp_send_capimsg(session, skb);
511
512	return CAPI_NOERROR;
513	}
514
515	static char cmtp_procinfo(struct capi_ctr ctrl)
516	{
517	return "CAPI Message Transport Protocol";
518	}
519
9a58a80a	520	static int cmtp_proc_show(struct seq_file m, void v)
1da177e4	521	{
9a58a80a	522	struct capi_ctr *ctrl = m->private;
1da177e4 LT	523	struct cmtp_session *session = ctrl->driverdata;
	524	struct cmtp_application *app;
	525	struct list_head p, n;
1da177e4	526
9a58a80a AD	527	seq_printf(m, "%s\n\n", cmtp_procinfo(ctrl));
	528	seq_printf(m, "addr %s\n", session->name);
	529	seq_printf(m, "ctrl %d\n", session->num);
1da177e4 LT	530
	531	list_for_each_safe(p, n, &session->applications) {
	532	app = list_entry(p, struct cmtp_application, list);
9a58a80a	533	seq_printf(m, "appl %d -> %d\n", app->appl, app->mapping);
1da177e4 LT	534	}
1da177e4 LT	535
9a58a80a AD	536	return 0;
9a58a80a AD	537	}
1da177e4	538
9a58a80a AD	539	static int cmtp_proc_open(struct inode inode, struct file file)
	540	{
	541	return single_open(file, cmtp_proc_show, PDE(inode)->data);
1da177e4 LT	542	}
1da177e4 LT	543
9a58a80a AD	544	static const struct file_operations cmtp_proc_fops = {
	545	.owner = THIS_MODULE,
	546	.open = cmtp_proc_open,
	547	.read = seq_read,
	548	.llseek = seq_lseek,
	549	.release = single_release,
	550	};
1da177e4 LT	551
	552	int cmtp_attach_device(struct cmtp_session *session)
	553	{
	554	unsigned char buf[4];
	555	long ret;
	556
	557	BT_DBG("session %p", session);
	558
	559	capimsg_setu32(buf, 0, 0);
	560
	561	cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, CMTP_INITIAL_MSGNUM,
	562	CAPI_FUNCTION_GET_PROFILE, buf, 4);
	563
	564	ret = wait_event_interruptible_timeout(session->wait,
	565	session->ncontroller, CMTP_INTEROP_TIMEOUT);
8e87d142	566
1da177e4 LT	567	BT_INFO("Found %d CAPI controller(s) on device %s", session->ncontroller, session->name);
	568
	569	if (!ret)
	570	return -ETIMEDOUT;
	571
	572	if (!session->ncontroller)
	573	return -ENODEV;
	574
	575	if (session->ncontroller > 1)
	576	BT_INFO("Setting up only CAPI controller 1");
	577
	578	session->ctrl.owner = THIS_MODULE;
	579	session->ctrl.driverdata = session;
	580	strcpy(session->ctrl.name, session->name);
	581
	582	session->ctrl.driver_name = "cmtp";
	583	session->ctrl.load_firmware = cmtp_load_firmware;
	584	session->ctrl.reset_ctr = cmtp_reset_ctr;
	585	session->ctrl.register_appl = cmtp_register_appl;
	586	session->ctrl.release_appl = cmtp_release_appl;
	587	session->ctrl.send_message = cmtp_send_message;
	588
	589	session->ctrl.procinfo = cmtp_procinfo;
9a58a80a	590	session->ctrl.proc_fops = &cmtp_proc_fops;
1da177e4 LT	591
	592	if (attach_capi_ctr(&session->ctrl) < 0) {
	593	BT_ERR("Can't attach new controller");
	594	return -EBUSY;
	595	}
	596
	597	session->num = session->ctrl.cnr;
	598
	599	BT_DBG("session %p num %d", session, session->num);
	600
	601	capimsg_setu32(buf, 0, 1);
	602
	603	cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
	604	CAPI_FUNCTION_GET_MANUFACTURER, buf, 4);
	605
	606	cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
	607	CAPI_FUNCTION_GET_VERSION, buf, 4);
	608
	609	cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
	610	CAPI_FUNCTION_GET_SERIAL_NUMBER, buf, 4);
	611
	612	cmtp_send_interopmsg(session, CAPI_REQ, 0xffff, cmtp_msgnum_get(session),
	613	CAPI_FUNCTION_GET_PROFILE, buf, 4);
	614
	615	return 0;
	616	}
	617
	618	void cmtp_detach_device(struct cmtp_session *session)
	619	{
	620	BT_DBG("session %p", session);
	621
	622	detach_capi_ctr(&session->ctrl);
	623	}