[mirror_ubuntu-zesty-kernel.git] / drivers / bluetooth / hci_h4.c

/* 
   BlueZ - Bluetooth protocol stack for Linux
   Copyright (C) 2000-2001 Qualcomm Incorporated

   Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>

   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.
*/

/*
 * Bluetooth HCI UART(H4) protocol.
 *
 * $Id: hci_h4.c,v 1.3 2002/09/09 01:17:32 maxk Exp $    
 */
#define VERSION "1.2"

#include <linux/config.h>
#include <linux/module.h>

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/interrupt.h>
#include <linux/ptrace.h>
#include <linux/poll.h>

#include <linux/slab.h>
#include <linux/tty.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/signal.h>
#include <linux/ioctl.h>
#include <linux/skbuff.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>
#include "hci_uart.h"
#include "hci_h4.h"

#ifndef CONFIG_BT_HCIUART_DEBUG
#undef  BT_DBG
#define BT_DBG( A... )
#endif

/* Initialize protocol */
static int h4_open(struct hci_uart *hu)
{
	struct h4_struct *h4;
	
	BT_DBG("hu %p", hu);
	
	h4 = kmalloc(sizeof(*h4), GFP_ATOMIC);
	if (!h4)
		return -ENOMEM;
	memset(h4, 0, sizeof(*h4));

	skb_queue_head_init(&h4->txq);

	hu->priv = h4;
	return 0;
}

/* Flush protocol data */
static int h4_flush(struct hci_uart *hu)
{
	struct h4_struct *h4 = hu->priv;

	BT_DBG("hu %p", hu);
	skb_queue_purge(&h4->txq);
	return 0;
}

/* Close protocol */
static int h4_close(struct hci_uart *hu)
{
	struct h4_struct *h4 = hu->priv;
	hu->priv = NULL;

	BT_DBG("hu %p", hu);

	skb_queue_purge(&h4->txq);
	if (h4->rx_skb)
		kfree_skb(h4->rx_skb);

	hu->priv = NULL;
	kfree(h4);
	return 0;
}

/* Enqueue frame for transmittion (padding, crc, etc) */
static int h4_enqueue(struct hci_uart *hu, struct sk_buff *skb)
{
	struct h4_struct *h4 = hu->priv;

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

	/* Prepend skb with frame type */
	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
	skb_queue_tail(&h4->txq, skb);
	return 0;
}

static inline int h4_check_data_len(struct h4_struct *h4, int len)
{
	register int room = skb_tailroom(h4->rx_skb);

	BT_DBG("len %d room %d", len, room);
	if (!len) {
		hci_recv_frame(h4->rx_skb);
	} else if (len > room) {
		BT_ERR("Data length is too large");
		kfree_skb(h4->rx_skb);
	} else {
		h4->rx_state = H4_W4_DATA;
		h4->rx_count = len;
		return len;
	}

	h4->rx_state = H4_W4_PACKET_TYPE;
	h4->rx_skb   = NULL;
	h4->rx_count = 0;
	return 0;
}

