CTC++ Coverage Report - Execution Profile    #315/1532

Files Summary | Functions Summary | Execution Profile | Index | No Index
First | Previous | Next | Last

File: drivers/bluetooth/bfusb.c
Instrumentation mode: function-decision-multicondition
TER: 0 % ( 0/300)

Start/	End/
True	False	-	Line	Source
			1	/*
			2	*
			3	*  AVM BlueFRITZ! USB driver
			4	*
			5	*  Copyright (C) 2003  Marcel Holtmann <marcel@holtmann.org>
			6	*
			7	*
			8	*  This program is free software; you can redistribute it and/or modify
			9	*  it under the terms of the GNU General Public License as published by
			10	*  the Free Software Foundation; either version 2 of the License, or
			11	*  (at your option) any later version.
			12	*
			13	*  This program is distributed in the hope that it will be useful,
			14	*  but WITHOUT ANY WARRANTY; without even the implied warranty of
			15	*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
			16	*  GNU General Public License for more details.
			17	*
			18	*  You should have received a copy of the GNU General Public License
			19	*  along with this program; if not, write to the Free Software
			20	*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
			21	*
			22	*/
			23
			24	#include <linux/config.h>
			25	#include <linux/module.h>
			26
			27	#include <linux/kernel.h>
			28	#include <linux/init.h>
			29	#include <linux/slab.h>
			30	#include <linux/types.h>
			31	#include <linux/sched.h>
			32	#include <linux/errno.h>
			33	#include <linux/skbuff.h>
			34
			35	#include <linux/device.h>
			36	#include <linux/firmware.h>
			37
			38	#include <linux/usb.h>
			39
			40	#include <net/bluetooth/bluetooth.h>
			41	#include <net/bluetooth/hci_core.h>
			42
			43	#ifndef CONFIG_BT_HCIBFUSB_DEBUG
			44	#undef  BT_DBG
			45	#define BT_DBG(D...)
			46	#endif
			47
			48	#define VERSION "1.1"
			49
			50	static int ignore = 0;
			51
			52	static struct usb_driver bfusb_driver;
			53
			54	static struct usb_device_id bfusb_table[] = {
			55	/* AVM BlueFRITZ! USB */
			56	{ USB_DEVICE(0x057c, 0x2200) },
			57
			58	{ }   /* Terminating entry */
			59	};
			60
			61	MODULE_DEVICE_TABLE(usb, bfusb_table);
			62
			63
			64	#define BFUSB_MAX_BLOCK_SIZE   256
			65
			66	#define BFUSB_BLOCK_TIMEOUT   3000
			67
			68	#define BFUSB_TX_PROCESS   1
			69	#define BFUSB_TX_WAKEUP      2
			70
			71	#define BFUSB_MAX_BULK_TX   2
			72	#define BFUSB_MAX_BULK_RX   2
			73
			74	struct bfusb {
			75	struct hci_dev      *hdev;
			76
			77	unsigned long      state;
			78
			79	struct usb_device   *udev;
			80
			81	unsigned int      bulk_in_ep;
			82	unsigned int      bulk_out_ep;
			83	unsigned int      bulk_pkt_size;
			84
			85	rwlock_t      lock;
			86
			87	struct sk_buff_head   transmit_q;
			88
			89	struct sk_buff      *reassembly;
			90
			91	atomic_t      pending_tx;
			92	struct sk_buff_head   pending_q;
			93	struct sk_buff_head   completed_q;
			94	};
			95
			96	struct bfusb_scb {
			97	struct urb *urb;
			98	};
			99
			100	static void bfusb_tx_complete(struct urb *urb, struct pt_regs *regs);
			101	static void bfusb_rx_complete(struct urb *urb, struct pt_regs *regs);
			102
0	0	-	103	static struct urb *bfusb_get_completed(struct bfusb *bfusb)
			104	{
			105	struct sk_buff *skb;
			106	struct urb *urb = NULL;
			107
			108	BT_DBG("bfusb %p", bfusb);
			109
			110	skb = skb_dequeue(&bfusb->completed_q);
0	0	-	111	if (skb) {
			112	urb = ((struct bfusb_scb *) skb->cb)->urb;
			113	kfree_skb(skb);
			114	}
			115
0		-	116	return urb;
			117	}
			118
