drivers/bluetooth/hci_vhci.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *
   4  *  Bluetooth virtual HCI driver
   5  *
   6  *  Copyright (C) 2000-2001  Qualcomm Incorporated
   7  *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
   8  *  Copyright (C) 2004-2006  Marcel Holtmann <marcel@holtmann.org>
   9  */
  10
  11 #include <linux/module.h>
  12 #include <asm/unaligned.h>
  13
  14 #include <linux/kernel.h>
  15 #include <linux/init.h>
  16 #include <linux/slab.h>
  17 #include <linux/types.h>
  18 #include <linux/errno.h>
  19 #include <linux/sched.h>
  20 #include <linux/poll.h>
  21
  22 #include <linux/skbuff.h>
  23 #include <linux/miscdevice.h>
  24 #include <linux/debugfs.h>
  25
  26 #include <net/bluetooth/bluetooth.h>
  27 #include <net/bluetooth/hci_core.h>
  28
  29 #define VERSION "1.5"
  30
  31 static bool amp;
  32
  33 struct vhci_data {
  34         struct hci_dev *hdev;
  35
  36         wait_queue_head_t read_wait;
  37         struct sk_buff_head readq;
  38
  39         struct mutex open_mutex;
  40         struct delayed_work open_timeout;
  41         struct work_struct suspend_work;
  42
  43         bool suspended;
  44         bool wakeup;
  45         __u16 msft_opcode;
  46         bool aosp_capable;
  47 };
  48
  49 static int vhci_open_dev(struct hci_dev *hdev)
  50 {
  51         return 0;
  52 }
  53
  54 static int vhci_close_dev(struct hci_dev *hdev)
  55 {
  56         struct vhci_data *data = hci_get_drvdata(hdev);
  57
  58         skb_queue_purge(&data->readq);
  59
  60         return 0;
  61 }
  62
  63 static int vhci_flush(struct hci_dev *hdev)
  64 {
  65         struct vhci_data *data = hci_get_drvdata(hdev);
  66
  67         skb_queue_purge(&data->readq);
  68
  69         return 0;
  70 }
  71
  72 static int vhci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
  73 {
  74         struct vhci_data *data = hci_get_drvdata(hdev);
  75
  76         memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
  77         skb_queue_tail(&data->readq, skb);
  78
  79         wake_up_interruptible(&data->read_wait);
  80         return 0;
  81 }
  82
  83 static int vhci_get_data_path_id(struct hci_dev *hdev, u8 *data_path_id)
  84 {
  85         *data_path_id = 0;
  86         return 0;
  87 }
  88
  89 static int vhci_get_codec_config_data(struct hci_dev *hdev, __u8 type,
  90                                       struct bt_codec *codec, __u8 *vnd_len,
  91                                       __u8 **vnd_data)
  92 {
  93         if (type != ESCO_LINK)
  94                 return -EINVAL;
  95
  96         *vnd_len = 0;
  97         *vnd_data = NULL;
  98         return 0;
  99 }
 100
 101 static bool vhci_wakeup(struct hci_dev *hdev)
 102 {
 103         struct vhci_data *data = hci_get_drvdata(hdev);
 104
 105         return data->wakeup;
 106 }
 107
 108 static ssize_t force_suspend_read(struct file *file, char __user *user_buf,
 109                                   size_t count, loff_t *ppos)
 110 {
 111         struct vhci_data *data = file->private_data;
 112         char buf[3];
 113
 114         buf[0] = data->suspended ? 'Y' : 'N';
 115         buf[1] = '\n';
 116         buf[2] = '\0';
 117         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
 118 }
 119
 120 static void vhci_suspend_work(struct work_struct *work)
 121 {
 122         struct vhci_data *data = container_of(work, struct vhci_data,
 123                                               suspend_work);
 124
 125         if (data->suspended)
 126                 hci_suspend_dev(data->hdev);
 127         else
 128                 hci_resume_dev(data->hdev);
 129 }
 130
 131 static ssize_t force_suspend_write(struct file *file,
 132                                    const char __user *user_buf,
 133                                    size_t count, loff_t *ppos)
 134 {
 135         struct vhci_data *data = file->private_data;
 136         bool enable;
 137         int err;
 138
 139         err = kstrtobool_from_user(user_buf, count, &enable);
 140         if (err)
 141                 return err;
 142
 143         if (data->suspended == enable)
 144                 return -EALREADY;
 145
 146         data->suspended = enable;
 147
 148         schedule_work(&data->suspend_work);
 149
 150         return count;
 151 }
 152
 153 static const struct file_operations force_suspend_fops = {
 154         .open           = simple_open,
 155         .read           = force_suspend_read,
 156         .write          = force_suspend_write,
 157         .llseek         = default_llseek,
 158 };
 159
 160 static ssize_t force_wakeup_read(struct file *file, char __user *user_buf,
 161                                  size_t count, loff_t *ppos)
 162 {
 163         struct vhci_data *data = file->private_data;
 164         char buf[3];
 165
 166         buf[0] = data->wakeup ? 'Y' : 'N';
 167         buf[1] = '\n';
 168         buf[2] = '\0';
 169         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
 170 }
 171
 172 static ssize_t force_wakeup_write(struct file *file,
 173                                   const char __user *user_buf, size_t count,
 174                                   loff_t *ppos)
 175 {
 176         struct vhci_data *data = file->private_data;
 177         bool enable;
 178         int err;
 179
 180         err = kstrtobool_from_user(user_buf, count, &enable);
 181         if (err)
 182                 return err;
 183
 184         if (data->wakeup == enable)
 185                 return -EALREADY;
 186
 187         data->wakeup = enable;
 188
 189         return count;
 190 }
 191
 192 static const struct file_operations force_wakeup_fops = {
 193         .open           = simple_open,
 194         .read           = force_wakeup_read,
 195         .write          = force_wakeup_write,
 196         .llseek         = default_llseek,
 197 };
 198
 199 static int msft_opcode_set(void *data, u64 val)
 200 {
 201         struct vhci_data *vhci = data;
 202
 203         if (val > 0xffff || hci_opcode_ogf(val) != 0x3f)
 204                 return -EINVAL;
 205
 206         if (vhci->msft_opcode)
 207                 return -EALREADY;
 208
 209         vhci->msft_opcode = val;
 210
 211         return 0;
 212 }
 213
 214 static int msft_opcode_get(void *data, u64 *val)
 215 {
 216         struct vhci_data *vhci = data;
 217
 218         *val = vhci->msft_opcode;
 219
 220         return 0;
 221 }
 222
 223 DEFINE_DEBUGFS_ATTRIBUTE(msft_opcode_fops, msft_opcode_get, msft_opcode_set,
 224                          "%llu\n");
 225
 226 static ssize_t aosp_capable_read(struct file *file, char __user *user_buf,
 227                                  size_t count, loff_t *ppos)
 228 {
 229         struct vhci_data *vhci = file->private_data;
 230         char buf[3];
 231
 232         buf[0] = vhci->aosp_capable ? 'Y' : 'N';
 233         buf[1] = '\n';
 234         buf[2] = '\0';
 235         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
 236 }
 237
 238 static ssize_t aosp_capable_write(struct file *file,
 239                                   const char __user *user_buf, size_t count,
 240                                   loff_t *ppos)
 241 {
 242         struct vhci_data *vhci = file->private_data;
 243         bool enable;
 244         int err;
 245
 246         err = kstrtobool_from_user(user_buf, count, &enable);
 247         if (err)
 248                 return err;
 249
 250         if (!enable)
 251                 return -EINVAL;
 252
 253         if (vhci->aosp_capable)
 254                 return -EALREADY;
 255
 256         vhci->aosp_capable = enable;
 257
 258         return count;
 259 }
 260
 261 static const struct file_operations aosp_capable_fops = {
 262         .open           = simple_open,
 263         .read           = aosp_capable_read,
 264         .write          = aosp_capable_write,
 265         .llseek         = default_llseek,
 266 };
 267
 268 static int vhci_setup(struct hci_dev *hdev)
 269 {
 270         struct vhci_data *vhci = hci_get_drvdata(hdev);
 271
 272         if (vhci->msft_opcode)
 273                 hci_set_msft_opcode(hdev, vhci->msft_opcode);
 274
 275         if (vhci->aosp_capable)
 276                 hci_set_aosp_capable(hdev);
 277
 278         return 0;
 279 }
 280
 281 static int __vhci_create_device(struct vhci_data *data, __u8 opcode)
 282 {
 283         struct hci_dev *hdev;
 284         struct sk_buff *skb;
 285         __u8 dev_type;
 286
 287         if (data->hdev)
 288                 return -EBADFD;
 289
 290         /* bits 0-1 are dev_type (Primary or AMP) */
 291         dev_type = opcode & 0x03;
 292
 293         if (dev_type != HCI_PRIMARY && dev_type != HCI_AMP)
 294                 return -EINVAL;
 295
 296         /* bits 2-5 are reserved (must be zero) */
 297         if (opcode & 0x3c)
 298                 return -EINVAL;
 299
 300         skb = bt_skb_alloc(4, GFP_KERNEL);
 301         if (!skb)
 302                 return -ENOMEM;
 303
 304         hdev = hci_alloc_dev();
 305         if (!hdev) {
 306                 kfree_skb(skb);
 307                 return -ENOMEM;
 308         }
 309
 310         data->hdev = hdev;
 311
 312         hdev->bus = HCI_VIRTUAL;
 313         hdev->dev_type = dev_type;
 314         hci_set_drvdata(hdev, data);
 315
 316         hdev->open  = vhci_open_dev;
 317         hdev->close = vhci_close_dev;
 318         hdev->flush = vhci_flush;
 319         hdev->send  = vhci_send_frame;
 320         hdev->get_data_path_id = vhci_get_data_path_id;
 321         hdev->get_codec_config_data = vhci_get_codec_config_data;
 322         hdev->wakeup = vhci_wakeup;
 323         hdev->setup = vhci_setup;
 324         set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);
 325
 326         /* bit 6 is for external configuration */
 327         if (opcode & 0x40)
 328                 set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);
 329
 330         /* bit 7 is for raw device */
 331         if (opcode & 0x80)
 332                 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
 333
 334         set_bit(HCI_QUIRK_VALID_LE_STATES, &hdev->quirks);
 335
 336         if (hci_register_dev(hdev) < 0) {
 337                 BT_ERR("Can't register HCI device");
 338                 hci_free_dev(hdev);
 339                 data->hdev = NULL;
 340                 kfree_skb(skb);
 341                 return -EBUSY;
 342         }
 343
 344         debugfs_create_file("force_suspend", 0644, hdev->debugfs, data,
 345                             &force_suspend_fops);
 346
 347         debugfs_create_file("force_wakeup", 0644, hdev->debugfs, data,
 348                             &force_wakeup_fops);
 349
 350         if (IS_ENABLED(CONFIG_BT_MSFTEXT))
 351                 debugfs_create_file("msft_opcode", 0644, hdev->debugfs, data,
 352                                     &msft_opcode_fops);
 353
 354         if (IS_ENABLED(CONFIG_BT_AOSPEXT))
 355                 debugfs_create_file("aosp_capable", 0644, hdev->debugfs, data,
 356                                     &aosp_capable_fops);
 357
 358         hci_skb_pkt_type(skb) = HCI_VENDOR_PKT;
 359
 360         skb_put_u8(skb, 0xff);
 361         skb_put_u8(skb, opcode);
 362         put_unaligned_le16(hdev->id, skb_put(skb, 2));
 363         skb_queue_tail(&data->readq, skb);
 364
 365         wake_up_interruptible(&data->read_wait);
 366         return 0;
 367 }
 368
 369 static int vhci_create_device(struct vhci_data *data, __u8 opcode)
 370 {
 371         int err;
 372
 373         mutex_lock(&data->open_mutex);
 374         err = __vhci_create_device(data, opcode);
 375         mutex_unlock(&data->open_mutex);
 376
 377         return err;
 378 }
 379
 380 static inline ssize_t vhci_get_user(struct vhci_data *data,
 381                                     struct iov_iter *from)
 382 {
 383         size_t len = iov_iter_count(from);
 384         struct sk_buff *skb;
 385         __u8 pkt_type, opcode;
 386         int ret;
 387
 388         if (len < 2 || len > HCI_MAX_FRAME_SIZE)
 389                 return -EINVAL;
 390
 391         skb = bt_skb_alloc(len, GFP_KERNEL);
 392         if (!skb)
 393                 return -ENOMEM;
 394
 395         if (!copy_from_iter_full(skb_put(skb, len), len, from)) {
 396                 kfree_skb(skb);
 397                 return -EFAULT;
 398         }
 399
 400         pkt_type = *((__u8 *) skb->data);
 401         skb_pull(skb, 1);
 402
 403         switch (pkt_type) {
 404         case HCI_EVENT_PKT:
 405         case HCI_ACLDATA_PKT:
 406         case HCI_SCODATA_PKT:
 407         case HCI_ISODATA_PKT:
 408                 if (!data->hdev) {
 409                         kfree_skb(skb);
 410                         return -ENODEV;
 411                 }
 412
 413                 hci_skb_pkt_type(skb) = pkt_type;
 414
 415                 ret = hci_recv_frame(data->hdev, skb);
 416                 break;
 417
 418         case HCI_VENDOR_PKT:
 419                 cancel_delayed_work_sync(&data->open_timeout);
 420
 421                 opcode = *((__u8 *) skb->data);
 422                 skb_pull(skb, 1);
 423
 424                 if (skb->len > 0) {
 425                         kfree_skb(skb);
 426                         return -EINVAL;
 427                 }
 428
 429                 kfree_skb(skb);
 430
 431                 ret = vhci_create_device(data, opcode);
 432                 break;
 433
 434         default:
 435                 kfree_skb(skb);
 436                 return -EINVAL;
 437         }
 438
 439         return (ret < 0) ? ret : len;
 440 }
 441
 442 static inline ssize_t vhci_put_user(struct vhci_data *data,
 443                                     struct sk_buff *skb,
 444                                     char __user *buf, int count)
 445 {
 446         char __user *ptr = buf;
 447         int len;
 448
 449         len = min_t(unsigned int, skb->len, count);
 450
 451         if (copy_to_user(ptr, skb->data, len))
 452                 return -EFAULT;
 453
 454         if (!data->hdev)
 455                 return len;
 456
 457         data->hdev->stat.byte_tx += len;
 458
 459         switch (hci_skb_pkt_type(skb)) {
 460         case HCI_COMMAND_PKT:
 461                 data->hdev->stat.cmd_tx++;
 462                 break;
 463         case HCI_ACLDATA_PKT:
 464                 data->hdev->stat.acl_tx++;
 465                 break;
 466         case HCI_SCODATA_PKT:
 467                 data->hdev->stat.sco_tx++;
 468                 break;
 469         }
 470
 471         return len;
 472 }
 473
 474 static ssize_t vhci_read(struct file *file,
 475                          char __user *buf, size_t count, loff_t *pos)
 476 {
 477         struct vhci_data *data = file->private_data;
 478         struct sk_buff *skb;
 479         ssize_t ret = 0;
 480
 481         while (count) {
 482                 skb = skb_dequeue(&data->readq);
 483                 if (skb) {
 484                         ret = vhci_put_user(data, skb, buf, count);
 485                         if (ret < 0)
 486                                 skb_queue_head(&data->readq, skb);
 487                         else
 488                                 kfree_skb(skb);
 489                         break;
 490                 }
 491
 492                 if (file->f_flags & O_NONBLOCK) {
 493                         ret = -EAGAIN;
 494                         break;
 495                 }
 496
 497                 ret = wait_event_interruptible(data->read_wait,
 498                                                !skb_queue_empty(&data->readq));
 499                 if (ret < 0)
 500                         break;
 501         }
 502
 503         return ret;
 504 }
 505
 506 static ssize_t vhci_write(struct kiocb *iocb, struct iov_iter *from)
 507 {
 508         struct file *file = iocb->ki_filp;
 509         struct vhci_data *data = file->private_data;
 510
 511         return vhci_get_user(data, from);
 512 }
 513
 514 static __poll_t vhci_poll(struct file *file, poll_table *wait)
 515 {
 516         struct vhci_data *data = file->private_data;
 517
 518         poll_wait(file, &data->read_wait, wait);
 519
 520         if (!skb_queue_empty(&data->readq))
 521                 return EPOLLIN | EPOLLRDNORM;
 522
 523         return EPOLLOUT | EPOLLWRNORM;
 524 }
 525
 526 static void vhci_open_timeout(struct work_struct *work)
 527 {
 528         struct vhci_data *data = container_of(work, struct vhci_data,
 529                                               open_timeout.work);
 530
 531         vhci_create_device(data, amp ? HCI_AMP : HCI_PRIMARY);
 532 }
 533
 534 static int vhci_open(struct inode *inode, struct file *file)
 535 {
 536         struct vhci_data *data;
 537
 538         data = kzalloc(sizeof(struct vhci_data), GFP_KERNEL);
 539         if (!data)
 540                 return -ENOMEM;
 541
 542         skb_queue_head_init(&data->readq);
 543         init_waitqueue_head(&data->read_wait);
 544
 545         mutex_init(&data->open_mutex);
 546         INIT_DELAYED_WORK(&data->open_timeout, vhci_open_timeout);
 547         INIT_WORK(&data->suspend_work, vhci_suspend_work);
 548
 549         file->private_data = data;
 550         nonseekable_open(inode, file);
 551
 552         schedule_delayed_work(&data->open_timeout, msecs_to_jiffies(1000));
 553
 554         return 0;
 555 }
 556
 557 static int vhci_release(struct inode *inode, struct file *file)
 558 {
 559         struct vhci_data *data = file->private_data;
 560         struct hci_dev *hdev;
 561
 562         cancel_delayed_work_sync(&data->open_timeout);
 563         flush_work(&data->suspend_work);
 564
 565         hdev = data->hdev;
 566
 567         if (hdev) {
 568                 hci_unregister_dev(hdev);
 569                 hci_free_dev(hdev);
 570         }
 571
 572         skb_queue_purge(&data->readq);
 573         file->private_data = NULL;
 574         kfree(data);
 575
 576         return 0;
 577 }
 578
 579 static const struct file_operations vhci_fops = {
 580         .owner          = THIS_MODULE,
 581         .read           = vhci_read,
 582         .write_iter     = vhci_write,
 583         .poll           = vhci_poll,
 584         .open           = vhci_open,
 585         .release        = vhci_release,
 586         .llseek         = no_llseek,
 587 };
 588
 589 static struct miscdevice vhci_miscdev = {
 590         .name   = "vhci",
 591         .fops   = &vhci_fops,
 592         .minor  = VHCI_MINOR,
 593 };
 594 module_misc_device(vhci_miscdev);
 595
 596 module_param(amp, bool, 0644);
 597 MODULE_PARM_DESC(amp, "Create AMP controller device");
 598
 599 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 600 MODULE_DESCRIPTION("Bluetooth virtual HCI driver ver " VERSION);
 601 MODULE_VERSION(VERSION);
 602 MODULE_LICENSE("GPL");
 603 MODULE_ALIAS("devname:vhci");
 604 MODULE_ALIAS_MISCDEV(VHCI_MINOR);