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"); 402