Release 4.7 drivers/bluetooth/hci_vhci.c

Directory: drivers/bluetooth
/*
 *
 *  Bluetooth virtual HCI driver
 *
 *  Copyright (C) 2000-2001  Qualcomm Incorporated
 *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
 *  Copyright (C) 2004-2006  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 <asm/unaligned.h>

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/poll.h>

#include <linux/skbuff.h>
#include <linux/miscdevice.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>


#define VERSION "1.5"


static bool amp;


struct vhci_data {
	
struct hci_dev *hdev;

	
wait_queue_head_t read_wait;
	
struct sk_buff_head readq;

	
struct mutex open_mutex;
	
struct delayed_work open_timeout;
};



static int vhci_open_dev(struct hci_dev *hdev)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 12 85.71% 1 33.33%
marcel holtmann marcel holtmann 1 7.14% 1 33.33%
maksim krasnyanskiy maksim krasnyanskiy 1 7.14% 1 33.33%
Total 14 100.00% 3 100.00%



static int vhci_close_dev(struct hci_dev *hdev)
{
	struct vhci_data *data = hci_get_drvdata(hdev);

	skb_queue_purge(&data->readq);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 20 62.50% 1 20.00%
marcel holtmann marcel holtmann 8 25.00% 2 40.00%
david herrmann david herrmann 3 9.38% 1 20.00%
maksim krasnyanskiy maksim krasnyanskiy 1 3.12% 1 20.00%
Total 32 100.00% 5 100.00%



static int vhci_flush(struct hci_dev *hdev)
{
	struct vhci_data *data = hci_get_drvdata(hdev);

	skb_queue_purge(&data->readq);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
maksim krasnyanskiy maksim krasnyanskiy 15 46.88% 1 25.00%
marcel holtmann marcel holtmann 14 43.75% 2 50.00%
david herrmann david herrmann 3 9.38% 1 25.00%
Total 32 100.00% 4 100.00%



static int vhci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct vhci_data *data = hci_get_drvdata(hdev);

	memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
	skb_queue_tail(&data->readq, skb);

	wake_up_interruptible(&data->read_wait);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 47 72.31% 1 12.50%
marcel holtmann marcel holtmann 17 26.15% 6 75.00%
maksim krasnyanskiy maksim krasnyanskiy 1 1.54% 1 12.50%
Total 65 100.00% 8 100.00%



static int __vhci_create_device(struct vhci_data *data, __u8 opcode)
{
	struct hci_dev *hdev;
	struct sk_buff *skb;
	__u8 dev_type;

	if (data->hdev)
		return -EBADFD;

	/* bits 0-1 are dev_type (BR/EDR or AMP) */
	dev_type = opcode & 0x03;

	if (dev_type != HCI_BREDR && dev_type != HCI_AMP)
		return -EINVAL;

	/* bits 2-5 are reserved (must be zero) */
	if (opcode & 0x3c)
		return -EINVAL;

	skb = bt_skb_alloc(4, GFP_KERNEL);
	if (!skb)
		return -ENOMEM;

	hdev = hci_alloc_dev();
	if (!hdev) {
		kfree_skb(skb);
		return -ENOMEM;
	}

	data->hdev = hdev;

	hdev->bus = HCI_VIRTUAL;
	hdev->dev_type = dev_type;
	hci_set_drvdata(hdev, data);

	hdev->open  = vhci_open_dev;
	hdev->close = vhci_close_dev;
	hdev->flush = vhci_flush;
	hdev->send  = vhci_send_frame;

	/* bit 6 is for external configuration */
	if (opcode & 0x40)
		set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);

	/* bit 7 is for raw device */
	if (opcode & 0x80)
		set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);

	if (hci_register_dev(hdev) < 0) {
		BT_ERR("Can't register HCI device");
		hci_free_dev(hdev);
		data->hdev = NULL;
		kfree_skb(skb);
		return -EBUSY;
	}

	hci_skb_pkt_type(skb) = HCI_VENDOR_PKT;

	*skb_put(skb, 1) = 0xff;
	*skb_put(skb, 1) = opcode;
	put_unaligned_le16(hdev->id, skb_put(skb, 2));
	skb_queue_tail(&data->readq, skb);

	wake_up_interruptible(&data->read_wait);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
marcel holtmann marcel holtmann 278 96.19% 4 80.00%
takashi iwai takashi iwai 11 3.81% 1 20.00%
Total 289 100.00% 5 100.00%



