drivers/bluetooth/hci_vhci.c

   1 /*
   2    BlueZ - Bluetooth protocol stack for Linux
   3    Copyright (C) 2000-2001 Qualcomm Incorporated
   4
   5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License version 2 as
   9    published by the Free Software Foundation;
  10
  11    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  12    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  13    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  14    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  15    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  16    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  17    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  18    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  19
  20    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  21    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  22    SOFTWARE IS DISCLAIMED.
  23 */
  24
  25 /*
  26  * Bluetooth HCI virtual device driver.
  27  *
  28  * $Id: hci_vhci.c,v 1.3 2002/04/17 17:37:20 maxk Exp $
  29  */
  30 #define VERSION "1.1"
  31
  32 #include <linux/config.h>
  33 #include <linux/module.h>
  34
  35 #include <linux/errno.h>
  36 #include <linux/kernel.h>
  37 #include <linux/major.h>
  38 #include <linux/sched.h>
  39 #include <linux/slab.h>
  40 #include <linux/poll.h>
  41 #include <linux/fcntl.h>
  42 #include <linux/init.h>
  43 #include <linux/random.h>
  44
  45 #include <linux/skbuff.h>
  46 #include <linux/miscdevice.h>
  47
  48 #include <asm/system.h>
  49 #include <asm/uaccess.h>
  50
  51 #include <net/bluetooth/bluetooth.h>
  52 #include <net/bluetooth/hci_core.h>
  53 #include "hci_vhci.h"
  54
  55 /* HCI device part */
  56
  57 static int hci_vhci_open(struct hci_dev *hdev)
  58 {
  59         set_bit(HCI_RUNNING, &hdev->flags);
  60         return 0;
  61 }
  62
  63 static int hci_vhci_flush(struct hci_dev *hdev)
  64 {
  65         struct hci_vhci_struct *hci_vhci = (struct hci_vhci_struct *) hdev->driver_data;
  66         skb_queue_purge(&hci_vhci->readq);
  67         return 0;
  68 }
  69
  70 static int hci_vhci_close(struct hci_dev *hdev)
  71 {
  72         if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
  73                 return 0;
  74
  75         hci_vhci_flush(hdev);
  76         return 0;
  77 }
  78
  79 static void hci_vhci_destruct(struct hci_dev *hdev)
  80 {
  81         struct hci_vhci_struct *vhci;
  82
  83         if (!hdev) return;
  84
  85         vhci = (struct hci_vhci_struct *) hdev->driver_data;
  86         kfree(vhci);
  87 }
  88
  89 static int hci_vhci_send_frame(struct sk_buff *skb)
  90 {
  91         struct hci_dev* hdev = (struct hci_dev *) skb->dev;
  92         struct hci_vhci_struct *hci_vhci;
  93
  94         if (!hdev) {
  95                 BT_ERR("Frame for uknown device (hdev=NULL)");
  96                 return -ENODEV;
  97         }
  98
  99         if (!test_bit(HCI_RUNNING, &hdev->flags))
 100                 return -EBUSY;
 101
 102         hci_vhci = (struct hci_vhci_struct *) hdev->driver_data;
 103
 104         memcpy(skb_push(skb, 1), &skb->pkt_type, 1);
 105         skb_queue_tail(&hci_vhci->readq, skb);
 106
 107         if (hci_vhci->flags & VHCI_FASYNC)
 108                 kill_fasync(&hci_vhci->fasync, SIGIO, POLL_IN);
 109         wake_up_interruptible(&hci_vhci->read_wait);
 110
 111         return 0;
 112 }
 113
 114 /* Character device part */
 115
 116 /* Poll */
 117 static unsigned int hci_vhci_chr_poll(struct file *file, poll_table * wait)
 118 {
 119         struct hci_vhci_struct *hci_vhci = (struct hci_vhci_struct *) file->private_data;
 120
 121         poll_wait(file, &hci_vhci->read_wait, wait);
 122
 123         if (skb_queue_len(&hci_vhci->readq))
 124                 return POLLIN | POLLRDNORM;
 125
 126         return POLLOUT | POLLWRNORM;
 127 }
 128
 129 /* Get packet from user space buffer(already verified) */
 130 static inline ssize_t hci_vhci_get_user(struct hci_vhci_struct *hci_vhci, const char __user *buf, size_t count)
 131 {
 132         struct sk_buff *skb;
 133
 134         if (count > HCI_MAX_FRAME_SIZE)
 135                 return -EINVAL;
 136
 137         if (!(skb = bt_skb_alloc(count, GFP_KERNEL)))
 138                 return -ENOMEM;
 139
 140         if (copy_from_user(skb_put(skb, count), buf, count)) {
 141                 kfree_skb(skb);
 142                 return -EFAULT;
 143         }
 144
 145         skb->dev = (void *) hci_vhci->hdev;
 146         skb->pkt_type = *((__u8 *) skb->data);
 147         skb_pull(skb, 1);
 148
 149         hci_recv_frame(skb);
 150
 151         return count;
 152 }
 153
 154 /* Write */
 155 static ssize_t hci_vhci_chr_write(struct file * file, const char __user * buf,
 156                              size_t count, loff_t *pos)
 157 {
 158         struct hci_vhci_struct *hci_vhci = (struct hci_vhci_struct *) file->private_data;
 159
 160         if (verify_area(VERIFY_READ, buf, count))
 161                 return -EFAULT;
 162
 163         return hci_vhci_get_user(hci_vhci, buf, count);
 164 }
 165
 166 /* Put packet to user space buffer(already verified) */
 167 static inline ssize_t hci_vhci_put_user(struct hci_vhci_struct *hci_vhci,
 168                                        struct sk_buff *skb, char __user *buf,
 169                                        int count)
 170 {
 171         int len = count, total = 0;
 172         char __user *ptr = buf;
 173
 174         len = min_t(unsigned int, skb->len, len);
 175         if (copy_to_user(ptr, skb->data, len))
 176                 return -EFAULT;
 177         total += len;
 178
 179         hci_vhci->hdev->stat.byte_tx += len;
 180         switch (skb->pkt_type) {
 181                 case HCI_COMMAND_PKT:
 182                         hci_vhci->hdev->stat.cmd_tx++;
 183                         break;
 184
 185                 case HCI_ACLDATA_PKT:
 186                         hci_vhci->hdev->stat.acl_tx++;
 187                         break;
 188
 189                 case HCI_SCODATA_PKT:
 190                         hci_vhci->hdev->stat.cmd_tx++;
 191                         break;
 192         };
 193
 194         return total;
 195 }
 196
 197 /* Read */
 198 static ssize_t hci_vhci_chr_read(struct file * file, char __user * buf, size_t count, loff_t *pos)
 199 {
 200         struct hci_vhci_struct *hci_vhci = (struct hci_vhci_struct *) file->private_data;
 201         DECLARE_WAITQUEUE(wait, current);
 202         struct sk_buff *skb;
 203         ssize_t ret = 0;
 204
 205         add_wait_queue(&hci_vhci->read_wait, &wait);
 206         while (count) {
 207                 set_current_state(TASK_INTERRUPTIBLE);
 208
 209                 /* Read frames from device queue */
 210                 if (!(skb = skb_dequeue(&hci_vhci->readq))) {
 211                         if (file->f_flags & O_NONBLOCK) {
 212                                 ret = -EAGAIN;
 213                                 break;
 214                         }
 215                         if (signal_pending(current)) {
 216                                 ret = -ERESTARTSYS;
 217                                 break;
 218                         }
 219
 220                         /* Nothing to read, let's sleep */
 221                         schedule();
 222                         continue;
 223                 }
 224
 225                 if (!verify_area(VERIFY_WRITE, buf, count))
 226                         ret = hci_vhci_put_user(hci_vhci, skb, buf, count);
 227                 else
 228                         ret = -EFAULT;
 229
 230                 kfree_skb(skb);
 231                 break;
 232         }
 233         set_current_state(TASK_RUNNING);
 234         remove_wait_queue(&hci_vhci->read_wait, &wait);
 235
 236         return ret;
 237 }
 238
 239 static loff_t hci_vhci_chr_lseek(struct file * file, loff_t offset, int origin)
 240 {
 241         return -ESPIPE;
 242 }
 243
 244 static int hci_vhci_chr_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 245 {
 246         return -EINVAL;
 247 }
 248
 249 static int hci_vhci_chr_fasync(int fd, struct file *file, int on)
 250 {
 251         struct hci_vhci_struct *hci_vhci = (struct hci_vhci_struct *) file->private_data;
 252         int ret;
 253
 254         if ((ret = fasync_helper(fd, file, on, &hci_vhci->fasync)) < 0)
 255                 return ret;
 256
 257         if (on)
 258                 hci_vhci->flags |= VHCI_FASYNC;
 259         else
 260                 hci_vhci->flags &= ~VHCI_FASYNC;
 261
 262         return 0;
 263 }
 264
 265 static int hci_vhci_chr_open(struct inode *inode, struct file * file)
 266 {
 267         struct hci_vhci_struct *hci_vhci = NULL;
 268         struct hci_dev *hdev;
 269
 270         if (!(hci_vhci = kmalloc(sizeof(struct hci_vhci_struct), GFP_KERNEL)))
 271                 return -ENOMEM;
 272
 273         memset(hci_vhci, 0, sizeof(struct hci_vhci_struct));
 274
 275         skb_queue_head_init(&hci_vhci->readq);
 276         init_waitqueue_head(&hci_vhci->read_wait);
 277
 278         /* Initialize and register HCI device */
 279         hdev = hci_alloc_dev();
 280         if (!hdev) {
 281                 kfree(hci_vhci);
 282                 return -ENOMEM;
 283         }
 284
 285         hci_vhci->hdev = hdev;
 286
 287         hdev->type = HCI_VHCI;
 288         hdev->driver_data = hci_vhci;
 289
 290         hdev->open  = hci_vhci_open;
 291         hdev->close = hci_vhci_close;
 292         hdev->flush = hci_vhci_flush;
 293         hdev->send  = hci_vhci_send_frame;
 294         hdev->destruct = hci_vhci_destruct;
 295
 296         hdev->owner = THIS_MODULE;
 297
 298         if (hci_register_dev(hdev) < 0) {
 299                 kfree(hci_vhci);
 300                 hci_free_dev(hdev);
 301                 return -EBUSY;
 302         }
 303
 304         file->private_data = hci_vhci;
 305         return nonseekable_open(inode, file);
 306 }
 307
 308 static int hci_vhci_chr_close(struct inode *inode, struct file *file)
 309 {
 310         struct hci_vhci_struct *hci_vhci = (struct hci_vhci_struct *) file->private_data;
 311
 312         if (hci_unregister_dev(hci_vhci->hdev) < 0) {
 313                 BT_ERR("Can't unregister HCI device %s", hci_vhci->hdev->name);
 314         }
 315
 316         hci_free_dev(hci_vhci->hdev);
 317
 318         file->private_data = NULL;
 319         return 0;
 320 }
 321
 322 static struct file_operations hci_vhci_fops = {
 323         .owner  = THIS_MODULE,
 324         .llseek = hci_vhci_chr_lseek,
 325         .read   = hci_vhci_chr_read,
 326         .write  = hci_vhci_chr_write,
 327         .poll   = hci_vhci_chr_poll,
 328         .ioctl  = hci_vhci_chr_ioctl,
 329         .open   = hci_vhci_chr_open,
 330         .release        = hci_vhci_chr_close,
 331         .fasync = hci_vhci_chr_fasync
 332 };
 333
 334 static struct miscdevice hci_vhci_miscdev=
 335 {
 336         VHCI_MINOR,
 337         "hci_vhci",
 338         &hci_vhci_fops
 339 };
 340
 341 int __init hci_vhci_init(void)
 342 {
 343         BT_INFO("VHCI driver ver %s", VERSION);
 344
 345         if (misc_register(&hci_vhci_miscdev)) {
 346                 BT_ERR("Can't register misc device %d\n", VHCI_MINOR);
 347                 return -EIO;
 348         }
 349
 350         return 0;
 351 }
 352
 353 void hci_vhci_cleanup(void)
 354 {
 355         misc_deregister(&hci_vhci_miscdev);
 356 }
 357
 358 module_init(hci_vhci_init);
 359 module_exit(hci_vhci_cleanup);
 360
 361 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>");
 362 MODULE_DESCRIPTION("Bluetooth VHCI driver ver " VERSION);
 363 MODULE_LICENSE("GPL");