drivers/bluetooth/virtio_bt.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002
0003 #include <linux/module.h>
0004 #include <linux/virtio.h>
0005 #include <linux/virtio_config.h>
0006 #include <linux/skbuff.h>
0007
0008 #include <uapi/linux/virtio_ids.h>
0009 #include <uapi/linux/virtio_bt.h>
0010
0011 #include <net/bluetooth/bluetooth.h>
0012 #include <net/bluetooth/hci_core.h>
0013
0014 #define VERSION "0.1"
0015
0016 enum {
0017     VIRTBT_VQ_TX,
0018     VIRTBT_VQ_RX,
0019     VIRTBT_NUM_VQS,
0020 };
0021
0022 struct virtio_bluetooth {
0023     struct virtio_device *vdev;
0024     struct virtqueue *vqs[VIRTBT_NUM_VQS];
0025     struct work_struct rx;
0026     struct hci_dev *hdev;
0027 };
0028
0029 static int virtbt_add_inbuf(struct virtio_bluetooth *vbt)
0030 {
0031     struct virtqueue *vq = vbt->vqs[VIRTBT_VQ_RX];
0032     struct scatterlist sg[1];
0033     struct sk_buff *skb;
0034     int err;
0035
0036     skb = alloc_skb(1000, GFP_KERNEL);
0037     if (!skb)
0038         return -ENOMEM;
0039
0040     sg_init_one(sg, skb->data, 1000);
0041
0042     err = virtqueue_add_inbuf(vq, sg, 1, skb, GFP_KERNEL);
0043     if (err < 0) {
0044         kfree_skb(skb);
0045         return err;
0046     }
0047
0048     return 0;
0049 }
0050
0051 static int virtbt_open(struct hci_dev *hdev)
0052 {
0053     struct virtio_bluetooth *vbt = hci_get_drvdata(hdev);
0054
0055     if (virtbt_add_inbuf(vbt) < 0)
0056         return -EIO;
0057
0058     virtqueue_kick(vbt->vqs[VIRTBT_VQ_RX]);
0059     return 0;
0060 }
0061
0062 static int virtbt_close(struct hci_dev *hdev)
0063 {
0064     struct virtio_bluetooth *vbt = hci_get_drvdata(hdev);
0065     int i;
0066
0067     cancel_work_sync(&vbt->rx);
0068
0069     for (i = 0; i < ARRAY_SIZE(vbt->vqs); i++) {
0070         struct virtqueue *vq = vbt->vqs[i];
0071         struct sk_buff *skb;
0072
0073         while ((skb = virtqueue_detach_unused_buf(vq)))
0074             kfree_skb(skb);
0075     }
0076
0077     return 0;
0078 }
0079
0080 static int virtbt_flush(struct hci_dev *hdev)
0081 {
0082     return 0;
0083 }
0084
0085 static int virtbt_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
0086 {
0087     struct virtio_bluetooth *vbt = hci_get_drvdata(hdev);
0088     struct scatterlist sg[1];
0089     int err;
0090
0091     memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
0092
0093     sg_init_one(sg, skb->data, skb->len);
0094     err = virtqueue_add_outbuf(vbt->vqs[VIRTBT_VQ_TX], sg, 1, skb,
0095                    GFP_KERNEL);
0096     if (err) {
0097         kfree_skb(skb);
0098         return err;
0099     }
0100
0101     virtqueue_kick(vbt->vqs[VIRTBT_VQ_TX]);
0102     return 0;
0103 }
0104
0105 static int virtbt_setup_zephyr(struct hci_dev *hdev)
0106 {
0107     struct sk_buff *skb;
0108
0109     /* Read Build Information */
0110     skb = __hci_cmd_sync(hdev, 0xfc08, 0, NULL, HCI_INIT_TIMEOUT);
0111     if (IS_ERR(skb))
0112         return PTR_ERR(skb);
0113
0114     bt_dev_info(hdev, "%s", (char *)(skb->data + 1));
0115
0116     hci_set_fw_info(hdev, "%s", skb->data + 1);
0117
0118     kfree_skb(skb);
0119     return 0;
0120 }
0121
0122 static int virtbt_set_bdaddr_zephyr(struct hci_dev *hdev,
0123                     const bdaddr_t *bdaddr)
0124 {
0125     struct sk_buff *skb;
0126
0127     /* Write BD_ADDR */
0128     skb = __hci_cmd_sync(hdev, 0xfc06, 6, bdaddr, HCI_INIT_TIMEOUT);
0129     if (IS_ERR(skb))
0130         return PTR_ERR(skb);
0131
0132     kfree_skb(skb);
0133     return 0;
0134 }
0135
0136 static int virtbt_setup_intel(struct hci_dev *hdev)
0137 {
0138     struct sk_buff *skb;
0139
0140     /* Intel Read Version */
0141     skb = __hci_cmd_sync(hdev, 0xfc05, 0, NULL, HCI_CMD_TIMEOUT);
0142     if (IS_ERR(skb))
0143         return PTR_ERR(skb);
0144
0145     kfree_skb(skb);
0146     return 0;
0147 }
0148
0149 static int virtbt_set_bdaddr_intel(struct hci_dev *hdev, const bdaddr_t *bdaddr)
0150 {
0151     struct sk_buff *skb;
0152
0153     /* Intel Write BD Address */
0154     skb = __hci_cmd_sync(hdev, 0xfc31, 6, bdaddr, HCI_INIT_TIMEOUT);
0155     if (IS_ERR(skb))
0156         return PTR_ERR(skb);
0157
0158     kfree_skb(skb);
0159     return 0;
0160 }
0161
0162 static int virtbt_setup_realtek(struct hci_dev *hdev)
0163 {
0164     struct sk_buff *skb;
0165
0166     /* Read ROM Version */
0167     skb = __hci_cmd_sync(hdev, 0xfc6d, 0, NULL, HCI_INIT_TIMEOUT);
0168     if (IS_ERR(skb))
0169         return PTR_ERR(skb);
0170
0171     bt_dev_info(hdev, "ROM version %u", *((__u8 *) (skb->data + 1)));
0172
0173     kfree_skb(skb);
0174     return 0;
0175 }
0176
0177 static int virtbt_shutdown_generic(struct hci_dev *hdev)
0178 {
0179     struct sk_buff *skb;
0180
0181     /* Reset */
0182     skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
0183     if (IS_ERR(skb))
0184         return PTR_ERR(skb);
0185
0186     kfree_skb(skb);
0187     return 0;
0188 }
0189
0190 static void virtbt_rx_handle(struct virtio_bluetooth *vbt, struct sk_buff *skb)
0191 {
0192     __u8 pkt_type;
0193
0194     pkt_type = *((__u8 *) skb->data);
0195     skb_pull(skb, 1);
0196
0197     switch (pkt_type) {
0198     case HCI_EVENT_PKT:
0199     case HCI_ACLDATA_PKT:
0200     case HCI_SCODATA_PKT:
0201     case HCI_ISODATA_PKT:
0202         hci_skb_pkt_type(skb) = pkt_type;
0203         hci_recv_frame(vbt->hdev, skb);
0204         break;
0205     default:
0206         kfree_skb(skb);
0207         break;
0208     }
0209 }
0210
0211 static void virtbt_rx_work(struct work_struct *work)
0212 {
0213     struct virtio_bluetooth *vbt = container_of(work,
0214                             struct virtio_bluetooth, rx);
0215     struct sk_buff *skb;
0216     unsigned int len;
0217
0218     skb = virtqueue_get_buf(vbt->vqs[VIRTBT_VQ_RX], &len);
0219     if (!skb)
0220         return;
0221
0222     skb->len = len;
0223     virtbt_rx_handle(vbt, skb);
0224
0225     if (virtbt_add_inbuf(vbt) < 0)
0226         return;
0227
0228     virtqueue_kick(vbt->vqs[VIRTBT_VQ_RX]);
0229 }
0230
0231 static void virtbt_tx_done(struct virtqueue *vq)
0232 {
0233     struct sk_buff *skb;
0234     unsigned int len;
0235
0236     while ((skb = virtqueue_get_buf(vq, &len)))
0237         kfree_skb(skb);
0238 }
0239
0240 static void virtbt_rx_done(struct virtqueue *vq)
0241 {
0242     struct virtio_bluetooth *vbt = vq->vdev->priv;
0243
0244     schedule_work(&vbt->rx);
0245 }
0246
0247 static int virtbt_probe(struct virtio_device *vdev)
0248 {
0249     vq_callback_t *callbacks[VIRTBT_NUM_VQS] = {
0250         [VIRTBT_VQ_TX] = virtbt_tx_done,
0251         [VIRTBT_VQ_RX] = virtbt_rx_done,
0252     };
0253     const char *names[VIRTBT_NUM_VQS] = {
0254         [VIRTBT_VQ_TX] = "tx",
0255         [VIRTBT_VQ_RX] = "rx",
0256     };
0257     struct virtio_bluetooth *vbt;
0258     struct hci_dev *hdev;
0259     int err;
0260     __u8 type;
0261
0262     if (!virtio_has_feature(vdev, VIRTIO_F_VERSION_1))
0263         return -ENODEV;
0264
0265     type = virtio_cread8(vdev, offsetof(struct virtio_bt_config, type));
0266
0267     switch (type) {
0268     case VIRTIO_BT_CONFIG_TYPE_PRIMARY:
0269     case VIRTIO_BT_CONFIG_TYPE_AMP:
0270         break;
0271     default:
0272         return -EINVAL;
0273     }
0274
0275     vbt = kzalloc(sizeof(*vbt), GFP_KERNEL);
0276     if (!vbt)
0277         return -ENOMEM;
0278
0279     vdev->priv = vbt;
0280     vbt->vdev = vdev;
0281
0282     INIT_WORK(&vbt->rx, virtbt_rx_work);
0283
0284     err = virtio_find_vqs(vdev, VIRTBT_NUM_VQS, vbt->vqs, callbacks,
0285                   names, NULL);
0286     if (err)
0287         return err;
0288
0289     hdev = hci_alloc_dev();
0290     if (!hdev) {
0291         err = -ENOMEM;
0292         goto failed;
0293     }
0294
0295     vbt->hdev = hdev;
0296
0297     hdev->bus = HCI_VIRTIO;
0298     hdev->dev_type = type;
0299     hci_set_drvdata(hdev, vbt);
0300
0301     hdev->open  = virtbt_open;
0302     hdev->close = virtbt_close;
0303     hdev->flush = virtbt_flush;
0304     hdev->send  = virtbt_send_frame;
0305
0306     if (virtio_has_feature(vdev, VIRTIO_BT_F_VND_HCI)) {
0307         __u16 vendor;
0308
0309         virtio_cread(vdev, struct virtio_bt_config, vendor, &vendor);
0310
0311         switch (vendor) {
0312         case VIRTIO_BT_CONFIG_VENDOR_ZEPHYR:
0313             hdev->manufacturer = 1521;
0314             hdev->setup = virtbt_setup_zephyr;
0315             hdev->shutdown = virtbt_shutdown_generic;
0316             hdev->set_bdaddr = virtbt_set_bdaddr_zephyr;
0317             break;
0318
0319         case VIRTIO_BT_CONFIG_VENDOR_INTEL:
0320             hdev->manufacturer = 2;
0321             hdev->setup = virtbt_setup_intel;
0322             hdev->shutdown = virtbt_shutdown_generic;
0323             hdev->set_bdaddr = virtbt_set_bdaddr_intel;
0324             set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
0325             set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
0326             set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);
0327             break;
0328
0329         case VIRTIO_BT_CONFIG_VENDOR_REALTEK:
0330             hdev->manufacturer = 93;
0331             hdev->setup = virtbt_setup_realtek;
0332             hdev->shutdown = virtbt_shutdown_generic;
0333             set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
0334             set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);
0335             break;
0336         }
0337     }
0338
0339     if (virtio_has_feature(vdev, VIRTIO_BT_F_MSFT_EXT)) {
0340         __u16 msft_opcode;
0341
0342         virtio_cread(vdev, struct virtio_bt_config,
0343                  msft_opcode, &msft_opcode);
0344
0345         hci_set_msft_opcode(hdev, msft_opcode);
0346     }
0347
0348     if (virtio_has_feature(vdev, VIRTIO_BT_F_AOSP_EXT))
0349         hci_set_aosp_capable(hdev);
0350
0351     if (hci_register_dev(hdev) < 0) {
0352         hci_free_dev(hdev);
0353         err = -EBUSY;
0354         goto failed;
0355     }
0356
0357     return 0;
0358
0359 failed:
0360     vdev->config->del_vqs(vdev);
0361     return err;
0362 }
0363
0364 static void virtbt_remove(struct virtio_device *vdev)
0365 {
0366     struct virtio_bluetooth *vbt = vdev->priv;
0367     struct hci_dev *hdev = vbt->hdev;
0368
0369     hci_unregister_dev(hdev);
0370     virtio_reset_device(vdev);
0371
0372     hci_free_dev(hdev);
0373     vbt->hdev = NULL;
0374
0375     vdev->config->del_vqs(vdev);
0376     kfree(vbt);
0377 }
0378
0379 static struct virtio_device_id virtbt_table[] = {
0380     { VIRTIO_ID_BT, VIRTIO_DEV_ANY_ID },
0381     { 0 },
0382 };
0383
0384 MODULE_DEVICE_TABLE(virtio, virtbt_table);
0385
0386 static const unsigned int virtbt_features[] = {
0387     VIRTIO_BT_F_VND_HCI,
0388     VIRTIO_BT_F_MSFT_EXT,
0389     VIRTIO_BT_F_AOSP_EXT,
0390 };
0391
0392 static struct virtio_driver virtbt_driver = {
0393     .driver.name         = KBUILD_MODNAME,
0394     .driver.owner        = THIS_MODULE,
0395     .feature_table       = virtbt_features,
0396     .feature_table_size  = ARRAY_SIZE(virtbt_features),
0397     .id_table            = virtbt_table,
0398     .probe               = virtbt_probe,
0399     .remove              = virtbt_remove,
0400 };
0401
0402 module_virtio_driver(virtbt_driver);
0403
0404 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
0405 MODULE_DESCRIPTION("Generic Bluetooth VIRTIO driver ver " VERSION);
0406 MODULE_VERSION(VERSION);
0407 MODULE_LICENSE("GPL");