0	0	-	119	static void bfusb_unlink_urbs(struct bfusb *bfusb)
			120	{
			121	struct sk_buff *skb;
			122	struct urb *urb;
			123
			124	BT_DBG("bfusb %p", bfusb);
			125
0	0	-	126	while ((skb = skb_dequeue(&bfusb->pending_q))) {
			127	urb = ((struct bfusb_scb *) skb->cb)->urb;
			128	usb_kill_urb(urb);
			129	skb_queue_tail(&bfusb->completed_q, skb);
			130	}
			131
0	0	-	132	while ((urb = bfusb_get_completed(bfusb)))
			133	usb_free_urb(urb);
			134	}
			135
			136
0	0	-	137	static int bfusb_send_bulk(struct bfusb *bfusb, struct sk_buff *skb)
			138	{
			139	struct bfusb_scb *scb = (void *) skb->cb;
			140	struct urb *urb = bfusb_get_completed(bfusb);
			141	int err, pipe;
			142
			143	BT_DBG("bfusb %p skb %p len %d", bfusb, skb, skb->len);
			144
0	0	-	145	if (!urb && !(urb = usb_alloc_urb(0, GFP_ATOMIC)))
0		-	145	T && !(F)
	0	-	145	T && !(T)
	0	-	145	F && !(_)
0		-	146	return -ENOMEM;
			147
			148	pipe = usb_sndbulkpipe(bfusb->udev, bfusb->bulk_out_ep);
			149
			150	usb_fill_bulk_urb(urb, bfusb->udev, pipe, skb->data, skb->len,
			151	bfusb_tx_complete, skb);
			152
			153	scb->urb = urb;
			154
			155	skb_queue_tail(&bfusb->pending_q, skb);
			156
			157	err = usb_submit_urb(urb, GFP_ATOMIC);
0	0	-	158	if (err) {
			159	BT_ERR("%s bulk tx submit failed urb %p err %d",
			160	bfusb->hdev->name, urb, err);
			161	skb_unlink(skb, &bfusb->pending_q);
			162	usb_free_urb(urb);
			163	} else
			164	atomic_inc(&bfusb->pending_tx);
			165
0		-	166	return err;
			167	}
			168
0	0	-	169	static void bfusb_tx_wakeup(struct bfusb *bfusb)
			170	{
			171	struct sk_buff *skb;
			172
			173	BT_DBG("bfusb %p", bfusb);
			174
0	0	-	175	if (test_and_set_bit(BFUSB_TX_PROCESS, &bfusb->state)) {
			176	set_bit(BFUSB_TX_WAKEUP, &bfusb->state);
0		-	177	return;
			178	}
			179
			180	do {
			181	clear_bit(BFUSB_TX_WAKEUP, &bfusb->state);
			182
			183	while ((atomic_read(&bfusb->pending_tx) < BFUSB_MAX_BULK_TX) &&
0	0	-	184	(skb = skb_dequeue(&bfusb->transmit_q))) {
0		-	184	(T) && (T)
	0	-	184	(T) && (F)
	0	-	184	(F) && (_)
0	0	-	185	if (bfusb_send_bulk(bfusb, skb) < 0) {
			186	skb_queue_head(&bfusb->transmit_q, skb);
0		-	187	break;
			188	}
			189	}
			190
0	0	-	191	} while (test_bit(BFUSB_TX_WAKEUP, &bfusb->state));
0	0	-	191	ternary-?: __builtin_constant_p ( 2 )
			192
			193	clear_bit(BFUSB_TX_PROCESS, &bfusb->state);
			194	}
			195
