1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2021 Beckhoff Automation GmbH & Co. KG 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer 12 * in this position and unchanged. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 /* 31 * virtio input device emulation. 32 */ 33 34 #include <sys/cdefs.h> 35 #include <sys/param.h> 36 #ifndef WITHOUT_CAPSICUM 37 #include <sys/capsicum.h> 38 39 #include <capsicum_helpers.h> 40 #endif 41 #include <sys/ioctl.h> 42 #include <sys/linker_set.h> 43 #include <sys/uio.h> 44 45 #include <dev/evdev/input.h> 46 47 #include <assert.h> 48 #include <err.h> 49 #include <errno.h> 50 #include <fcntl.h> 51 #include <pthread.h> 52 #include <stddef.h> 53 #include <stdio.h> 54 #include <stdlib.h> 55 #include <string.h> 56 #include <sysexits.h> 57 #include <unistd.h> 58 59 #include "bhyverun.h" 60 #include "config.h" 61 #include "debug.h" 62 #include "mevent.h" 63 #include "pci_emul.h" 64 #include "virtio.h" 65 66 #define VTINPUT_RINGSZ 64 67 68 #define VTINPUT_MAX_PKT_LEN 10 69 70 /* 71 * Queue definitions. 72 */ 73 #define VTINPUT_EVENTQ 0 74 #define VTINPUT_STATUSQ 1 75 76 #define VTINPUT_MAXQ 2 77 78 static int pci_vtinput_debug; 79 #define DPRINTF(params) \ 80 if (pci_vtinput_debug) \ 81 PRINTLN params 82 #define WPRINTF(params) PRINTLN params 83 84 enum vtinput_config_select { 85 VTINPUT_CFG_UNSET = 0x00, 86 VTINPUT_CFG_ID_NAME = 0x01, 87 VTINPUT_CFG_ID_SERIAL = 0x02, 88 VTINPUT_CFG_ID_DEVIDS = 0x03, 89 VTINPUT_CFG_PROP_BITS = 0x10, 90 VTINPUT_CFG_EV_BITS = 0x11, 91 VTINPUT_CFG_ABS_INFO = 0x12 92 }; 93 94 struct vtinput_absinfo { 95 uint32_t min; 96 uint32_t max; 97 uint32_t fuzz; 98 uint32_t flat; 99 uint32_t res; 100 } __packed; 101 102 struct vtinput_devids { 103 uint16_t bustype; 104 uint16_t vendor; 105 uint16_t product; 106 uint16_t version; 107 } __packed; 108 109 struct vtinput_config { 110 uint8_t select; 111 uint8_t subsel; 112 uint8_t size; 113 uint8_t reserved[5]; 114 union { 115 char string[128]; 116 uint8_t bitmap[128]; 117 struct vtinput_absinfo abs; 118 struct vtinput_devids ids; 119 } u; 120 } __packed; 121 122 struct vtinput_event { 123 uint16_t type; 124 uint16_t code; 125 uint32_t value; 126 } __packed; 127 128 struct vtinput_event_elem { 129 struct vtinput_event event; 130 struct iovec iov; 131 uint16_t idx; 132 }; 133 134 struct vtinput_eventqueue { 135 struct vtinput_event_elem *events; 136 uint32_t size; 137 uint32_t idx; 138 }; 139 140 /* 141 * Per-device softc 142 */ 143 struct pci_vtinput_softc { 144 struct virtio_softc vsc_vs; 145 struct vqueue_info vsc_queues[VTINPUT_MAXQ]; 146 pthread_mutex_t vsc_mtx; 147 const char *vsc_evdev; 148 int vsc_fd; 149 struct vtinput_config vsc_config; 150 int vsc_config_valid; 151 struct mevent *vsc_evp; 152 struct vtinput_eventqueue vsc_eventqueue; 153 }; 154 155 static void pci_vtinput_reset(void *); 156 static int pci_vtinput_cfgread(void *, int, int, uint32_t *); 157 static int pci_vtinput_cfgwrite(void *, int, int, uint32_t); 158 159 static struct virtio_consts vtinput_vi_consts = { 160 .vc_name = "vtinput", 161 .vc_nvq = VTINPUT_MAXQ, 162 .vc_cfgsize = sizeof(struct vtinput_config), 163 .vc_reset = pci_vtinput_reset, 164 .vc_cfgread = pci_vtinput_cfgread, 165 .vc_cfgwrite = pci_vtinput_cfgwrite, 166 .vc_hv_caps = 0, 167 }; 168 169 static void 170 pci_vtinput_reset(void *vsc) 171 { 172 struct pci_vtinput_softc *sc = vsc; 173 174 DPRINTF(("%s: device reset requested", __func__)); 175 vi_reset_dev(&sc->vsc_vs); 176 } 177 178 static void 179 pci_vtinput_notify_eventq(void *vsc __unused, struct vqueue_info *vq __unused) 180 { 181 DPRINTF(("%s", __func__)); 182 } 183 184 static void 185 pci_vtinput_notify_statusq(void *vsc, struct vqueue_info *vq) 186 { 187 struct pci_vtinput_softc *sc = vsc; 188 189 while (vq_has_descs(vq)) { 190 /* get descriptor chain */ 191 struct iovec iov; 192 struct vi_req req; 193 const int n = vq_getchain(vq, &iov, 1, &req); 194 if (n <= 0) { 195 WPRINTF(("%s: invalid descriptor: %d", __func__, n)); 196 return; 197 } 198 199 /* get event */ 200 struct vtinput_event event; 201 memcpy(&event, iov.iov_base, sizeof(event)); 202 203 /* 204 * on multi touch devices: 205 * - host send EV_MSC to guest 206 * - guest sends EV_MSC back to host 207 * - host writes EV_MSC to evdev 208 * - evdev saves EV_MSC in it's event buffer 209 * - host receives an extra EV_MSC by reading the evdev event 210 * buffer 211 * - frames become larger and larger 212 * avoid endless loops by ignoring EV_MSC 213 */ 214 if (event.type == EV_MSC) { 215 vq_relchain(vq, req.idx, sizeof(event)); 216 continue; 217 } 218 219 /* send event to evdev */ 220 struct input_event host_event; 221 host_event.type = event.type; 222 host_event.code = event.code; 223 host_event.value = event.value; 224 if (gettimeofday(&host_event.time, NULL) != 0) { 225 WPRINTF(("%s: failed gettimeofday", __func__)); 226 } 227 if (write(sc->vsc_fd, &host_event, sizeof(host_event)) == -1) { 228 WPRINTF(("%s: failed to write host_event", __func__)); 229 } 230 231 vq_relchain(vq, req.idx, sizeof(event)); 232 } 233 vq_endchains(vq, 1); 234 } 235 236 static int 237 pci_vtinput_get_bitmap(struct pci_vtinput_softc *sc, int cmd, int count) 238 { 239 if (count <= 0 || !sc) { 240 return (-1); 241 } 242 243 /* query bitmap */ 244 memset(sc->vsc_config.u.bitmap, 0, sizeof(sc->vsc_config.u.bitmap)); 245 if (ioctl(sc->vsc_fd, cmd, sc->vsc_config.u.bitmap) < 0) { 246 return (-1); 247 } 248 249 /* get number of set bytes in bitmap */ 250 for (int i = count - 1; i >= 0; i--) { 251 if (sc->vsc_config.u.bitmap[i]) { 252 return i + 1; 253 } 254 } 255 256 return (-1); 257 } 258 259 static int 260 pci_vtinput_read_config_id_name(struct pci_vtinput_softc *sc) 261 { 262 char name[128]; 263 if (ioctl(sc->vsc_fd, EVIOCGNAME(sizeof(name) - 1), name) < 0) { 264 return (1); 265 } 266 267 memcpy(sc->vsc_config.u.string, name, sizeof(name)); 268 sc->vsc_config.size = strnlen(name, sizeof(name)); 269 270 return (0); 271 } 272 273 static int 274 pci_vtinput_read_config_id_serial(struct pci_vtinput_softc *sc) 275 { 276 /* serial isn't supported */ 277 sc->vsc_config.size = 0; 278 279 return (0); 280 } 281 282 static int 283 pci_vtinput_read_config_id_devids(struct pci_vtinput_softc *sc) 284 { 285 struct input_id devids; 286 if (ioctl(sc->vsc_fd, EVIOCGID, &devids)) { 287 return (1); 288 } 289 290 sc->vsc_config.u.ids.bustype = devids.bustype; 291 sc->vsc_config.u.ids.vendor = devids.vendor; 292 sc->vsc_config.u.ids.product = devids.product; 293 sc->vsc_config.u.ids.version = devids.version; 294 sc->vsc_config.size = sizeof(struct vtinput_devids); 295 296 return (0); 297 } 298 299 static int 300 pci_vtinput_read_config_prop_bits(struct pci_vtinput_softc *sc) 301 { 302 /* 303 * Evdev bitmap countains 1 bit per count. Additionally evdev bitmaps 304 * are arrays of longs instead of chars. Calculate how many longs are 305 * required for evdev bitmap. Multiply that with sizeof(long) to get the 306 * number of elements. 307 */ 308 const int count = howmany(INPUT_PROP_CNT, sizeof(long) * 8) * 309 sizeof(long); 310 const unsigned int cmd = EVIOCGPROP(count); 311 const int size = pci_vtinput_get_bitmap(sc, cmd, count); 312 if (size <= 0) { 313 return (1); 314 } 315 316 sc->vsc_config.size = size; 317 318 return (0); 319 } 320 321 static int 322 pci_vtinput_read_config_ev_bits(struct pci_vtinput_softc *sc, uint8_t type) 323 { 324 int count; 325 326 switch (type) { 327 case EV_KEY: 328 count = KEY_CNT; 329 break; 330 case EV_REL: 331 count = REL_CNT; 332 break; 333 case EV_ABS: 334 count = ABS_CNT; 335 break; 336 case EV_MSC: 337 count = MSC_CNT; 338 break; 339 case EV_SW: 340 count = SW_CNT; 341 break; 342 case EV_LED: 343 count = LED_CNT; 344 break; 345 default: 346 return (1); 347 } 348 349 /* 350 * Evdev bitmap countains 1 bit per count. Additionally evdev bitmaps 351 * are arrays of longs instead of chars. Calculate how many longs are 352 * required for evdev bitmap. Multiply that with sizeof(long) to get the 353 * number of elements. 354 */ 355 count = howmany(count, sizeof(long) * 8) * sizeof(long); 356 const unsigned int cmd = EVIOCGBIT(sc->vsc_config.subsel, count); 357 const int size = pci_vtinput_get_bitmap(sc, cmd, count); 358 if (size <= 0) { 359 return (1); 360 } 361 362 sc->vsc_config.size = size; 363 364 return (0); 365 } 366 367 static int 368 pci_vtinput_read_config_abs_info(struct pci_vtinput_softc *sc) 369 { 370 /* check if evdev has EV_ABS */ 371 if (!pci_vtinput_read_config_ev_bits(sc, EV_ABS)) { 372 return (1); 373 } 374 375 /* get abs information */ 376 struct input_absinfo abs; 377 if (ioctl(sc->vsc_fd, EVIOCGABS(sc->vsc_config.subsel), &abs) < 0) { 378 return (1); 379 } 380 381 /* save abs information */ 382 sc->vsc_config.u.abs.min = abs.minimum; 383 sc->vsc_config.u.abs.max = abs.maximum; 384 sc->vsc_config.u.abs.fuzz = abs.fuzz; 385 sc->vsc_config.u.abs.flat = abs.flat; 386 sc->vsc_config.u.abs.res = abs.resolution; 387 sc->vsc_config.size = sizeof(struct vtinput_absinfo); 388 389 return (0); 390 } 391 392 static int 393 pci_vtinput_read_config(struct pci_vtinput_softc *sc) 394 { 395 switch (sc->vsc_config.select) { 396 case VTINPUT_CFG_UNSET: 397 return (0); 398 case VTINPUT_CFG_ID_NAME: 399 return pci_vtinput_read_config_id_name(sc); 400 case VTINPUT_CFG_ID_SERIAL: 401 return pci_vtinput_read_config_id_serial(sc); 402 case VTINPUT_CFG_ID_DEVIDS: 403 return pci_vtinput_read_config_id_devids(sc); 404 case VTINPUT_CFG_PROP_BITS: 405 return pci_vtinput_read_config_prop_bits(sc); 406 case VTINPUT_CFG_EV_BITS: 407 return pci_vtinput_read_config_ev_bits( 408 sc, sc->vsc_config.subsel); 409 case VTINPUT_CFG_ABS_INFO: 410 return pci_vtinput_read_config_abs_info(sc); 411 default: 412 return (1); 413 } 414 } 415 416 static int 417 pci_vtinput_cfgread(void *vsc, int offset, int size, uint32_t *retval) 418 { 419 struct pci_vtinput_softc *sc = vsc; 420 421 /* check for valid offset and size */ 422 if (offset + size > (int)sizeof(struct vtinput_config)) { 423 WPRINTF(("%s: read to invalid offset/size %d/%d", __func__, 424 offset, size)); 425 memset(retval, 0, size); 426 return (0); 427 } 428 429 /* read new config values, if select and subsel changed. */ 430 if (!sc->vsc_config_valid) { 431 if (pci_vtinput_read_config(sc) != 0) { 432 DPRINTF(("%s: could not read config %d/%d", __func__, 433 sc->vsc_config.select, sc->vsc_config.subsel)); 434 memset(retval, 0, size); 435 return (0); 436 } 437 sc->vsc_config_valid = 1; 438 } 439 440 uint8_t *ptr = (uint8_t *)&sc->vsc_config; 441 memcpy(retval, ptr + offset, size); 442 443 return (0); 444 } 445 446 static int 447 pci_vtinput_cfgwrite(void *vsc, int offset, int size, uint32_t value) 448 { 449 struct pci_vtinput_softc *sc = vsc; 450 451 /* guest can only write to select and subsel fields */ 452 if (offset + size > 2) { 453 WPRINTF(("%s: write to readonly reg %d", __func__, offset)); 454 return (1); 455 } 456 457 /* copy value into config */ 458 uint8_t *ptr = (uint8_t *)&sc->vsc_config; 459 memcpy(ptr + offset, &value, size); 460 461 /* select/subsel changed, query new config on next cfgread */ 462 sc->vsc_config_valid = 0; 463 464 return (0); 465 } 466 467 static int 468 vtinput_eventqueue_add_event( 469 struct vtinput_eventqueue *queue, struct input_event *e) 470 { 471 /* check if queue is full */ 472 if (queue->idx >= queue->size) { 473 /* alloc new elements for queue */ 474 const uint32_t newSize = queue->idx; 475 void *newPtr = realloc(queue->events, 476 queue->size * sizeof(struct vtinput_event_elem)); 477 if (newPtr == NULL) { 478 WPRINTF(("%s: realloc memory for eventqueue failed!", 479 __func__)); 480 return (1); 481 } 482 queue->events = newPtr; 483 queue->size = newSize; 484 } 485 486 /* save event */ 487 struct vtinput_event *event = &queue->events[queue->idx].event; 488 event->type = e->type; 489 event->code = e->code; 490 event->value = e->value; 491 queue->idx++; 492 493 return (0); 494 } 495 496 static void 497 vtinput_eventqueue_clear(struct vtinput_eventqueue *queue) 498 { 499 /* just reset index to clear queue */ 500 queue->idx = 0; 501 } 502 503 static void 504 vtinput_eventqueue_send_events( 505 struct vtinput_eventqueue *queue, struct vqueue_info *vq) 506 { 507 /* 508 * First iteration through eventqueue: 509 * Get descriptor chains. 510 */ 511 for (uint32_t i = 0; i < queue->idx; ++i) { 512 /* get descriptor */ 513 if (!vq_has_descs(vq)) { 514 /* 515 * We don't have enough descriptors for all events. 516 * Return chains back to guest. 517 */ 518 vq_retchains(vq, i); 519 WPRINTF(( 520 "%s: not enough available descriptors, dropping %d events", 521 __func__, queue->idx)); 522 goto done; 523 } 524 525 /* get descriptor chain */ 526 struct iovec iov; 527 struct vi_req req; 528 const int n = vq_getchain(vq, &iov, 1, &req); 529 if (n <= 0) { 530 WPRINTF(("%s: invalid descriptor: %d", __func__, n)); 531 return; 532 } 533 if (n != 1) { 534 WPRINTF( 535 ("%s: invalid number of descriptors in chain: %d", 536 __func__, n)); 537 /* release invalid chain */ 538 vq_relchain(vq, req.idx, 0); 539 return; 540 } 541 if (iov.iov_len < sizeof(struct vtinput_event)) { 542 WPRINTF(("%s: invalid descriptor length: %lu", __func__, 543 iov.iov_len)); 544 /* release invalid chain */ 545 vq_relchain(vq, req.idx, 0); 546 return; 547 } 548 549 /* save descriptor */ 550 queue->events[i].iov = iov; 551 queue->events[i].idx = req.idx; 552 } 553 554 /* 555 * Second iteration through eventqueue: 556 * Send events to guest by releasing chains 557 */ 558 for (uint32_t i = 0; i < queue->idx; ++i) { 559 struct vtinput_event_elem event = queue->events[i]; 560 memcpy(event.iov.iov_base, &event.event, 561 sizeof(struct vtinput_event)); 562 vq_relchain(vq, event.idx, sizeof(struct vtinput_event)); 563 } 564 done: 565 /* clear queue and send interrupt to guest */ 566 vtinput_eventqueue_clear(queue); 567 vq_endchains(vq, 1); 568 } 569 570 static int 571 vtinput_read_event_from_host(int fd, struct input_event *event) 572 { 573 const int len = read(fd, event, sizeof(struct input_event)); 574 if (len != sizeof(struct input_event)) { 575 if (len == -1 && errno != EAGAIN) { 576 WPRINTF(("%s: event read failed! len = %d, errno = %d", 577 __func__, len, errno)); 578 } 579 580 /* host doesn't have more events for us */ 581 return (1); 582 } 583 584 return (0); 585 } 586 587 static void 588 vtinput_read_event(int fd __attribute((unused)), 589 enum ev_type t __attribute__((unused)), void *arg __attribute__((unused))) 590 { 591 struct pci_vtinput_softc *sc = arg; 592 593 /* skip if driver isn't ready */ 594 if (!(sc->vsc_vs.vs_status & VIRTIO_CONFIG_STATUS_DRIVER_OK)) 595 return; 596 597 /* read all events from host */ 598 struct input_event event; 599 while (vtinput_read_event_from_host(sc->vsc_fd, &event) == 0) { 600 /* add events to our queue */ 601 vtinput_eventqueue_add_event(&sc->vsc_eventqueue, &event); 602 603 /* only send events to guest on EV_SYN or SYN_REPORT */ 604 if (event.type != EV_SYN || event.type != SYN_REPORT) { 605 continue; 606 } 607 608 /* send host events to guest */ 609 vtinput_eventqueue_send_events( 610 &sc->vsc_eventqueue, &sc->vsc_queues[VTINPUT_EVENTQ]); 611 } 612 } 613 614 static int 615 pci_vtinput_legacy_config(nvlist_t *nvl, const char *opts) 616 { 617 if (opts == NULL) 618 return (-1); 619 620 /* 621 * parse opts: 622 * virtio-input,/dev/input/eventX 623 */ 624 char *cp = strchr(opts, ','); 625 if (cp == NULL) { 626 set_config_value_node(nvl, "path", opts); 627 return (0); 628 } 629 char *path = strndup(opts, cp - opts); 630 set_config_value_node(nvl, "path", path); 631 free(path); 632 633 return (pci_parse_legacy_config(nvl, cp + 1)); 634 } 635 636 static int 637 pci_vtinput_init(struct pci_devinst *pi, nvlist_t *nvl) 638 { 639 struct pci_vtinput_softc *sc; 640 641 /* 642 * Keep it here. 643 * Else it's possible to access it uninitialized by jumping to failed. 644 */ 645 pthread_mutexattr_t mtx_attr = NULL; 646 647 sc = calloc(1, sizeof(struct pci_vtinput_softc)); 648 649 sc->vsc_evdev = get_config_value_node(nvl, "path"); 650 if (sc->vsc_evdev == NULL) { 651 WPRINTF(("%s: missing required path config value", __func__)); 652 goto failed; 653 } 654 655 /* 656 * open evdev by using non blocking I/O: 657 * read from /dev/input/eventX would block our thread otherwise 658 */ 659 sc->vsc_fd = open(sc->vsc_evdev, O_RDWR | O_NONBLOCK); 660 if (sc->vsc_fd < 0) { 661 WPRINTF(("%s: failed to open %s", __func__, sc->vsc_evdev)); 662 goto failed; 663 } 664 665 /* check if evdev is really a evdev */ 666 int evversion; 667 int error = ioctl(sc->vsc_fd, EVIOCGVERSION, &evversion); 668 if (error < 0) { 669 WPRINTF(("%s: %s is no evdev", __func__, sc->vsc_evdev)); 670 goto failed; 671 } 672 673 /* gain exclusive access to evdev */ 674 error = ioctl(sc->vsc_fd, EVIOCGRAB, 1); 675 if (error < 0) { 676 WPRINTF(("%s: failed to grab %s", __func__, sc->vsc_evdev)); 677 goto failed; 678 } 679 680 if (pthread_mutexattr_init(&mtx_attr)) { 681 WPRINTF(("%s: init mutexattr failed", __func__)); 682 goto failed; 683 } 684 if (pthread_mutexattr_settype(&mtx_attr, PTHREAD_MUTEX_RECURSIVE)) { 685 WPRINTF(("%s: settype mutexattr failed", __func__)); 686 goto failed; 687 } 688 if (pthread_mutex_init(&sc->vsc_mtx, &mtx_attr)) { 689 WPRINTF(("%s: init mutex failed", __func__)); 690 goto failed; 691 } 692 693 /* init softc */ 694 sc->vsc_eventqueue.idx = 0; 695 sc->vsc_eventqueue.size = VTINPUT_MAX_PKT_LEN; 696 sc->vsc_eventqueue.events = calloc( 697 sc->vsc_eventqueue.size, sizeof(struct vtinput_event_elem)); 698 sc->vsc_config_valid = 0; 699 if (sc->vsc_eventqueue.events == NULL) { 700 WPRINTF(("%s: failed to alloc eventqueue", __func__)); 701 goto failed; 702 } 703 704 /* register event handler */ 705 sc->vsc_evp = mevent_add(sc->vsc_fd, EVF_READ, vtinput_read_event, sc); 706 if (sc->vsc_evp == NULL) { 707 WPRINTF(("%s: could not register mevent", __func__)); 708 goto failed; 709 } 710 711 #ifndef WITHOUT_CAPSICUM 712 cap_rights_t rights; 713 cap_rights_init(&rights, CAP_EVENT, CAP_IOCTL, CAP_READ, CAP_WRITE); 714 if (caph_rights_limit(sc->vsc_fd, &rights) == -1) { 715 errx(EX_OSERR, "Unable to apply rights for sandbox"); 716 } 717 #endif 718 719 /* link virtio to softc */ 720 vi_softc_linkup( 721 &sc->vsc_vs, &vtinput_vi_consts, sc, pi, sc->vsc_queues); 722 sc->vsc_vs.vs_mtx = &sc->vsc_mtx; 723 724 /* init virtio queues */ 725 sc->vsc_queues[VTINPUT_EVENTQ].vq_qsize = VTINPUT_RINGSZ; 726 sc->vsc_queues[VTINPUT_EVENTQ].vq_notify = pci_vtinput_notify_eventq; 727 sc->vsc_queues[VTINPUT_STATUSQ].vq_qsize = VTINPUT_RINGSZ; 728 sc->vsc_queues[VTINPUT_STATUSQ].vq_notify = pci_vtinput_notify_statusq; 729 730 /* initialize config space */ 731 pci_set_cfgdata16(pi, PCIR_DEVICE, VIRTIO_DEV_INPUT); 732 pci_set_cfgdata16(pi, PCIR_VENDOR, VIRTIO_VENDOR); 733 pci_set_cfgdata8(pi, PCIR_CLASS, PCIC_INPUTDEV); 734 pci_set_cfgdata8(pi, PCIR_SUBCLASS, PCIS_INPUTDEV_OTHER); 735 pci_set_cfgdata8(pi, PCIR_REVID, VIRTIO_REV_INPUT); 736 pci_set_cfgdata16(pi, PCIR_SUBDEV_0, VIRTIO_SUBDEV_INPUT); 737 pci_set_cfgdata16(pi, PCIR_SUBVEND_0, VIRTIO_SUBVEN_INPUT); 738 739 /* add MSI-X table BAR */ 740 if (vi_intr_init(&sc->vsc_vs, 1, fbsdrun_virtio_msix())) 741 goto failed; 742 /* add virtio register */ 743 vi_set_io_bar(&sc->vsc_vs, 0); 744 745 return (0); 746 747 failed: 748 if (sc == NULL) { 749 return (-1); 750 } 751 752 if (sc->vsc_evp) 753 mevent_delete(sc->vsc_evp); 754 if (sc->vsc_eventqueue.events) 755 free(sc->vsc_eventqueue.events); 756 if (sc->vsc_mtx) 757 pthread_mutex_destroy(&sc->vsc_mtx); 758 if (mtx_attr) 759 pthread_mutexattr_destroy(&mtx_attr); 760 if (sc->vsc_fd) 761 close(sc->vsc_fd); 762 763 free(sc); 764 765 return (-1); 766 } 767 768 static const struct pci_devemu pci_de_vinput = { 769 .pe_emu = "virtio-input", 770 .pe_init = pci_vtinput_init, 771 .pe_legacy_config = pci_vtinput_legacy_config, 772 .pe_barwrite = vi_pci_write, 773 .pe_barread = vi_pci_read, 774 }; 775 PCI_EMUL_SET(pci_de_vinput); 776