/* * *  Bluetooth HCI UART driver * *  Copyright (C) 2002-2003  Fabrizio Gennari <fabrizio.gennari@philips.com> *  Copyright (C) 2004-2005  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 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, write to the Free Software *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA * */#include <linux/module.h>#include <linux/kernel.h>#include <linux/init.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 <linux/bitrev.h>#include <asm/unaligned.h>#include <net/bluetooth/bluetooth.h>#include <net/bluetooth/hci_core.h>#include "hci_uart.h"#define VERSION "0.3"static int txcrc = 1;static int hciextn = 1;#define BCSP_TXWINSIZE	4#define BCSP_ACK_PKT	0x05#define BCSP_LE_PKT	0x06struct bcsp_struct {	struct sk_buff_head unack;	/* Unack'ed packets queue */	struct sk_buff_head rel;	/* Reliable packets queue */	struct sk_buff_head unrel;	/* Unreliable packets queue */	unsigned long rx_count;	struct	sk_buff *rx_skb;	u8	rxseq_txack;		/* rxseq == txack. */	u8	rxack;			/* Last packet sent by us that the peer ack'ed */	struct	timer_list tbcsp;	enum {		BCSP_W4_PKT_DELIMITER,		BCSP_W4_PKT_START,		BCSP_W4_BCSP_HDR,		BCSP_W4_DATA,		BCSP_W4_CRC	} rx_state;	enum {		BCSP_ESCSTATE_NOESC,		BCSP_ESCSTATE_ESC	} rx_esc_state;	u8	use_crc;	u16	message_crc;	u8	txack_req;		/* Do we need to send ack's to the peer? */	/* Reliable packet sequence number - used to assign seq to each rel pkt. */	u8	msgq_txseq;};/* ---- BCSP CRC calculation ---- *//* Table for calculating CRC for polynomial 0x1021, LSB processed first,initial value 0xffff, bits shifted in reverse order. */static const u16 crc_table[] = {	0x0000, 0x1081, 0x2102, 0x3183,	0x4204, 0x5285, 0x6306, 0x7387,	0x8408, 0x9489, 0xa50a, 0xb58b,	0xc60c, 0xd68d, 0xe70e, 0xf78f};/* Initialise the crc calculator */#define BCSP_CRC_INIT(x) x = 0xffff/*   Update crc with next data byte   Implementation note        The data byte is treated as two nibbles.  The crc is generated        in reverse, i.e., bits are fed into the register from the top.*/static void bcsp_crc_update(u16 *crc, u8 d){	u16 reg = *crc;	reg = (reg >> 4) ^ crc_table[(reg ^ d) & 0x000f];	reg = (reg >> 4) ^ crc_table[(reg ^ (d >> 4)) & 0x000f];	*crc = reg;}/* ---- BCSP core ---- */static void bcsp_slip_msgdelim(struct sk_buff *skb){	const char pkt_delim = 0xc0;	memcpy(skb_put(skb, 1), &pkt_delim, 1);}static void bcsp_slip_one_byte(struct sk_buff *skb, u8 c){	const char esc_c0[2] = { 0xdb, 0xdc };	const char esc_db[2] = { 0xdb, 0xdd };	switch (c) {	case 0xc0:		memcpy(skb_put(skb, 2), &esc_c0, 2);		break;	case 0xdb:		memcpy(skb_put(skb, 2), &esc_db, 2);		break;	default:		memcpy(skb_put(skb, 1), &c, 1);	}}static int bcsp_enqueue(struct hci_uart *hu, struct sk_buff *skb){	struct bcsp_struct *bcsp = hu->priv;	if (skb->len > 0xFFF) {		BT_ERR("Packet too long");		kfree_skb(skb);		return 0;	}	switch (bt_cb(skb)->pkt_type) {	case HCI_ACLDATA_PKT:	case HCI_COMMAND_PKT:		skb_queue_tail(&bcsp->rel, skb);		break;	case HCI_SCODATA_PKT:		skb_queue_tail(&bcsp->unrel, skb);		break;	default:		BT_ERR("Unknown packet type");		kfree_skb(skb);		break;	}	return 0;}static struct sk_buff *bcsp_prepare_pkt(struct bcsp_struct *bcsp, u8 *data,		int len, int pkt_type){	struct sk_buff *nskb;	u8 hdr[4], chan;	u16 BCSP_CRC_INIT(bcsp_txmsg_crc);	int rel, i;	switch (pkt_type) {	case HCI_ACLDATA_PKT:		chan = 6;	/* BCSP ACL channel */		rel = 1;	/* reliable channel */		break;	case HCI_COMMAND_PKT:		chan = 5;	/* BCSP cmd/evt channel */		rel = 1;	/* reliable channel */		break;	case HCI_SCODATA_PKT:		chan = 7;	/* BCSP SCO channel */		rel = 0;	/* unreliable channel */		break;	case BCSP_LE_PKT:		chan = 1;	/* BCSP LE channel */		rel = 0;	/* unreliable channel */		break;	case BCSP_ACK_PKT:		chan = 0;	/* BCSP internal channel */		rel = 0;	/* unreliable channel */		break;	default:		BT_ERR("Unknown packet type");		return NULL;	}	if (hciextn && chan == 5) {		__le16 opcode = ((struct hci_command_hdr *)data)->opcode;		/* Vendor specific commands */		if (hci_opcode_ogf(__le16_to_cpu(opcode)) == 0x3f) {			u8 desc = *(data + HCI_COMMAND_HDR_SIZE);			if ((desc & 0xf0) == 0xc0) {				data += HCI_COMMAND_HDR_SIZE + 1;				len  -= HCI_COMMAND_HDR_SIZE + 1;				chan = desc & 0x0f;			}		}	}	/* Max len of packet: (original len +4(bcsp hdr) +2(crc))*2	   (because bytes 0xc0 and 0xdb are escaped, worst case is	   when the packet is all made of 0xc0 and 0xdb :) )	   + 2 (0xc0 delimiters at start and end). */	nskb = alloc_skb((len + 6) * 2 + 2, GFP_ATOMIC);	if (!nskb)		return NULL;	bt_cb(nskb)->pkt_type = pkt_type;	bcsp_slip_msgdelim(nskb);	hdr[0] = bcsp->rxseq_txack << 3;	bcsp->txack_req = 0;	BT_DBG("We request packet no %u to card", bcsp->rxseq_txack);	if (rel) {		hdr[0] |= 0x80 + bcsp->msgq_txseq;		BT_DBG("Sending packet with seqno %u", bcsp->msgq_txseq);		bcsp->msgq_txseq = ++(bcsp->msgq_txseq) & 0x07;	}	if (bcsp->use_crc)		hdr[0] |= 0x40;	hdr[1] = ((len << 4) & 0xff) | chan;	hdr[2] = len >> 4;	hdr[3] = ~(hdr[0] + hdr[1] + hdr[2]);	/* Put BCSP header */	for (i = 0; i < 4; i++) {		bcsp_slip_one_byte(nskb, hdr[i]);		if (bcsp->use_crc)			bcsp_crc_update(&bcsp_txmsg_crc, hdr[i]);	}	/* Put payload */	for (i = 0; i < len; i++) {		bcsp_slip_one_byte(nskb, data[i]);		if (bcsp->use_crc)			bcsp_crc_update(&bcsp_txmsg_crc, data[i]);	}	/* Put CRC */	if (bcsp->use_crc) {		bcsp_txmsg_crc = bitrev16(bcsp_txmsg_crc);		bcsp_slip_one_byte(nskb, (u8) ((bcsp_txmsg_crc >> 8) & 0x00ff));		bcsp_slip_one_byte(nskb, (u8) (bcsp_txmsg_crc & 0x00ff));	}	bcsp_slip_msgdelim(nskb);	return nskb;}/* This is a rewrite of pkt_avail in ABCSP */static struct sk_buff *bcsp_dequeue(struct hci_uart *hu){	struct bcsp_struct *bcsp = hu->priv;	unsigned long flags;	struct sk_buff *skb;		/* First of all, check for unreliable messages in the queue,	   since they have priority */	if ((skb = skb_dequeue(&bcsp->unrel)) != NULL) {		struct sk_buff *nskb = bcsp_prepare_pkt(bcsp, skb->data, skb->len, bt_cb(skb)->pkt_type);		if (nskb) {			kfree_skb(skb);			return nskb;		} else {			skb_queue_head(&bcsp->unrel, skb);			BT_ERR("Could not dequeue pkt because alloc_skb failed");		}	}	/* Now, try to send a reliable pkt. We can only send a	   reliable packet if the number of packets sent but not yet ack'ed	   is < than the winsize */	spin_lock_irqsave_nested(&bcsp->unack.lock, flags, SINGLE_DEPTH_NESTING);	if (bcsp->unack.qlen < BCSP_TXWINSIZE && (skb = skb_dequeue(&bcsp->rel)) != NULL) {		struct sk_buff *nskb = bcsp_prepare_pkt(bcsp, skb->data, skb->len, bt_cb(skb)->pkt_type);		if (nskb) {			__skb_queue_tail(&bcsp->unack, skb);			mod_timer(&bcsp->tbcsp, jiffies + HZ / 4);			spin_unlock_irqrestore(&bcsp->unack.lock, flags);			return nskb;		} else {			skb_queue_head(&bcsp->rel, skb);			BT_ERR("Could not dequeue pkt because alloc_skb failed");		}	}	spin_unlock_irqrestore(&bcsp->unack.lock, flags);	/* We could not send a reliable packet, either because there are	   none or because there are too many unack'ed pkts. Did we receive	   any packets we have not acknowledged yet ? */	if (bcsp->txack_req) {		/* if so, craft an empty ACK pkt and send it on BCSP unreliable		   channel 0 */		struct sk_buff *nskb = bcsp_prepare_pkt(bcsp, NULL, 0, BCSP_ACK_PKT);		return nskb;	}	/* We have nothing to send */	return NULL;}static int bcsp_flush(struct hci_uart *hu){	BT_DBG("hu %p", hu);	return 0;}/* Remove ack'ed packets */static void bcsp_pkt_cull(struct bcsp_struct *bcsp){	struct sk_buff *skb, *tmp;	unsigned long flags;	int i, pkts_to_be_removed;	u8 seqno;	spin_lock_irqsave(&bcsp->unack.lock, flags);	pkts_to_be_removed = skb_queue_len(&bcsp->unack);	seqno = bcsp->msgq_txseq;	while (pkts_to_be_removed) {		if (bcsp->rxack == seqno)			break;		pkts_to_be_removed--;		seqno = (seqno - 1) & 0x07;	}	if (bcsp->rxack != seqno)		BT_ERR("Peer acked invalid packet");	BT_DBG("Removing %u pkts out of %u, up to seqno %u",	       pkts_to_be_removed, skb_queue_len(&bcsp->unack),	       (seqno - 1) & 0x07);	i = 0;	skb_queue_walk_safe(&bcsp->unack, skb, tmp) {		if (i++ >= pkts_to_be_removed)			break;		__skb_unlink(skb, &bcsp->unack);		kfree_skb(skb);	}