0	0	-	196	static void bfusb_tx_complete(struct urb *urb, struct pt_regs *regs)
			197	{
			198	struct sk_buff *skb = (struct sk_buff *) urb->context;
			199	struct bfusb *bfusb = (struct bfusb *) skb->dev;
			200
			201	BT_DBG("bfusb %p urb %p skb %p len %d", bfusb, urb, skb, skb->len);
			202
			203	atomic_dec(&bfusb->pending_tx);
			204
0	0	-	205	if (!test_bit(HCI_RUNNING, &bfusb->hdev->flags))
0	0	-	205	ternary-?: __builtin_constant_p ( HCI_RUNNING )
0		-	206	return;
			207
0	0	-	208	if (!urb->status)
			209	bfusb->hdev->stat.byte_tx += skb->len;
			210	else
			211	bfusb->hdev->stat.err_tx++;
			212
			213	read_lock(&bfusb->lock);
			213	do
0	0	-	213	do-while (0)
0	0	-	213	do-while (0)
			214
			215	skb_unlink(skb, &bfusb->pending_q);
			216	skb_queue_tail(&bfusb->completed_q, skb);
			217
			218	bfusb_tx_wakeup(bfusb);
			219
			220	read_unlock(&bfusb->lock);
			220	do
0	0	-	220	do-while (0)
0	0	-	220	do-while (0)
			221	}
			222
			223
0	0	-	224	static int bfusb_rx_submit(struct bfusb *bfusb, struct urb *urb)
			225	{
			226	struct bfusb_scb *scb;
			227	struct sk_buff *skb;
			228	int err, pipe, size = HCI_MAX_FRAME_SIZE + 32;
			229
			230	BT_DBG("bfusb %p urb %p", bfusb, urb);
			231
0	0	-	232	if (!urb && !(urb = usb_alloc_urb(0, GFP_ATOMIC)))
0		-	232	T && !(F)
	0	-	232	T && !(T)
	0	-	232	F && !(_)
0		-	233	return -ENOMEM;
			234
0	0	-	235	if (!(skb = bt_skb_alloc(size, GFP_ATOMIC))) {
			236	usb_free_urb(urb);
0		-	237	return -ENOMEM;
			238	}
			239
			240	skb->dev = (void *) bfusb;
			241
			242	scb = (struct bfusb_scb *) skb->cb;
			243	scb->urb = urb;
			244
			245	pipe = usb_rcvbulkpipe(bfusb->udev, bfusb->bulk_in_ep);
			246
			247	usb_fill_bulk_urb(urb, bfusb->udev, pipe, skb->data, size,
			248	bfusb_rx_complete, skb);
			249
			250	skb_queue_tail(&bfusb->pending_q, skb);
			251
			252	err = usb_submit_urb(urb, GFP_ATOMIC);
0	0	-	253	if (err) {
			254	BT_ERR("%s bulk rx submit failed urb %p err %d",
			255	bfusb->hdev->name, urb, err);
			256	skb_unlink(skb, &bfusb->pending_q);
			257	kfree_skb(skb);
			258	usb_free_urb(urb);
			259	}
			260
0		-	261	return err;
			262	}
			263