/* Recv data */
static int h4_recv(struct hci_uart *hu, void *data, int count)
{
	struct h4_struct *h4 = hu->priv;
	register char *ptr;
	struct hci_event_hdr *eh;
	struct hci_acl_hdr   *ah;
	struct hci_sco_hdr   *sh;
	register int len, type, dlen;

	BT_DBG("hu %p count %d rx_state %ld rx_count %ld", 
			hu, count, h4->rx_state, h4->rx_count);

	ptr = data;
	while (count) {
		if (h4->rx_count) {
			len = min_t(unsigned int, h4->rx_count, count);
			memcpy(skb_put(h4->rx_skb, len), ptr, len);
			h4->rx_count -= len; count -= len; ptr += len;

			if (h4->rx_count)
				continue;

			switch (h4->rx_state) {
			case H4_W4_DATA:
				BT_DBG("Complete data");

				hci_recv_frame(h4->rx_skb);

				h4->rx_state = H4_W4_PACKET_TYPE;
				h4->rx_skb = NULL;
				continue;

			case H4_W4_EVENT_HDR:
				eh = (struct hci_event_hdr *) h4->rx_skb->data;

				BT_DBG("Event header: evt 0x%2.2x plen %d", eh->evt, eh->plen);

				h4_check_data_len(h4, eh->plen);
				continue;

			case H4_W4_ACL_HDR:
				ah = (struct hci_acl_hdr *) h4->rx_skb->data;
				dlen = __le16_to_cpu(ah->dlen);

				BT_DBG("ACL header: dlen %d", dlen);

				h4_check_data_len(h4, dlen);
				continue;

			case H4_W4_SCO_HDR:
				sh = (struct hci_sco_hdr *) h4->rx_skb->data;

				BT_DBG("SCO header: dlen %d", sh->dlen);

				h4_check_data_len(h4, sh->dlen);
				continue;
			}
		}

		/* H4_W4_PACKET_TYPE */
		switch (*ptr) {
		case HCI_EVENT_PKT:
			BT_DBG("Event packet");
			h4->rx_state = H4_W4_EVENT_HDR;
			h4->rx_count = HCI_EVENT_HDR_SIZE;
			type = HCI_EVENT_PKT;
			break;

		case HCI_ACLDATA_PKT:
			BT_DBG("ACL packet");
			h4->rx_state = H4_W4_ACL_HDR;
			h4->rx_count = HCI_ACL_HDR_SIZE;
			type = HCI_ACLDATA_PKT;
			break;

		case HCI_SCODATA_PKT:
			BT_DBG("SCO packet");
			h4->rx_state = H4_W4_SCO_HDR;
			h4->rx_count = HCI_SCO_HDR_SIZE;
			type = HCI_SCODATA_PKT;
			break;

		default:
			BT_ERR("Unknown HCI packet type %2.2x", (__u8)*ptr);
			hu->hdev->stat.err_rx++;
			ptr++; count--;
			continue;
		};
		ptr++; count--;

		/* Allocate packet */
		h4->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
		if (!h4->rx_skb) {
			BT_ERR("Can't allocate mem for new packet");
			h4->rx_state = H4_W4_PACKET_TYPE;
			h4->rx_count = 0;
			return 0;
		}
		h4->rx_skb->dev = (void *) hu->hdev;
		bt_cb(h4->rx_skb)->pkt_type = type;
	}
	return count;
}

static struct sk_buff *h4_dequeue(struct hci_uart *hu)
{
	struct h4_struct *h4 = hu->priv;
	return skb_dequeue(&h4->txq);
}

static struct hci_uart_proto h4p = {
	.id      = HCI_UART_H4,
	.open    = h4_open,
	.close   = h4_close,
	.recv    = h4_recv,
	.enqueue = h4_enqueue,
	.dequeue = h4_dequeue,
	.flush   = h4_flush,
};
	      
int h4_init(void)
{
	int err = hci_uart_register_proto(&h4p);
	if (!err)
		BT_INFO("HCI H4 protocol initialized");
	else
		BT_ERR("HCI H4 protocol registration failed");
	
	return err;
}