static int vhci_create_device(struct vhci_data *data, __u8 opcode)
{
	int err;

	mutex_lock(&data->open_mutex);
	err = __vhci_create_device(data, opcode);
	mutex_unlock(&data->open_mutex);

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
takashi iwai takashi iwai 45 100.00% 1 100.00%
Total 45 100.00% 1 100.00%



static inline ssize_t vhci_get_user(struct vhci_data *data,
				    struct iov_iter *from)
{
	size_t len = iov_iter_count(from);
	struct sk_buff *skb;
	__u8 pkt_type, opcode;
	int ret;

	if (len < 2 || len > HCI_MAX_FRAME_SIZE)
		return -EINVAL;

	skb = bt_skb_alloc(len, GFP_KERNEL);
	if (!skb)
		return -ENOMEM;

	if (copy_from_iter(skb_put(skb, len), len, from) != len) {
		kfree_skb(skb);
		return -EFAULT;
	}

	pkt_type = *((__u8 *) skb->data);
	skb_pull(skb, 1);

	switch (pkt_type) {
	case HCI_EVENT_PKT:
	case HCI_ACLDATA_PKT:
	case HCI_SCODATA_PKT:
		if (!data->hdev) {
			kfree_skb(skb);
			return -ENODEV;
		}

		hci_skb_pkt_type(skb) = pkt_type;

		ret = hci_recv_frame(data->hdev, skb);
		break;

	case HCI_VENDOR_PKT:
		cancel_delayed_work_sync(&data->open_timeout);

		opcode = *((__u8 *) skb->data);
		skb_pull(skb, 1);

		if (skb->len > 0) {
			kfree_skb(skb);
			return -EINVAL;
		}

		kfree_skb(skb);

		ret = vhci_create_device(data, opcode);
		break;

	default:
		kfree_skb(skb);
		return -EINVAL;
	}

	return (ret < 0) ? ret : len;
}

Contributors
Person Tokens Prop Commits CommitProp
marcel holtmann marcel holtmann 157 61.09% 7 53.85%
linus torvalds linus torvalds 71 27.63% 2 15.38%
al viro al viro 10 3.89% 1 7.69%
arnaldo carvalho de melo arnaldo carvalho de melo 10 3.89% 1 7.69%
jiri slaby jiri slaby 8 3.11% 1 7.69%
maksim krasnyanskiy maksim krasnyanskiy 1 0.39% 1 7.69%
Total 257 100.00% 13 100.00%



static inline ssize_t vhci_put_user(struct vhci_data *data,
				    struct sk_buff *skb,
				    char __user *buf, int count)
{
	char __user *ptr = buf;
	int len;

	len = min_t(unsigned int, skb->len, count);

	if (copy_to_user(ptr, skb->data, len))
		return -EFAULT;

	if (!data->hdev)
		return len;

	data->hdev->stat.byte_tx += len;

	switch (hci_skb_pkt_type(skb)) {
	case HCI_COMMAND_PKT:
		data->hdev->stat.cmd_tx++;
		break;
	case HCI_ACLDATA_PKT:
		data->hdev->stat.acl_tx++;
		break;
	case HCI_SCODATA_PKT:
		data->hdev->stat.sco_tx++;
		break;
	}

	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 85 63.43% 1 9.09%
marcel holtmann marcel holtmann 36 26.87% 6 54.55%
arnaldo carvalho de melo arnaldo carvalho de melo 7 5.22% 1 9.09%
maksim krasnyanskiy maksim krasnyanskiy 4 2.99% 1 9.09%
al viro al viro 1 0.75% 1 9.09%
gustavo f. padovan gustavo f. padovan 1 0.75% 1 9.09%
Total 134 100.00% 11 100.00%



static ssize_t vhci_read(struct file *file,
			 char __user *buf, size_t count, loff_t *pos)
{
	struct vhci_data *data = file->private_data;
	struct sk_buff *skb;
	ssize_t ret = 0;

	while (count) {
		skb = skb_dequeue(&data->readq);
		if (skb) {
			ret = vhci_put_user(data, skb, buf, count);
			if (ret < 0)
				skb_queue_head(&data->readq, skb);
			else
				kfree_skb(skb);
			break;
		}

		if (file->f_flags & O_NONBLOCK) {
			ret = -EAGAIN;
			break;
		}

		ret = wait_event_interruptible(data->read_wait,
					       !skb_queue_empty(&data->readq));
		if (ret < 0)
			break;
	}

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 79 54.86% 2 33.33%
marcel holtmann marcel holtmann 64 44.44% 3 50.00%
al viro al viro 1 0.69% 1 16.67%
Total 144 100.00% 6 100.00%



static ssize_t vhci_write(struct kiocb *iocb, struct iov_iter *from)
{
	struct file *file = iocb->ki_filp;
	struct vhci_data *data = file->private_data;

	return vhci_get_user(data, from);
}

Contributors
Person Tokens Prop Commits CommitProp
marcel holtmann marcel holtmann 27 64.29% 3 50.00%
maksim krasnyanskiy maksim krasnyanskiy 7 16.67% 1 16.67%
linus torvalds linus torvalds 5 11.90% 1 16.67%
al viro al viro 3 7.14% 1 16.67%
Total 42 100.00% 6 100.00%



static unsigned int vhci_poll(struct file *file, poll_table *wait)
{
	struct vhci_data *data = file->private_data;

	poll_wait(file, &data->read_wait, wait);

	if (!skb_queue_empty(&data->readq))
		return POLLIN | POLLRDNORM;

	return POLLOUT | POLLWRNORM;
}

Contributors
Person Tokens Prop Commits CommitProp
marcel holtmann marcel holtmann 30 51.72% 2 66.67%
linus torvalds linus torvalds 28 48.28% 1 33.33%
Total 58 100.00% 3 100.00%



static void vhci_open_timeout(struct work_struct *work)
{
	struct vhci_data *data = container_of(work, struct vhci_data,
					      open_timeout.work);

	vhci_create_device(data, amp ? HCI_AMP : HCI_BREDR);
}

Contributors
Person Tokens Prop Commits CommitProp
marcel holtmann marcel holtmann 39 100.00% 1 100.00%
Total 39 100.00% 1 100.00%



static int vhci_open(struct inode *inode, struct file *file)
{
	struct vhci_data *data;

	data = kzalloc(sizeof(struct vhci_data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	skb_queue_head_init(&data->readq);
	init_waitqueue_head(&data->read_wait);

	mutex_init(&data->open_mutex);
	INIT_DELAYED_WORK(&data->open_timeout, vhci_open_timeout);

	file->private_data = data;
	nonseekable_open(inode, file);

	schedule_delayed_work(&data->open_timeout, msecs_to_jiffies(1000));

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 59 55.66% 2 20.00%
marcel holtmann marcel holtmann 34 32.08% 4 40.00%
takashi iwai takashi iwai 8 7.55% 1 10.00%
david herrmann david herrmann 4 3.77% 2 20.00%
deepak saxena deepak saxena 1 0.94% 1 10.00%
Total 106 100.00% 10 100.00%



static int vhci_release(struct inode *inode, struct file *file)
{
	struct vhci_data *data = file->private_data;
	struct hci_dev *hdev;

	cancel_delayed_work_sync(&data->open_timeout);

	hdev = data->hdev;

	if (hdev) {
		hci_unregister_dev(hdev);
		hci_free_dev(hdev);
	}

	skb_queue_purge(&data->readq);
	file->private_data = NULL;
	kfree(data);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 36 43.90% 1 11.11%
marcel holtmann marcel holtmann 27 32.93% 5 55.56%
jiri slaby jiri slaby 14 17.07% 2 22.22%
david herrmann david herrmann 5 6.10% 1 11.11%
Total 82 100.00% 9 100.00%


static const struct file_operations vhci_fops = {
	.owner		= THIS_MODULE,
	.read		= vhci_read,
	.write_iter	= vhci_write,
	.poll		= vhci_poll,
	.open		= vhci_open,
	.release	= vhci_release,
	.llseek		= no_llseek,
};


static struct miscdevice vhci_miscdev = {
	.name	= "vhci",
	.fops	= &vhci_fops,
	.minor	= VHCI_MINOR,
};



static int __init vhci_init(void)
{
	BT_INFO("Virtual HCI driver ver %s", VERSION);

	return misc_register(&vhci_miscdev);
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 17 73.91% 2 33.33%
marcel holtmann marcel holtmann 5 21.74% 3 50.00%
maksim krasnyanskiy maksim krasnyanskiy 1 4.35% 1 16.67%
Total 23 100.00% 6 100.00%



static void __exit vhci_exit(void)
{
	misc_deregister(&vhci_miscdev);
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 10 66.67% 1 33.33%
marcel holtmann marcel holtmann 5 33.33% 2 66.67%
Total 15 100.00% 3 100.00%


module_init(vhci_init);

module_exit(vhci_exit);

module_param(amp, bool, 0644);
MODULE_PARM_DESC(amp, "Create AMP controller device");

MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("Bluetooth virtual HCI driver ver " VERSION);

MODULE_VERSION(VERSION);
MODULE_LICENSE("GPL");
MODULE_ALIAS("devname:vhci");

MODULE_ALIAS_MISCDEV(VHCI_MINOR);
Overall Contributors
Person Tokens Prop Commits CommitProp
marcel holtmann marcel holtmann 818 52.00% 20 47.62%
linus torvalds linus torvalds 542 34.46% 3 7.14%
takashi iwai takashi iwai 68 4.32% 1 2.38%
maksim krasnyanskiy maksim krasnyanskiy 31 1.97% 3 7.14%
jiri slaby jiri slaby 22 1.40% 2 4.76%
andrei emeltchenko andrei emeltchenko 20 1.27% 1 2.38%
arnaldo carvalho de melo arnaldo carvalho de melo 17 1.08% 1 2.38%
al viro al viro 16 1.02% 2 4.76%
david herrmann david herrmann 15 0.95% 3 7.14%
rusty russell rusty russell 10 0.64% 1 2.38%
lucas de marchi lucas de marchi 6 0.38% 1 2.38%
arnd bergmann arnd bergmann 5 0.32% 1 2.38%
deepak saxena deepak saxena 1 0.06% 1 2.38%
arjan van de ven arjan van de ven 1 0.06% 1 2.38%
gustavo f. padovan gustavo f. padovan 1 0.06% 1 2.38%
Total 1573 100.00% 42 100.00%
  Directory: drivers/bluetooth

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
linus torvalds	linus torvalds	12	85.71%	1	33.33%
marcel holtmann	marcel holtmann	1	7.14%	1	33.33%
maksim krasnyanskiy	maksim krasnyanskiy	1	7.14%	1	33.33%
	Total	14	100.00%	3	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/bluetooth/hci_vhci.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
