Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

Bluetooth: Add support for virtio transport driver

This adds support for Bluetooth HCI transport over virtio.

Signed-off-by: Marcel Holtmann <marcel@holtmann.org>
Signed-off-by: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

+445
+10
drivers/bluetooth/Kconfig
··· 425 425 Say Y here to compile support for HCI over Redpine into the 426 426 kernel or say M to compile as a module. 427 427 428 + config BT_VIRTIO 429 + tristate "Virtio Bluetooth driver" 430 + depends on VIRTIO 431 + help 432 + Virtio Bluetooth support driver. 433 + This driver supports Virtio Bluetooth devices. 434 + 435 + Say Y here to compile support for HCI over Virtio into the 436 + kernel or say M to compile as a module. 437 + 428 438 endmenu
+2
drivers/bluetooth/Makefile
··· 26 26 obj-$(CONFIG_BT_RTL) += btrtl.o 27 27 obj-$(CONFIG_BT_QCA) += btqca.o 28 28 29 + obj-$(CONFIG_BT_VIRTIO) += virtio_bt.o 30 + 29 31 obj-$(CONFIG_BT_HCIUART_NOKIA) += hci_nokia.o 30 32 31 33 obj-$(CONFIG_BT_HCIRSI) += btrsi.o
+401
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");
+31
include/uapi/linux/virtio_bt.h
··· 1 + /* SPDX-License-Identifier: BSD-3-Clause */ 2 + 3 + #ifndef _UAPI_LINUX_VIRTIO_BT_H 4 + #define _UAPI_LINUX_VIRTIO_BT_H 5 + 6 + #include <linux/virtio_types.h> 7 + 8 + /* Feature bits */ 9 + #define VIRTIO_BT_F_VND_HCI 0 /* Indicates vendor command support */ 10 + #define VIRTIO_BT_F_MSFT_EXT 1 /* Indicates MSFT vendor support */ 11 + #define VIRTIO_BT_F_AOSP_EXT 2 /* Indicates AOSP vendor support */ 12 + 13 + enum virtio_bt_config_type { 14 + VIRTIO_BT_CONFIG_TYPE_PRIMARY = 0, 15 + VIRTIO_BT_CONFIG_TYPE_AMP = 1, 16 + }; 17 + 18 + enum virtio_bt_config_vendor { 19 + VIRTIO_BT_CONFIG_VENDOR_NONE = 0, 20 + VIRTIO_BT_CONFIG_VENDOR_ZEPHYR = 1, 21 + VIRTIO_BT_CONFIG_VENDOR_INTEL = 2, 22 + VIRTIO_BT_CONFIG_VENDOR_REALTEK = 3, 23 + }; 24 + 25 + struct virtio_bt_config { 26 + __u8 type; 27 + __u16 vendor; 28 + __u16 msft_opcode; 29 + } __attribute__((packed)); 30 + 31 + #endif /* _UAPI_LINUX_VIRTIO_BT_H */
+1
include/uapi/linux/virtio_ids.h
··· 53 53 #define VIRTIO_ID_MEM 24 /* virtio mem */ 54 54 #define VIRTIO_ID_FS 26 /* virtio filesystem */ 55 55 #define VIRTIO_ID_PMEM 27 /* virtio pmem */ 56 + #define VIRTIO_ID_BT 28 /* virtio bluetooth */ 56 57 #define VIRTIO_ID_MAC80211_HWSIM 29 /* virtio mac80211-hwsim */ 57 58 58 59 #endif /* _LINUX_VIRTIO_IDS_H */