hci_vhci.c 7.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381
  1. /*
  2. *
  3. * Bluetooth virtual HCI driver
  4. *
  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>
  8. *
  9. *
  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.
  14. *
  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.
  19. *
  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
  23. *
  24. */
  25. #include <linux/module.h>
  26. #include <linux/kernel.h>
  27. #include <linux/init.h>
  28. #include <linux/slab.h>
  29. #include <linux/types.h>
  30. #include <linux/errno.h>
  31. #include <linux/sched.h>
  32. #include <linux/poll.h>
  33. #include <linux/skbuff.h>
  34. #include <linux/miscdevice.h>
  35. #include <net/bluetooth/bluetooth.h>
  36. #include <net/bluetooth/hci_core.h>
  37. #ifndef CONFIG_BT_HCIVHCI_DEBUG
  38. #undef BT_DBG
  39. #define BT_DBG(D...)
  40. #endif
  41. #define VERSION "1.2"
  42. static int minor = MISC_DYNAMIC_MINOR;
  43. struct vhci_data {
  44. struct hci_dev *hdev;
  45. unsigned long flags;
  46. wait_queue_head_t read_wait;
  47. struct sk_buff_head readq;
  48. struct fasync_struct *fasync;
  49. };
  50. #define VHCI_FASYNC 0x0010
  51. static struct miscdevice vhci_miscdev;
  52. static int vhci_open_dev(struct hci_dev *hdev)
  53. {
  54. set_bit(HCI_RUNNING, &hdev->flags);
  55. return 0;
  56. }
  57. static int vhci_close_dev(struct hci_dev *hdev)
  58. {
  59. struct vhci_data *data = hdev->driver_data;
  60. if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
  61. return 0;
  62. skb_queue_purge(&data->readq);
  63. return 0;
  64. }
  65. static int vhci_flush(struct hci_dev *hdev)
  66. {
  67. struct vhci_data *data = hdev->driver_data;
  68. skb_queue_purge(&data->readq);
  69. return 0;
  70. }
  71. static int vhci_send_frame(struct sk_buff *skb)
  72. {
  73. struct hci_dev* hdev = (struct hci_dev *) skb->dev;
  74. struct vhci_data *data;
  75. if (!hdev) {
  76. BT_ERR("Frame for unknown HCI device (hdev=NULL)");
  77. return -ENODEV;
  78. }
  79. if (!test_bit(HCI_RUNNING, &hdev->flags))
  80. return -EBUSY;
  81. data = hdev->driver_data;
  82. memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
  83. skb_queue_tail(&data->readq, skb);
  84. if (data->flags & VHCI_FASYNC)
  85. kill_fasync(&data->fasync, SIGIO, POLL_IN);
  86. wake_up_interruptible(&data->read_wait);
  87. return 0;
  88. }
  89. static void vhci_destruct(struct hci_dev *hdev)
  90. {
  91. kfree(hdev->driver_data);
  92. }
  93. static inline ssize_t vhci_get_user(struct vhci_data *data,
  94. const char __user *buf, size_t count)
  95. {
  96. struct sk_buff *skb;
  97. if (count > HCI_MAX_FRAME_SIZE)
  98. return -EINVAL;
  99. skb = bt_skb_alloc(count, GFP_KERNEL);
  100. if (!skb)
  101. return -ENOMEM;
  102. if (copy_from_user(skb_put(skb, count), buf, count)) {
  103. kfree_skb(skb);
  104. return -EFAULT;
  105. }
  106. skb->dev = (void *) data->hdev;
  107. bt_cb(skb)->pkt_type = *((__u8 *) skb->data);
  108. skb_pull(skb, 1);
  109. hci_recv_frame(skb);
  110. return count;
  111. }
  112. static inline ssize_t vhci_put_user(struct vhci_data *data,
  113. struct sk_buff *skb, char __user *buf, int count)
  114. {
  115. char __user *ptr = buf;
  116. int len, total = 0;
  117. len = min_t(unsigned int, skb->len, count);
  118. if (copy_to_user(ptr, skb->data, len))
  119. return -EFAULT;
  120. total += len;
  121. data->hdev->stat.byte_tx += len;
  122. switch (bt_cb(skb)->pkt_type) {
  123. case HCI_COMMAND_PKT:
  124. data->hdev->stat.cmd_tx++;
  125. break;
  126. case HCI_ACLDATA_PKT:
  127. data->hdev->stat.acl_tx++;
  128. break;
  129. case HCI_SCODATA_PKT:
  130. data->hdev->stat.cmd_tx++;
  131. break;
  132. };
  133. return total;
  134. }
  135. static loff_t vhci_llseek(struct file *file, loff_t offset, int origin)
  136. {
  137. return -ESPIPE;
  138. }
  139. static ssize_t vhci_read(struct file *file,
  140. char __user *buf, size_t count, loff_t *pos)
  141. {
  142. DECLARE_WAITQUEUE(wait, current);
  143. struct vhci_data *data = file->private_data;
  144. struct sk_buff *skb;
  145. ssize_t ret = 0;
  146. add_wait_queue(&data->read_wait, &wait);
  147. while (count) {
  148. set_current_state(TASK_INTERRUPTIBLE);
  149. skb = skb_dequeue(&data->readq);
  150. if (!skb) {
  151. if (file->f_flags & O_NONBLOCK) {
  152. ret = -EAGAIN;
  153. break;
  154. }
  155. if (signal_pending(current)) {
  156. ret = -ERESTARTSYS;
  157. break;
  158. }
  159. schedule();
  160. continue;
  161. }
  162. if (access_ok(VERIFY_WRITE, buf, count))
  163. ret = vhci_put_user(data, skb, buf, count);
  164. else
  165. ret = -EFAULT;
  166. kfree_skb(skb);
  167. break;
  168. }
  169. set_current_state(TASK_RUNNING);
  170. remove_wait_queue(&data->read_wait, &wait);
  171. return ret;
  172. }
  173. static ssize_t vhci_write(struct file *file,
  174. const char __user *buf, size_t count, loff_t *pos)
  175. {
  176. struct vhci_data *data = file->private_data;
  177. if (!access_ok(VERIFY_READ, buf, count))
  178. return -EFAULT;
  179. return vhci_get_user(data, buf, count);
  180. }
  181. static unsigned int vhci_poll(struct file *file, poll_table *wait)
  182. {
  183. struct vhci_data *data = file->private_data;
  184. poll_wait(file, &data->read_wait, wait);
  185. if (!skb_queue_empty(&data->readq))
  186. return POLLIN | POLLRDNORM;
  187. return POLLOUT | POLLWRNORM;
  188. }
  189. static int vhci_ioctl(struct inode *inode, struct file *file,
  190. unsigned int cmd, unsigned long arg)
  191. {
  192. return -EINVAL;
  193. }
  194. static int vhci_open(struct inode *inode, struct file *file)
  195. {
  196. struct vhci_data *data;
  197. struct hci_dev *hdev;
  198. data = kzalloc(sizeof(struct vhci_data), GFP_KERNEL);
  199. if (!data)
  200. return -ENOMEM;
  201. skb_queue_head_init(&data->readq);
  202. init_waitqueue_head(&data->read_wait);
  203. hdev = hci_alloc_dev();
  204. if (!hdev) {
  205. kfree(data);
  206. return -ENOMEM;
  207. }
  208. data->hdev = hdev;
  209. hdev->type = HCI_VIRTUAL;
  210. hdev->driver_data = data;
  211. hdev->open = vhci_open_dev;
  212. hdev->close = vhci_close_dev;
  213. hdev->flush = vhci_flush;
  214. hdev->send = vhci_send_frame;
  215. hdev->destruct = vhci_destruct;
  216. hdev->owner = THIS_MODULE;
  217. if (hci_register_dev(hdev) < 0) {
  218. BT_ERR("Can't register HCI device");
  219. kfree(data);
  220. hci_free_dev(hdev);
  221. return -EBUSY;
  222. }
  223. file->private_data = data;
  224. return nonseekable_open(inode, file);
  225. }
  226. static int vhci_release(struct inode *inode, struct file *file)
  227. {
  228. struct vhci_data *data = file->private_data;
  229. struct hci_dev *hdev = data->hdev;
  230. if (hci_unregister_dev(hdev) < 0) {
  231. BT_ERR("Can't unregister HCI device %s", hdev->name);
  232. }
  233. hci_free_dev(hdev);
  234. file->private_data = NULL;
  235. return 0;
  236. }
  237. static int vhci_fasync(int fd, struct file *file, int on)
  238. {
  239. struct vhci_data *data = file->private_data;
  240. int err;
  241. err = fasync_helper(fd, file, on, &data->fasync);
  242. if (err < 0)
  243. return err;
  244. if (on)
  245. data->flags |= VHCI_FASYNC;
  246. else
  247. data->flags &= ~VHCI_FASYNC;
  248. return 0;
  249. }
  250. static const struct file_operations vhci_fops = {
  251. .owner = THIS_MODULE,
  252. .llseek = vhci_llseek,
  253. .read = vhci_read,
  254. .write = vhci_write,
  255. .poll = vhci_poll,
  256. .ioctl = vhci_ioctl,
  257. .open = vhci_open,
  258. .release = vhci_release,
  259. .fasync = vhci_fasync,
  260. };
  261. static struct miscdevice vhci_miscdev= {
  262. .name = "vhci",
  263. .fops = &vhci_fops,
  264. };
  265. static int __init vhci_init(void)
  266. {
  267. BT_INFO("Virtual HCI driver ver %s", VERSION);
  268. vhci_miscdev.minor = minor;
  269. if (misc_register(&vhci_miscdev) < 0) {
  270. BT_ERR("Can't register misc device with minor %d", minor);
  271. return -EIO;
  272. }
  273. return 0;
  274. }
  275. static void __exit vhci_exit(void)
  276. {
  277. if (misc_deregister(&vhci_miscdev) < 0)
  278. BT_ERR("Can't unregister misc device with minor %d", minor);
  279. }
  280. module_init(vhci_init);
  281. module_exit(vhci_exit);
  282. module_param(minor, int, 0444);
  283. MODULE_PARM_DESC(minor, "Miscellaneous minor device number");
  284. MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
  285. MODULE_DESCRIPTION("Bluetooth virtual HCI driver ver " VERSION);
  286. MODULE_VERSION(VERSION);
  287. MODULE_LICENSE("GPL");