0	0	-	264	static inline int bfusb_recv_block(struct bfusb *bfusb, int hdr, unsigned char *data, int len)
			265	{
			266	BT_DBG("bfusb %p hdr 0x%02x data %p len %d", bfusb, hdr, data, len);
			267
0	0	-	268	if (hdr & 0x10) {
			269	BT_ERR("%s error in block", bfusb->hdev->name);
0	0	-	270	if (bfusb->reassembly)
			271	kfree_skb(bfusb->reassembly);
			272	bfusb->reassembly = NULL;
0		-	273	return -EIO;
			274	}
			275
0	0	-	276	if (hdr & 0x04) {
			277	struct sk_buff *skb;
			278	unsigned char pkt_type;
			279	int pkt_len = 0;
			280
0	0	-	281	if (bfusb->reassembly) {
			282	BT_ERR("%s unexpected start block", bfusb->hdev->name);
			283	kfree_skb(bfusb->reassembly);
			284	bfusb->reassembly = NULL;
			285	}
			286
0	0	-	287	if (len < 1) {
			288	BT_ERR("%s no packet type found", bfusb->hdev->name);
0		-	289	return -EPROTO;
			290	}
			291
			292	pkt_type = *data++; len--;
			293
			294	switch (pkt_type) {
0		-	295	case HCI_EVENT_PKT:
0	0	-	296	if (len >= HCI_EVENT_HDR_SIZE) {
			297	struct hci_event_hdr *hdr = (struct hci_event_hdr *) data;
			298	pkt_len = HCI_EVENT_HDR_SIZE + hdr->plen;
			299	} else {
			300	BT_ERR("%s event block is too short", bfusb->hdev->name);
0		-	301	return -EILSEQ;
			302	}
0		-	303	break;
			304
0		-	305	case HCI_ACLDATA_PKT:
0	0	-	306	if (len >= HCI_ACL_HDR_SIZE) {
			307	struct hci_acl_hdr *hdr = (struct hci_acl_hdr *) data;
			308	pkt_len = HCI_ACL_HDR_SIZE + __le16_to_cpu(hdr->dlen);
			309	} else {
			310	BT_ERR("%s data block is too short", bfusb->hdev->name);
0		-	311	return -EILSEQ;
			312	}
0		-	313	break;
			314
0		-	315	case HCI_SCODATA_PKT:
0	0	-	316	if (len >= HCI_SCO_HDR_SIZE) {
			317	struct hci_sco_hdr *hdr = (struct hci_sco_hdr *) data;
			318	pkt_len = HCI_SCO_HDR_SIZE + hdr->dlen;
			319	} else {
			320	BT_ERR("%s audio block is too short", bfusb->hdev->name);
0		-	321	return -EILSEQ;
			322	}
0		-	323	break;
			324	}
			325
			326	skb = bt_skb_alloc(pkt_len, GFP_ATOMIC);
0	0	-	327	if (!skb) {
			328	BT_ERR("%s no memory for the packet", bfusb->hdev->name);
0		-	329	return -ENOMEM;
			330	}
			331
			332	skb->dev = (void *) bfusb->hdev;
			333	bt_cb(skb)->pkt_type = pkt_type;
			334
			335	bfusb->reassembly = skb;
			336	} else {
0	0	-	337	if (!bfusb->reassembly) {
			338	BT_ERR("%s unexpected continuation block", bfusb->hdev->name);
0		-	339	return -EIO;
			340	}
			341	}
			342
0	0	-	343	if (len > 0)
			344	memcpy(skb_put(bfusb->reassembly, len), data, len);
			345
0	0	-	346	if (hdr & 0x08) {
			347	hci_recv_frame(bfusb->reassembly);
			348	bfusb->reassembly = NULL;
			349	}
			350
0		-	351	return 0;
			352	}
			353
0	0	-	354	static void bfusb_rx_complete(struct urb *urb, struct pt_regs *regs)
			355	{
			356	struct sk_buff *skb = (struct sk_buff *) urb->context;
			357	struct bfusb *bfusb = (struct bfusb *) skb->dev;
			358	unsigned char *buf = urb->transfer_buffer;
			359	int count = urb->actual_length;
			360	int err, hdr, len;
			361
			362	BT_DBG("bfusb %p urb %p skb %p len %d", bfusb, urb, skb, skb->len);
			363
			364	read_lock(&bfusb->lock);
			364	do
0	0	-	364	do-while (0)
0	0	-	364	do-while (0)
			365
0	0	-	366	if (!test_bit(HCI_RUNNING, &bfusb->hdev->flags))
0	0	-	366	ternary-?: __builtin_constant_p ( HCI_RUNNING )
0		-	367	goto unlock;
			368
0	0	-	369	if (urb->status || !count)
0		-	369	T || _
0		-	369	F || T
	0	-	369	F || F
0		-	370	goto resubmit;
			371
			372	bfusb->hdev->stat.byte_rx += count;
			373
			374	skb_put(skb, count);
			375
0	0	-	376	while (count) {
			377	hdr = buf[0] | (buf[1] << 8);
			378
0	0	-	379	if (hdr & 0x4000) {
			380	len = 0;
			381	count -= 2;
			382	buf   += 2;
			383	} else {
			384	len = (buf[2] == 0) ? 256 : buf[2];
0	0	-	384	ternary-?: ( buf [ 2 ] == 0 )
			385	count -= 3;
			386	buf   += 3;
			387	}
			388
0	0	-	389	if (count < len) {
			390	BT_ERR("%s block extends over URB buffer ranges",
			391	bfusb->hdev->name);
			392	}
			393
0	0	-	394	if ((hdr & 0xe1) == 0xc1)
			395	bfusb_recv_block(bfusb, hdr, buf, len);
			396
			397	count -= len;
			398	buf   += len;
			399	}
			400
			401	skb_unlink(skb, &bfusb->pending_q);
			402	kfree_skb(skb);
			403
			404	bfusb_rx_submit(bfusb, urb);
			405
			406	read_unlock(&bfusb->lock);
			406	do
0	0	-	406	do-while (0)
0	0	-	406	do-while (0)
			407
0		-	408	return;
			409
			410	resubmit:
			411	urb->dev = bfusb->udev;
			412
			413	err = usb_submit_urb(urb, GFP_ATOMIC);
0	0	-	414	if (err) {
			415	BT_ERR("%s bulk resubmit failed urb %p err %d",
			416	bfusb->hdev->name, urb, err);
			417	}
			418
			419	unlock:
			420	read_unlock(&bfusb->lock);
			420	do
0	0	-	420	do-while (0)
0	0	-	420	do-while (0)
			421	}
			422
			423
