3 * Bluetooth virtual HCI driver
5 * Copyright (C) 2000-2001 Qualcomm Incorporated
6 * Copyright (C) 2002-2003 Maxim Krasnyansky <maxk@qualcomm.com>
7 * Copyright (C) 2004-2006 Marcel Holtmann <marcel@holtmann.org>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include <linux/module.h>
27 #include <asm/unaligned.h>
29 #include <linux/kernel.h>
30 #include <linux/init.h>
31 #include <linux/slab.h>
32 #include <linux/types.h>
33 #include <linux/errno.h>
34 #include <linux/sched.h>
35 #include <linux/poll.h>
37 #include <linux/skbuff.h>
38 #include <linux/miscdevice.h>
40 #include <net/bluetooth/bluetooth.h>
41 #include <net/bluetooth/hci_core.h>
50 wait_queue_head_t read_wait
;
51 struct sk_buff_head readq
;
53 struct delayed_work open_timeout
;
56 static int vhci_open_dev(struct hci_dev
*hdev
)
58 set_bit(HCI_RUNNING
, &hdev
->flags
);
63 static int vhci_close_dev(struct hci_dev
*hdev
)
65 struct vhci_data
*data
= hci_get_drvdata(hdev
);
67 if (!test_and_clear_bit(HCI_RUNNING
, &hdev
->flags
))
70 skb_queue_purge(&data
->readq
);
75 static int vhci_flush(struct hci_dev
*hdev
)
77 struct vhci_data
*data
= hci_get_drvdata(hdev
);
79 skb_queue_purge(&data
->readq
);
84 static int vhci_send_frame(struct hci_dev
*hdev
, struct sk_buff
*skb
)
86 struct vhci_data
*data
= hci_get_drvdata(hdev
);
88 if (!test_bit(HCI_RUNNING
, &hdev
->flags
))
91 memcpy(skb_push(skb
, 1), &bt_cb(skb
)->pkt_type
, 1);
92 skb_queue_tail(&data
->readq
, skb
);
94 wake_up_interruptible(&data
->read_wait
);
98 static int vhci_create_device(struct vhci_data
*data
, __u8 dev_type
)
100 struct hci_dev
*hdev
;
103 skb
= bt_skb_alloc(4, GFP_KERNEL
);
107 hdev
= hci_alloc_dev();
115 hdev
->bus
= HCI_VIRTUAL
;
116 hdev
->dev_type
= dev_type
;
117 hci_set_drvdata(hdev
, data
);
119 hdev
->open
= vhci_open_dev
;
120 hdev
->close
= vhci_close_dev
;
121 hdev
->flush
= vhci_flush
;
122 hdev
->send
= vhci_send_frame
;
124 if (hci_register_dev(hdev
) < 0) {
125 BT_ERR("Can't register HCI device");
132 bt_cb(skb
)->pkt_type
= HCI_VENDOR_PKT
;
134 *skb_put(skb
, 1) = 0xff;
135 *skb_put(skb
, 1) = dev_type
;
136 put_unaligned_le16(hdev
->id
, skb_put(skb
, 2));
137 skb_queue_tail(&data
->readq
, skb
);
139 wake_up_interruptible(&data
->read_wait
);
143 static inline ssize_t
vhci_get_user(struct vhci_data
*data
,
144 const char __user
*buf
, size_t count
)
147 __u8 pkt_type
, dev_type
;
150 if (count
< 2 || count
> HCI_MAX_FRAME_SIZE
)
153 skb
= bt_skb_alloc(count
, GFP_KERNEL
);
157 if (copy_from_user(skb_put(skb
, count
), buf
, count
)) {
162 pkt_type
= *((__u8
*) skb
->data
);
167 case HCI_ACLDATA_PKT
:
168 case HCI_SCODATA_PKT
:
174 bt_cb(skb
)->pkt_type
= pkt_type
;
176 ret
= hci_recv_frame(data
->hdev
, skb
);
185 cancel_delayed_work_sync(&data
->open_timeout
);
187 dev_type
= *((__u8
*) skb
->data
);
197 if (dev_type
!= HCI_BREDR
&& dev_type
!= HCI_AMP
)
200 ret
= vhci_create_device(data
, dev_type
);
208 return (ret
< 0) ? ret
: count
;
211 static inline ssize_t
vhci_put_user(struct vhci_data
*data
,
213 char __user
*buf
, int count
)
215 char __user
*ptr
= buf
;
218 len
= min_t(unsigned int, skb
->len
, count
);
220 if (copy_to_user(ptr
, skb
->data
, len
))
226 data
->hdev
->stat
.byte_tx
+= len
;
228 switch (bt_cb(skb
)->pkt_type
) {
229 case HCI_COMMAND_PKT
:
230 data
->hdev
->stat
.cmd_tx
++;
232 case HCI_ACLDATA_PKT
:
233 data
->hdev
->stat
.acl_tx
++;
235 case HCI_SCODATA_PKT
:
236 data
->hdev
->stat
.sco_tx
++;
243 static ssize_t
vhci_read(struct file
*file
,
244 char __user
*buf
, size_t count
, loff_t
*pos
)
246 struct vhci_data
*data
= file
->private_data
;
251 skb
= skb_dequeue(&data
->readq
);
253 ret
= vhci_put_user(data
, skb
, buf
, count
);
255 skb_queue_head(&data
->readq
, skb
);
261 if (file
->f_flags
& O_NONBLOCK
) {
266 ret
= wait_event_interruptible(data
->read_wait
,
267 !skb_queue_empty(&data
->readq
));
275 static ssize_t
vhci_write(struct file
*file
,
276 const char __user
*buf
, size_t count
, loff_t
*pos
)
278 struct vhci_data
*data
= file
->private_data
;
280 return vhci_get_user(data
, buf
, count
);
283 static unsigned int vhci_poll(struct file
*file
, poll_table
*wait
)
285 struct vhci_data
*data
= file
->private_data
;
287 poll_wait(file
, &data
->read_wait
, wait
);
289 if (!skb_queue_empty(&data
->readq
))
290 return POLLIN
| POLLRDNORM
;
292 return POLLOUT
| POLLWRNORM
;
295 static void vhci_open_timeout(struct work_struct
*work
)
297 struct vhci_data
*data
= container_of(work
, struct vhci_data
,
300 vhci_create_device(data
, amp
? HCI_AMP
: HCI_BREDR
);
303 static int vhci_open(struct inode
*inode
, struct file
*file
)
305 struct vhci_data
*data
;
307 data
= kzalloc(sizeof(struct vhci_data
), GFP_KERNEL
);
311 skb_queue_head_init(&data
->readq
);
312 init_waitqueue_head(&data
->read_wait
);
314 INIT_DELAYED_WORK(&data
->open_timeout
, vhci_open_timeout
);
316 file
->private_data
= data
;
317 nonseekable_open(inode
, file
);
319 schedule_delayed_work(&data
->open_timeout
, msecs_to_jiffies(1000));
324 static int vhci_release(struct inode
*inode
, struct file
*file
)
326 struct vhci_data
*data
= file
->private_data
;
327 struct hci_dev
*hdev
= data
->hdev
;
329 cancel_delayed_work_sync(&data
->open_timeout
);
332 hci_unregister_dev(hdev
);
336 file
->private_data
= NULL
;
342 static const struct file_operations vhci_fops
= {
343 .owner
= THIS_MODULE
,
348 .release
= vhci_release
,
352 static struct miscdevice vhci_miscdev
= {
355 .minor
= MISC_DYNAMIC_MINOR
,
358 static int __init
vhci_init(void)
360 BT_INFO("Virtual HCI driver ver %s", VERSION
);
362 return misc_register(&vhci_miscdev
);
365 static void __exit
vhci_exit(void)
367 misc_deregister(&vhci_miscdev
);
370 module_init(vhci_init
);
371 module_exit(vhci_exit
);
373 module_param(amp
, bool, 0644);
374 MODULE_PARM_DESC(amp
, "Create AMP controller device");
376 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
377 MODULE_DESCRIPTION("Bluetooth virtual HCI driver ver " VERSION
);
378 MODULE_VERSION(VERSION
);
379 MODULE_LICENSE("GPL");
380 MODULE_ALIAS("devname:vhci");