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 opcode
)
100 struct hci_dev
*hdev
;
104 /* bits 0-1 are dev_type (BR/EDR or AMP) */
105 dev_type
= opcode
& 0x03;
107 if (dev_type
!= HCI_BREDR
&& dev_type
!= HCI_AMP
)
110 /* bits 2-5 are reserved (must be zero) */
114 skb
= bt_skb_alloc(4, GFP_KERNEL
);
118 hdev
= hci_alloc_dev();
126 hdev
->bus
= HCI_VIRTUAL
;
127 hdev
->dev_type
= dev_type
;
128 hci_set_drvdata(hdev
, data
);
130 hdev
->open
= vhci_open_dev
;
131 hdev
->close
= vhci_close_dev
;
132 hdev
->flush
= vhci_flush
;
133 hdev
->send
= vhci_send_frame
;
135 /* bit 6 is for external configuration */
137 set_bit(HCI_QUIRK_EXTERNAL_CONFIG
, &hdev
->quirks
);
139 /* bit 7 is for raw device */
141 set_bit(HCI_QUIRK_RAW_DEVICE
, &hdev
->quirks
);
143 if (hci_register_dev(hdev
) < 0) {
144 BT_ERR("Can't register HCI device");
151 bt_cb(skb
)->pkt_type
= HCI_VENDOR_PKT
;
153 *skb_put(skb
, 1) = 0xff;
154 *skb_put(skb
, 1) = opcode
;
155 put_unaligned_le16(hdev
->id
, skb_put(skb
, 2));
156 skb_queue_tail(&data
->readq
, skb
);
158 wake_up_interruptible(&data
->read_wait
);
162 static inline ssize_t
vhci_get_user(struct vhci_data
*data
,
163 const struct iovec
*iov
,
166 size_t len
= iov_length(iov
, count
);
168 __u8 pkt_type
, opcode
;
172 if (len
< 2 || len
> HCI_MAX_FRAME_SIZE
)
175 skb
= bt_skb_alloc(len
, GFP_KERNEL
);
179 for (i
= 0; i
< count
; i
++) {
180 if (copy_from_user(skb_put(skb
, iov
[i
].iov_len
),
181 iov
[i
].iov_base
, iov
[i
].iov_len
)) {
187 pkt_type
= *((__u8
*) skb
->data
);
192 case HCI_ACLDATA_PKT
:
193 case HCI_SCODATA_PKT
:
199 bt_cb(skb
)->pkt_type
= pkt_type
;
201 ret
= hci_recv_frame(data
->hdev
, skb
);
210 cancel_delayed_work_sync(&data
->open_timeout
);
212 opcode
= *((__u8
*) skb
->data
);
222 ret
= vhci_create_device(data
, opcode
);
230 return (ret
< 0) ? ret
: len
;
233 static inline ssize_t
vhci_put_user(struct vhci_data
*data
,
235 char __user
*buf
, int count
)
237 char __user
*ptr
= buf
;
240 len
= min_t(unsigned int, skb
->len
, count
);
242 if (copy_to_user(ptr
, skb
->data
, len
))
248 data
->hdev
->stat
.byte_tx
+= len
;
250 switch (bt_cb(skb
)->pkt_type
) {
251 case HCI_COMMAND_PKT
:
252 data
->hdev
->stat
.cmd_tx
++;
254 case HCI_ACLDATA_PKT
:
255 data
->hdev
->stat
.acl_tx
++;
257 case HCI_SCODATA_PKT
:
258 data
->hdev
->stat
.sco_tx
++;
265 static ssize_t
vhci_read(struct file
*file
,
266 char __user
*buf
, size_t count
, loff_t
*pos
)
268 struct vhci_data
*data
= file
->private_data
;
273 skb
= skb_dequeue(&data
->readq
);
275 ret
= vhci_put_user(data
, skb
, buf
, count
);
277 skb_queue_head(&data
->readq
, skb
);
283 if (file
->f_flags
& O_NONBLOCK
) {
288 ret
= wait_event_interruptible(data
->read_wait
,
289 !skb_queue_empty(&data
->readq
));
297 static ssize_t
vhci_write(struct kiocb
*iocb
, const struct iovec
*iov
,
298 unsigned long count
, loff_t pos
)
300 struct file
*file
= iocb
->ki_filp
;
301 struct vhci_data
*data
= file
->private_data
;
303 return vhci_get_user(data
, iov
, count
);
306 static unsigned int vhci_poll(struct file
*file
, poll_table
*wait
)
308 struct vhci_data
*data
= file
->private_data
;
310 poll_wait(file
, &data
->read_wait
, wait
);
312 if (!skb_queue_empty(&data
->readq
))
313 return POLLIN
| POLLRDNORM
;
315 return POLLOUT
| POLLWRNORM
;
318 static void vhci_open_timeout(struct work_struct
*work
)
320 struct vhci_data
*data
= container_of(work
, struct vhci_data
,
323 vhci_create_device(data
, amp
? HCI_AMP
: HCI_BREDR
);
326 static int vhci_open(struct inode
*inode
, struct file
*file
)
328 struct vhci_data
*data
;
330 data
= kzalloc(sizeof(struct vhci_data
), GFP_KERNEL
);
334 skb_queue_head_init(&data
->readq
);
335 init_waitqueue_head(&data
->read_wait
);
337 INIT_DELAYED_WORK(&data
->open_timeout
, vhci_open_timeout
);
339 file
->private_data
= data
;
340 nonseekable_open(inode
, file
);
342 schedule_delayed_work(&data
->open_timeout
, msecs_to_jiffies(1000));
347 static int vhci_release(struct inode
*inode
, struct file
*file
)
349 struct vhci_data
*data
= file
->private_data
;
350 struct hci_dev
*hdev
= data
->hdev
;
352 cancel_delayed_work_sync(&data
->open_timeout
);
355 hci_unregister_dev(hdev
);
359 file
->private_data
= NULL
;
365 static const struct file_operations vhci_fops
= {
366 .owner
= THIS_MODULE
,
368 .aio_write
= vhci_write
,
371 .release
= vhci_release
,
375 static struct miscdevice vhci_miscdev
= {
381 static int __init
vhci_init(void)
383 BT_INFO("Virtual HCI driver ver %s", VERSION
);
385 return misc_register(&vhci_miscdev
);
388 static void __exit
vhci_exit(void)
390 misc_deregister(&vhci_miscdev
);
393 module_init(vhci_init
);
394 module_exit(vhci_exit
);
396 module_param(amp
, bool, 0644);
397 MODULE_PARM_DESC(amp
, "Create AMP controller device");
399 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
400 MODULE_DESCRIPTION("Bluetooth virtual HCI driver ver " VERSION
);
401 MODULE_VERSION(VERSION
);
402 MODULE_LICENSE("GPL");
403 MODULE_ALIAS("devname:vhci");
404 MODULE_ALIAS_MISCDEV(VHCI_MINOR
);