0	0	-	424	static int bfusb_open(struct hci_dev *hdev)
			425	{
			426	struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
			427	unsigned long flags;
			428	int i, err;
			429
			430	BT_DBG("hdev %p bfusb %p", hdev, bfusb);
			431
0	0	-	432	if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
0		-	433	return 0;
			434
			435	write_lock_irqsave(&bfusb->lock, flags);
			435	do
			435	do
0	0	-	435	do-while (0)
0	0	-	435	do-while (0)
			435	do
			435	do
0	0	-	435	do-while (0)
0	0	-	435	do-while (0)
0	0	-	435	do-while (0)
			436
			437	err = bfusb_rx_submit(bfusb, NULL);
0	0	-	438	if (!err) {
0	0	-	439	for (i = 1; i < BFUSB_MAX_BULK_RX; i++)
			440	bfusb_rx_submit(bfusb, NULL);
			441	} else {
			442	clear_bit(HCI_RUNNING, &hdev->flags);
			443	}
			444
			445	write_unlock_irqrestore(&bfusb->lock, flags);
			445	do
			445	do
0	0	-	445	do-while (0)
0	0	-	445	do-while (0)
0	0	-	445	do-while (0)
			446
0		-	447	return err;
			448	}
			449
0	0	-	450	static int bfusb_flush(struct hci_dev *hdev)
			451	{
			452	struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
			453
			454	BT_DBG("hdev %p bfusb %p", hdev, bfusb);
			455
			456	skb_queue_purge(&bfusb->transmit_q);
			457
0		-	458	return 0;
			459	}
			460
0	0	-	461	static int bfusb_close(struct hci_dev *hdev)
			462	{
			463	struct bfusb *bfusb = (struct bfusb *) hdev->driver_data;
			464	unsigned long flags;
			465
			466	BT_DBG("hdev %p bfusb %p", hdev, bfusb);
			467
0	0	-	468	if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
0		-	469	return 0;
			470
			471	write_lock_irqsave(&bfusb->lock, flags);
			471	do
			471	do
0	0	-	471	do-while (0)
0	0	-	471	do-while (0)
			471	do
			471	do
0	0	-	471	do-while (0)
0	0	-	471	do-while (0)
0	0	-	471	do-while (0)
			472	write_unlock_irqrestore(&bfusb->lock, flags);
			472	do
			472	do
0	0	-	472	do-while (0)
0	0	-	472	do-while (0)
0	0	-	472	do-while (0)
			473
			474	bfusb_unlink_urbs(bfusb);
			475	bfusb_flush(hdev);
			476
0		-	477	return 0;
			478	}
			479
0	0	-	480	static int bfusb_send_frame(struct sk_buff *skb)
			481	{
			482	struct hci_dev *hdev = (struct hci_dev *) skb->dev;
			483	struct bfusb *bfusb;
			484	struct sk_buff *nskb;
			485	unsigned char buf[3];
			486	int sent = 0, size, count;
			487
			488	BT_DBG("hdev %p skb %p type %d len %d", hdev, skb, bt_cb(skb)->pkt_type, skb->len);
			489
0	0	-