int h4_deinit(void)
{
	return hci_uart_unregister_proto(&h4p);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	BlueZ - Bluetooth protocol stack for Linux
	3	Copyright (C) 2000-2001 Qualcomm Incorporated
	4
	5	Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License version 2 as
	9	published by the Free Software Foundation;
	10
	11	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	12	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	13	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
	14	IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
	15	CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
	16	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	17	ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	18	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	19
	20	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
	21	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
	22	SOFTWARE IS DISCLAIMED.
	23	*/
	24
	25	/*
	26	* Bluetooth HCI UART(H4) protocol.
	27	*
	28	* $Id: hci_h4.c,v 1.3 2002/09/09 01:17:32 maxk Exp $
	29	*/
	30	#define VERSION "1.2"
	31
	32	#include <linux/config.h>
	33	#include <linux/module.h>
	34
	35	#include <linux/kernel.h>
	36	#include <linux/init.h>
	37	#include <linux/sched.h>
	38	#include <linux/types.h>
	39	#include <linux/fcntl.h>
	40	#include <linux/interrupt.h>
	41	#include <linux/ptrace.h>
	42	#include <linux/poll.h>
	43
	44	#include <linux/slab.h>
	45	#include <linux/tty.h>
	46	#include <linux/errno.h>
	47	#include <linux/string.h>
	48	#include <linux/signal.h>
	49	#include <linux/ioctl.h>
	50	#include <linux/skbuff.h>
	51
	52	#include <net/bluetooth/bluetooth.h>
	53	#include <net/bluetooth/hci_core.h>
	54	#include "hci_uart.h"
	55	#include "hci_h4.h"
	56
	57	#ifndef CONFIG_BT_HCIUART_DEBUG
	58	#undef BT_DBG
	59	#define BT_DBG( A... )
1da177e4 LT	60	#endif
	61
	62	/* Initialize protocol */
	63	static int h4_open(struct hci_uart *hu)
	64	{
	65	struct h4_struct *h4;
	66
	67	BT_DBG("hu %p", hu);
	68
	69	h4 = kmalloc(sizeof(*h4), GFP_ATOMIC);
	70	if (!h4)
	71	return -ENOMEM;
	72	memset(h4, 0, sizeof(*h4));
	73
	74	skb_queue_head_init(&h4->txq);
	75
	76	hu->priv = h4;
	77	return 0;
	78	}
	79
	80	/* Flush protocol data */
	81	static int h4_flush(struct hci_uart *hu)
	82	{
	83	struct h4_struct *h4 = hu->priv;
	84
	85	BT_DBG("hu %p", hu);
	86	skb_queue_purge(&h4->txq);
	87	return 0;
	88	}
	89
	90	/* Close protocol */
	91	static int h4_close(struct hci_uart *hu)
	92	{
	93	struct h4_struct *h4 = hu->priv;
	94	hu->priv = NULL;
	95
	96	BT_DBG("hu %p", hu);
	97
	98	skb_queue_purge(&h4->txq);
	99	if (h4->rx_skb)
	100	kfree_skb(h4->rx_skb);
	101
	102	hu->priv = NULL;
	103	kfree(h4);
	104	return 0;
	105	}
	106
	107	/* Enqueue frame for transmittion (padding, crc, etc) */
	108	static int h4_enqueue(struct hci_uart hu, struct sk_buff skb)
	109	{
	110	struct h4_struct *h4 = hu->priv;
	111
	112	BT_DBG("hu %p skb %p", hu, skb);
	113
	114	/* Prepend skb with frame type */
0d48d939	115	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	116	skb_queue_tail(&h4->txq, skb);
	117	return 0;
	118	}
	119
	120	static inline int h4_check_data_len(struct h4_struct *h4, int len)
	121	{
	122	register int room = skb_tailroom(h4->rx_skb);
	123
	124	BT_DBG("len %d room %d", len, room);
	125	if (!len) {
1da177e4 LT	126	hci_recv_frame(h4->rx_skb);
	127	} else if (len > room) {
	128	BT_ERR("Data length is too large");
	129	kfree_skb(h4->rx_skb);
	130	} else {
	131	h4->rx_state = H4_W4_DATA;
	132	h4->rx_count = len;
	133	return len;
	134	}
	135
	136	h4->rx_state = H4_W4_PACKET_TYPE;
	137	h4->rx_skb = NULL;
	138	h4->rx_count = 0;
	139	return 0;
	140	}
	141
	142	/* Recv data */
	143	static int h4_recv(struct hci_uart hu, void data, int count)
	144	{
	145	struct h4_struct *h4 = hu->priv;
	146	register char *ptr;
	147	struct hci_event_hdr *eh;
	148	struct hci_acl_hdr *ah;
	149	struct hci_sco_hdr *sh;
	150	register int len, type, dlen;
	151
	152	BT_DBG("hu %p count %d rx_state %ld rx_count %ld",
	153	hu, count, h4->rx_state, h4->rx_count);
	154
	155	ptr = data;
	156	while (count) {
	157	if (h4->rx_count) {
	158	len = min_t(unsigned int, h4->rx_count, count);
	159	memcpy(skb_put(h4->rx_skb, len), ptr, len);
	160	h4->rx_count -= len; count -= len; ptr += len;
	161
	162	if (h4->rx_count)
	163	continue;
	164
	165	switch (h4->rx_state) {
	166	case H4_W4_DATA:
	167	BT_DBG("Complete data");
	168
1da177e4 LT	169	hci_recv_frame(h4->rx_skb);
	170
	171	h4->rx_state = H4_W4_PACKET_TYPE;
	172	h4->rx_skb = NULL;
	173	continue;
	174
	175	case H4_W4_EVENT_HDR:
	176	eh = (struct hci_event_hdr *) h4->rx_skb->data;
	177
	178	BT_DBG("Event header: evt 0x%2.2x plen %d", eh->evt, eh->plen);
	179
	180	h4_check_data_len(h4, eh->plen);
	181	continue;
	182
	183	case H4_W4_ACL_HDR:
	184	ah = (struct hci_acl_hdr *) h4->rx_skb->data;
	185	dlen = __le16_to_cpu(ah->dlen);
	186
	187	BT_DBG("ACL header: dlen %d", dlen);
	188
	189	h4_check_data_len(h4, dlen);
	190	continue;
	191
	192	case H4_W4_SCO_HDR:
	193	sh = (struct hci_sco_hdr *) h4->rx_skb->data;
	194
	195	BT_DBG("SCO header: dlen %d", sh->dlen);
	196
	197	h4_check_data_len(h4, sh->dlen);
	198	continue;
	199	}
	200	}
	201
	202	/* H4_W4_PACKET_TYPE */
	203	switch (*ptr) {
	204	case HCI_EVENT_PKT:
	205	BT_DBG("Event packet");
	206	h4->rx_state = H4_W4_EVENT_HDR;
	207	h4->rx_count = HCI_EVENT_HDR_SIZE;
	208	type = HCI_EVENT_PKT;
	209	break;
	210
	211	case HCI_ACLDATA_PKT:
	212	BT_DBG("ACL packet");
	213	h4->rx_state = H4_W4_ACL_HDR;
	214	h4->rx_count = HCI_ACL_HDR_SIZE;
	215	type = HCI_ACLDATA_PKT;
	216	break;
	217
	218	case HCI_SCODATA_PKT:
	219	BT_DBG("SCO packet");
	220	h4->rx_state = H4_W4_SCO_HDR;
	221	h4->rx_count = HCI_SCO_HDR_SIZE;
	222	type = HCI_SCODATA_PKT;
	223	break;
	224
	225	default:
	226	BT_ERR("Unknown HCI packet type %2.2x", (__u8)*ptr);
	227	hu->hdev->stat.err_rx++;
	228	ptr++; count--;
	229	continue;
	230	};
	231	ptr++; count--;
	232
233	/* Allocate packet */
234	h4->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
235	if (!h4->rx_skb) {
236	BT_ERR("Can't allocate mem for new packet");
237	h4->rx_state = H4_W4_PACKET_TYPE;
238	h4->rx_count = 0;
239	return 0;
240	}
241	h4->rx_skb->dev = (void *) hu->hdev;
0d48d939	242	bt_cb(h4->rx_skb)->pkt_type = type;
1da177e4 LT	243	}
	244	return count;
	245	}
	246
	247	static struct sk_buff h4_dequeue(struct hci_uart hu)
	248	{
	249	struct h4_struct *h4 = hu->priv;
	250	return skb_dequeue(&h4->txq);
	251	}
	252
	253	static struct hci_uart_proto h4p = {
	254	.id = HCI_UART_H4,
	255	.open = h4_open,
	256	.close = h4_close,
	257	.recv = h4_recv,
	258	.enqueue = h4_enqueue,
	259	.dequeue = h4_dequeue,
	260	.flush = h4_flush,
	261	};
	262
	263	int h4_init(void)
	264	{
	265	int err = hci_uart_register_proto(&h4p);
	266	if (!err)
	267	BT_INFO("HCI H4 protocol initialized");
	268	else
	269	BT_ERR("HCI H4 protocol registration failed");
	270
	271	return err;
	272	}
	273
	274	int h4_deinit(void)
	275	{
	276	return hci_uart_unregister_proto(&h4p);
	277	}