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