drivers/bluetooth/virtio_bt.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2
   3 #include <linux/module.h>
   4 #include <linux/virtio.h>
   5 #include <linux/virtio_config.h>
   6 #include <linux/skbuff.h>
   7
   8 #include <uapi/linux/virtio_ids.h>
   9 #include <uapi/linux/virtio_bt.h>
  10
  11 #include <net/bluetooth/bluetooth.h>
  12 #include <net/bluetooth/hci_core.h>
  13
  14 #define VERSION "0.1"
  15
  16 enum {
  17         VIRTBT_VQ_TX,
  18         VIRTBT_VQ_RX,
  19         VIRTBT_NUM_VQS,
  20 };
  21
  22 struct virtio_bluetooth {
  23         struct virtio_device *vdev;
  24         struct virtqueue *vqs[VIRTBT_NUM_VQS];
  25         struct work_struct rx;
  26         struct hci_dev *hdev;
  27 };
  28
  29 static int virtbt_add_inbuf(struct virtio_bluetooth *vbt)
  30 {
  31         struct virtqueue *vq = vbt->vqs[VIRTBT_VQ_RX];
  32         struct scatterlist sg[1];
  33         struct sk_buff *skb;
  34         int err;
  35
  36         skb = alloc_skb(1000, GFP_KERNEL);
  37         if (!skb)
  38                 return -ENOMEM;
  39
  40         sg_init_one(sg, skb->data, 1000);
  41
  42         err = virtqueue_add_inbuf(vq, sg, 1, skb, GFP_KERNEL);
  43         if (err < 0) {
  44                 kfree_skb(skb);
  45                 return err;
  46         }
  47
  48         return 0;
  49 }
  50
  51 static int virtbt_open(struct hci_dev *hdev)
  52 {
  53         return 0;
  54 }
  55
  56 static int virtbt_open_vdev(struct virtio_bluetooth *vbt)
  57 {
  58         if (virtbt_add_inbuf(vbt) < 0)
  59                 return -EIO;
  60
  61         virtqueue_kick(vbt->vqs[VIRTBT_VQ_RX]);
  62         return 0;
  63 }
  64
  65 static int virtbt_close(struct hci_dev *hdev)
  66 {
  67         return 0;
  68 }
  69
  70 static int virtbt_close_vdev(struct virtio_bluetooth *vbt)
  71 {
  72         int i;
  73
  74         cancel_work_sync(&vbt->rx);
  75
  76         for (i = 0; i < ARRAY_SIZE(vbt->vqs); i++) {
  77                 struct virtqueue *vq = vbt->vqs[i];
  78                 struct sk_buff *skb;
  79
  80                 while ((skb = virtqueue_detach_unused_buf(vq)))
  81                         kfree_skb(skb);
  82         }
  83
  84         return 0;
  85 }
  86
  87 static int virtbt_flush(struct hci_dev *hdev)
  88 {
  89         return 0;
  90 }
  91
  92 static int virtbt_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
  93 {
  94         struct virtio_bluetooth *vbt = hci_get_drvdata(hdev);
  95         struct scatterlist sg[1];
  96         int err;
  97
  98         memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
  99
 100         sg_init_one(sg, skb->data, skb->len);
 101         err = virtqueue_add_outbuf(vbt->vqs[VIRTBT_VQ_TX], sg, 1, skb,
 102                                    GFP_KERNEL);
 103         if (err) {
 104                 kfree_skb(skb);
 105                 return err;
 106         }
 107
 108         virtqueue_kick(vbt->vqs[VIRTBT_VQ_TX]);
 109         return 0;
 110 }
 111
 112 static int virtbt_setup_zephyr(struct hci_dev *hdev)
 113 {
 114         struct sk_buff *skb;
 115
 116         /* Read Build Information */
 117         skb = __hci_cmd_sync(hdev, 0xfc08, 0, NULL, HCI_INIT_TIMEOUT);
 118         if (IS_ERR(skb))
 119                 return PTR_ERR(skb);
 120
 121         bt_dev_info(hdev, "%s", (char *)(skb->data + 1));
 122
 123         hci_set_fw_info(hdev, "%s", skb->data + 1);
 124
 125         kfree_skb(skb);
 126         return 0;
 127 }
 128
 129 static int virtbt_set_bdaddr_zephyr(struct hci_dev *hdev,
 130                                     const bdaddr_t *bdaddr)
 131 {
 132         struct sk_buff *skb;
 133
 134         /* Write BD_ADDR */
 135         skb = __hci_cmd_sync(hdev, 0xfc06, 6, bdaddr, HCI_INIT_TIMEOUT);
 136         if (IS_ERR(skb))
 137                 return PTR_ERR(skb);
 138
 139         kfree_skb(skb);
 140         return 0;
 141 }
 142
 143 static int virtbt_setup_intel(struct hci_dev *hdev)
 144 {
 145         struct sk_buff *skb;
 146
 147         /* Intel Read Version */
 148         skb = __hci_cmd_sync(hdev, 0xfc05, 0, NULL, HCI_CMD_TIMEOUT);
 149         if (IS_ERR(skb))
 150                 return PTR_ERR(skb);
 151
 152         kfree_skb(skb);
 153         return 0;
 154 }
 155
 156 static int virtbt_set_bdaddr_intel(struct hci_dev *hdev, const bdaddr_t *bdaddr)
 157 {
 158         struct sk_buff *skb;
 159
 160         /* Intel Write BD Address */
 161         skb = __hci_cmd_sync(hdev, 0xfc31, 6, bdaddr, HCI_INIT_TIMEOUT);
 162         if (IS_ERR(skb))
 163                 return PTR_ERR(skb);
 164
 165         kfree_skb(skb);
 166         return 0;
 167 }
 168
 169 static int virtbt_setup_realtek(struct hci_dev *hdev)
 170 {
 171         struct sk_buff *skb;
 172
 173         /* Read ROM Version */
 174         skb = __hci_cmd_sync(hdev, 0xfc6d, 0, NULL, HCI_INIT_TIMEOUT);
 175         if (IS_ERR(skb))
 176                 return PTR_ERR(skb);
 177
 178         bt_dev_info(hdev, "ROM version %u", *((__u8 *) (skb->data + 1)));
 179
 180         kfree_skb(skb);
 181         return 0;
 182 }
 183
 184 static int virtbt_shutdown_generic(struct hci_dev *hdev)
 185 {
 186         struct sk_buff *skb;
 187
 188         /* Reset */
 189         skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
 190         if (IS_ERR(skb))
 191                 return PTR_ERR(skb);
 192
 193         kfree_skb(skb);
 194         return 0;
 195 }
 196
 197 static void virtbt_rx_handle(struct virtio_bluetooth *vbt, struct sk_buff *skb)
 198 {
 199         __u8 pkt_type;
 200
 201         pkt_type = *((__u8 *) skb->data);
 202         skb_pull(skb, 1);
 203
 204         switch (pkt_type) {
 205         case HCI_EVENT_PKT:
 206         case HCI_ACLDATA_PKT:
 207         case HCI_SCODATA_PKT:
 208         case HCI_ISODATA_PKT:
 209                 hci_skb_pkt_type(skb) = pkt_type;
 210                 hci_recv_frame(vbt->hdev, skb);
 211                 break;
 212         default:
 213                 kfree_skb(skb);
 214                 break;
 215         }
 216 }
 217
 218 static void virtbt_rx_work(struct work_struct *work)
 219 {
 220         struct virtio_bluetooth *vbt = container_of(work,
 221                                                     struct virtio_bluetooth, rx);
 222         struct sk_buff *skb;
 223         unsigned int len;
 224
 225         skb = virtqueue_get_buf(vbt->vqs[VIRTBT_VQ_RX], &len);
 226         if (!skb)
 227                 return;
 228
 229         skb_put(skb, len);
 230         virtbt_rx_handle(vbt, skb);
 231
 232         if (virtbt_add_inbuf(vbt) < 0)
 233                 return;
 234
 235         virtqueue_kick(vbt->vqs[VIRTBT_VQ_RX]);
 236 }
 237
 238 static void virtbt_tx_done(struct virtqueue *vq)
 239 {
 240         struct sk_buff *skb;
 241         unsigned int len;
 242
 243         while ((skb = virtqueue_get_buf(vq, &len)))
 244                 kfree_skb(skb);
 245 }
 246
 247 static void virtbt_rx_done(struct virtqueue *vq)
 248 {
 249         struct virtio_bluetooth *vbt = vq->vdev->priv;
 250
 251         schedule_work(&vbt->rx);
 252 }
 253
 254 static int virtbt_probe(struct virtio_device *vdev)
 255 {
 256         vq_callback_t *callbacks[VIRTBT_NUM_VQS] = {
 257                 [VIRTBT_VQ_TX] = virtbt_tx_done,
 258                 [VIRTBT_VQ_RX] = virtbt_rx_done,
 259         };
 260         const char *names[VIRTBT_NUM_VQS] = {
 261                 [VIRTBT_VQ_TX] = "tx",
 262                 [VIRTBT_VQ_RX] = "rx",
 263         };
 264         struct virtio_bluetooth *vbt;
 265         struct hci_dev *hdev;
 266         int err;
 267         __u8 type;
 268
 269         if (!virtio_has_feature(vdev, VIRTIO_F_VERSION_1))
 270                 return -ENODEV;
 271
 272         type = virtio_cread8(vdev, offsetof(struct virtio_bt_config, type));
 273
 274         switch (type) {
 275         case VIRTIO_BT_CONFIG_TYPE_PRIMARY:
 276         case VIRTIO_BT_CONFIG_TYPE_AMP:
 277                 break;
 278         default:
 279                 return -EINVAL;
 280         }
 281
 282         vbt = kzalloc(sizeof(*vbt), GFP_KERNEL);
 283         if (!vbt)
 284                 return -ENOMEM;
 285
 286         vdev->priv = vbt;
 287         vbt->vdev = vdev;
 288
 289         INIT_WORK(&vbt->rx, virtbt_rx_work);
 290
 291         err = virtio_find_vqs(vdev, VIRTBT_NUM_VQS, vbt->vqs, callbacks,
 292                               names, NULL);
 293         if (err)
 294                 return err;
 295
 296         hdev = hci_alloc_dev();
 297         if (!hdev) {
 298                 err = -ENOMEM;
 299                 goto failed;
 300         }
 301
 302         vbt->hdev = hdev;
 303
 304         hdev->bus = HCI_VIRTIO;
 305         hdev->dev_type = type;
 306         hci_set_drvdata(hdev, vbt);
 307
 308         hdev->open  = virtbt_open;
 309         hdev->close = virtbt_close;
 310         hdev->flush = virtbt_flush;
 311         hdev->send  = virtbt_send_frame;
 312
 313         if (virtio_has_feature(vdev, VIRTIO_BT_F_VND_HCI)) {
 314                 __u16 vendor;
 315
 316                 if (virtio_has_feature(vdev, VIRTIO_BT_F_CONFIG_V2))
 317                         virtio_cread(vdev, struct virtio_bt_config_v2,
 318                                      vendor, &vendor);
 319                 else
 320                         virtio_cread(vdev, struct virtio_bt_config,
 321                                      vendor, &vendor);
 322
 323                 switch (vendor) {
 324                 case VIRTIO_BT_CONFIG_VENDOR_ZEPHYR:
 325                         hdev->manufacturer = 1521;
 326                         hdev->setup = virtbt_setup_zephyr;
 327                         hdev->shutdown = virtbt_shutdown_generic;
 328                         hdev->set_bdaddr = virtbt_set_bdaddr_zephyr;
 329                         break;
 330
 331                 case VIRTIO_BT_CONFIG_VENDOR_INTEL:
 332                         hdev->manufacturer = 2;
 333                         hdev->setup = virtbt_setup_intel;
 334                         hdev->shutdown = virtbt_shutdown_generic;
 335                         hdev->set_bdaddr = virtbt_set_bdaddr_intel;
 336                         set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
 337                         set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
 338                         set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);
 339                         break;
 340
 341                 case VIRTIO_BT_CONFIG_VENDOR_REALTEK:
 342                         hdev->manufacturer = 93;
 343                         hdev->setup = virtbt_setup_realtek;
 344                         hdev->shutdown = virtbt_shutdown_generic;
 345                         set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
 346                         set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);
 347                         break;
 348                 }
 349         }
 350
 351         if (virtio_has_feature(vdev, VIRTIO_BT_F_MSFT_EXT)) {
 352                 __u16 msft_opcode;
 353
 354                 if (virtio_has_feature(vdev, VIRTIO_BT_F_CONFIG_V2))
 355                         virtio_cread(vdev, struct virtio_bt_config_v2,
 356                                      msft_opcode, &msft_opcode);
 357                 else
 358                         virtio_cread(vdev, struct virtio_bt_config,
 359                                      msft_opcode, &msft_opcode);
 360
 361                 hci_set_msft_opcode(hdev, msft_opcode);
 362         }
 363
 364         if (virtio_has_feature(vdev, VIRTIO_BT_F_AOSP_EXT))
 365                 hci_set_aosp_capable(hdev);
 366
 367         if (hci_register_dev(hdev) < 0) {
 368                 hci_free_dev(hdev);
 369                 err = -EBUSY;
 370                 goto failed;
 371         }
 372
 373         virtio_device_ready(vdev);
 374         err = virtbt_open_vdev(vbt);
 375         if (err)
 376                 goto open_failed;
 377
 378         return 0;
 379
 380 open_failed:
 381         hci_free_dev(hdev);
 382 failed:
 383         vdev->config->del_vqs(vdev);
 384         return err;
 385 }
 386
 387 static void virtbt_remove(struct virtio_device *vdev)
 388 {
 389         struct virtio_bluetooth *vbt = vdev->priv;
 390         struct hci_dev *hdev = vbt->hdev;
 391
 392         hci_unregister_dev(hdev);
 393         virtio_reset_device(vdev);
 394         virtbt_close_vdev(vbt);
 395
 396         hci_free_dev(hdev);
 397         vbt->hdev = NULL;
 398
 399         vdev->config->del_vqs(vdev);
 400         kfree(vbt);
 401 }
 402
 403 static struct virtio_device_id virtbt_table[] = {
 404         { VIRTIO_ID_BT, VIRTIO_DEV_ANY_ID },
 405         { 0 },
 406 };
 407
 408 MODULE_DEVICE_TABLE(virtio, virtbt_table);
 409
 410 static const unsigned int virtbt_features[] = {
 411         VIRTIO_BT_F_VND_HCI,
 412         VIRTIO_BT_F_MSFT_EXT,
 413         VIRTIO_BT_F_AOSP_EXT,
 414         VIRTIO_BT_F_CONFIG_V2,
 415 };
 416
 417 static struct virtio_driver virtbt_driver = {
 418         .driver.name         = KBUILD_MODNAME,
 419         .driver.owner        = THIS_MODULE,
 420         .feature_table       = virtbt_features,
 421         .feature_table_size  = ARRAY_SIZE(virtbt_features),
 422         .id_table            = virtbt_table,
 423         .probe               = virtbt_probe,
 424         .remove              = virtbt_remove,
 425 };
 426
 427 module_virtio_driver(virtbt_driver);
 428
 429 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 430 MODULE_DESCRIPTION("Generic Bluetooth VIRTIO driver ver " VERSION);
 431 MODULE_VERSION(VERSION);
 432 MODULE_LICENSE("GPL");