1 /* $FreeBSD$ */ 2 /*- 3 * Copyright (c) 2013 Hans Petter Selasky. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <bsd_global.h> 28 29 struct usb_process usb_process[USB_PROC_MAX]; 30 31 static device_t usb_pci_root; 32 33 int (*bus_alloc_resource_any_cb)(struct resource *res, device_t dev, 34 int type, int *rid, unsigned int flags); 35 int (*ofw_bus_status_ok_cb)(device_t dev); 36 int (*ofw_bus_is_compatible_cb)(device_t dev, char *name); 37 38 /*------------------------------------------------------------------------* 39 * Implementation of busdma API 40 *------------------------------------------------------------------------*/ 41 int 42 bus_dma_tag_create(bus_dma_tag_t parent, bus_size_t alignment, 43 bus_size_t boundary, bus_addr_t lowaddr, 44 bus_addr_t highaddr, bus_dma_filter_t *filter, 45 void *filterarg, bus_size_t maxsize, int nsegments, 46 bus_size_t maxsegsz, int flags, bus_dma_lock_t *lockfunc, 47 void *lockfuncarg, bus_dma_tag_t *dmat) 48 { 49 struct bus_dma_tag *ret; 50 51 ret = malloc(sizeof(struct bus_dma_tag), XXX, XXX); 52 if (*dmat == NULL) 53 return (ENOMEM); 54 ret->alignment = alignment; 55 ret->maxsize = maxsize; 56 57 *dmat = ret; 58 59 return (0); 60 } 61 62 int 63 bus_dmamem_alloc(bus_dma_tag_t dmat, void** vaddr, int flags, 64 bus_dmamap_t *mapp) 65 { 66 void *addr; 67 68 addr = malloc(dmat->maxsize + dmat->alignment, XXX, XXX); 69 if (addr == NULL) 70 return (ENOMEM); 71 72 *mapp = addr; 73 addr = (void*)(((uintptr_t)addr + dmat->alignment - 1) & ~(dmat->alignment - 1)); 74 75 *vaddr = addr; 76 return (0); 77 } 78 79 int 80 bus_dmamap_load(bus_dma_tag_t dmat, bus_dmamap_t map, void *buf, 81 bus_size_t buflen, bus_dmamap_callback_t *callback, 82 void *callback_arg, int flags) 83 { 84 bus_dma_segment_t segs[1]; 85 86 segs[0].ds_addr = (uintptr_t)buf; 87 segs[0].ds_len = buflen; 88 89 (*callback)(callback_arg, segs, 1, 0); 90 91 return (0); 92 } 93 94 void 95 bus_dmamem_free(bus_dma_tag_t dmat, void *vaddr, bus_dmamap_t map) 96 { 97 98 free(map, XXX); 99 } 100 101 int 102 bus_dma_tag_destroy(bus_dma_tag_t dmat) 103 { 104 105 free(dmat, XXX); 106 return (0); 107 } 108 109 /*------------------------------------------------------------------------* 110 * Implementation of resource management API 111 *------------------------------------------------------------------------*/ 112 113 struct resource * 114 bus_alloc_resource_any(device_t dev, int type, int *rid, unsigned int flags) 115 { 116 struct resource *res; 117 int ret = EINVAL; 118 119 res = malloc(sizeof(*res), XXX, XXX); 120 if (res == NULL) 121 return (NULL); 122 123 res->__r_i = malloc(sizeof(struct resource_i), XXX, XXX); 124 if (res->__r_i == NULL) { 125 free(res, XXX); 126 return (NULL); 127 } 128 129 if (bus_alloc_resource_any_cb != NULL) 130 ret = (*bus_alloc_resource_any_cb)(res, dev, type, rid, flags); 131 if (ret == 0) 132 return (res); 133 134 free(res->__r_i, XXX); 135 free(res, XXX); 136 return (NULL); 137 } 138 139 int 140 bus_alloc_resources(device_t dev, struct resource_spec *rs, 141 struct resource **res) 142 { 143 int i; 144 145 for (i = 0; rs[i].type != -1; i++) 146 res[i] = NULL; 147 for (i = 0; rs[i].type != -1; i++) { 148 res[i] = bus_alloc_resource_any(dev, 149 rs[i].type, &rs[i].rid, rs[i].flags); 150 if (res[i] == NULL && !(rs[i].flags & RF_OPTIONAL)) { 151 bus_release_resources(dev, rs, res); 152 return (ENXIO); 153 } 154 } 155 return (0); 156 } 157 158 void 159 bus_release_resources(device_t dev, const struct resource_spec *rs, 160 struct resource **res) 161 { 162 int i; 163 164 for (i = 0; rs[i].type != -1; i++) 165 if (res[i] != NULL) { 166 bus_release_resource( 167 dev, rs[i].type, rs[i].rid, res[i]); 168 res[i] = NULL; 169 } 170 } 171 172 int 173 bus_setup_intr(device_t dev, struct resource *r, int flags, 174 driver_filter_t filter, driver_intr_t handler, void *arg, void **cookiep) 175 { 176 177 dev->dev_irq_filter = filter; 178 dev->dev_irq_fn = handler; 179 dev->dev_irq_arg = arg; 180 181 return (0); 182 } 183 184 int 185 bus_teardown_intr(device_t dev, struct resource *r, void *cookie) 186 { 187 188 dev->dev_irq_filter = NULL; 189 dev->dev_irq_fn = NULL; 190 dev->dev_irq_arg = NULL; 191 192 return (0); 193 } 194 195 int 196 bus_release_resource(device_t dev, int type, int rid, struct resource *r) 197 { 198 /* Resource releasing is not supported */ 199 return (EINVAL); 200 } 201 202 int 203 bus_generic_attach(device_t dev) 204 { 205 device_t child; 206 207 TAILQ_FOREACH(child, &dev->dev_children, dev_link) { 208 device_probe_and_attach(child); 209 } 210 211 return (0); 212 } 213 214 bus_space_tag_t 215 rman_get_bustag(struct resource *r) 216 { 217 218 return (r->r_bustag); 219 } 220 221 bus_space_handle_t 222 rman_get_bushandle(struct resource *r) 223 { 224 225 return (r->r_bushandle); 226 } 227 228 u_long 229 rman_get_size(struct resource *r) 230 { 231 232 return (r->__r_i->r_end - r->__r_i->r_start + 1); 233 } 234 235 int 236 ofw_bus_status_okay(device_t dev) 237 { 238 if (ofw_bus_status_ok_cb == NULL) 239 return (0); 240 241 return ((*ofw_bus_status_ok_cb)(dev)); 242 } 243 244 int 245 ofw_bus_is_compatible(device_t dev, char *name) 246 { 247 if (ofw_bus_is_compatible_cb == NULL) 248 return (0); 249 250 return ((*ofw_bus_is_compatible_cb)(dev, name)); 251 } 252 253 /*------------------------------------------------------------------------* 254 * Implementation of mutex API 255 *------------------------------------------------------------------------*/ 256 257 struct mtx Giant; 258 259 static void 260 mtx_system_init(void *arg) 261 { 262 mtx_init(&Giant, "Giant", NULL, MTX_DEF | MTX_RECURSE); 263 } 264 SYSINIT(mtx_system_init, SI_SUB_LOCK, SI_ORDER_MIDDLE, mtx_system_init, NULL); 265 266 void 267 mtx_init(struct mtx *mtx, const char *name, const char *type, int opt) 268 { 269 mtx->owned = 0; 270 mtx->parent = mtx; 271 } 272 273 void 274 mtx_lock(struct mtx *mtx) 275 { 276 mtx = mtx->parent; 277 mtx->owned++; 278 } 279 280 void 281 mtx_unlock(struct mtx *mtx) 282 { 283 mtx = mtx->parent; 284 mtx->owned--; 285 } 286 287 int 288 mtx_owned(struct mtx *mtx) 289 { 290 mtx = mtx->parent; 291 return (mtx->owned != 0); 292 } 293 294 void 295 mtx_destroy(struct mtx *mtx) 296 { 297 /* NOP */ 298 } 299 300 /*------------------------------------------------------------------------* 301 * Implementation of shared/exclusive mutex API 302 *------------------------------------------------------------------------*/ 303 304 void 305 sx_init_flags(struct sx *sx, const char *name, int flags) 306 { 307 sx->owned = 0; 308 } 309 310 void 311 sx_destroy(struct sx *sx) 312 { 313 /* NOP */ 314 } 315 316 void 317 sx_xlock(struct sx *sx) 318 { 319 sx->owned++; 320 } 321 322 void 323 sx_xunlock(struct sx *sx) 324 { 325 sx->owned--; 326 } 327 328 int 329 sx_xlocked(struct sx *sx) 330 { 331 return (sx->owned != 0); 332 } 333 334 /*------------------------------------------------------------------------* 335 * Implementaiton of condition variable API 336 *------------------------------------------------------------------------*/ 337 338 void 339 cv_init(struct cv *cv, const char *desc) 340 { 341 cv->sleeping = 0; 342 } 343 344 void 345 cv_destroy(struct cv *cv) 346 { 347 /* NOP */ 348 } 349 350 void 351 cv_wait(struct cv *cv, struct mtx *mtx) 352 { 353 cv_timedwait(cv, mtx, -1); 354 } 355 356 int 357 cv_timedwait(struct cv *cv, struct mtx *mtx, int timo) 358 { 359 int start = ticks; 360 int delta; 361 int time = 0; 362 363 if (cv->sleeping) 364 return (EWOULDBLOCK); /* not allowed */ 365 366 cv->sleeping = 1; 367 368 while (cv->sleeping) { 369 if (timo >= 0) { 370 delta = ticks - start; 371 if (delta >= timo || delta < 0) 372 break; 373 } 374 mtx_unlock(mtx); 375 376 usb_idle(); 377 378 if (++time >= (1000000 / hz)) { 379 time = 0; 380 callout_process(1); 381 } 382 383 /* Sleep for 1 us */ 384 delay(1); 385 386 mtx_lock(mtx); 387 } 388 389 if (cv->sleeping) { 390 cv->sleeping = 0; 391 return (EWOULDBLOCK); /* not allowed */ 392 } 393 return (0); 394 } 395 396 void 397 cv_signal(struct cv *cv) 398 { 399 cv->sleeping = 0; 400 } 401 402 void 403 cv_broadcast(struct cv *cv) 404 { 405 cv->sleeping = 0; 406 } 407 408 /*------------------------------------------------------------------------* 409 * Implementation of callout API 410 *------------------------------------------------------------------------*/ 411 412 static void callout_proc_msg(struct usb_proc_msg *); 413 414 volatile int ticks = 0; 415 416 static LIST_HEAD(, callout) head_callout = LIST_HEAD_INITIALIZER(&head_callout); 417 418 static struct mtx mtx_callout; 419 static struct usb_proc_msg callout_msg[2]; 420 421 static void 422 callout_system_init(void *arg) 423 { 424 mtx_init(&mtx_callout, "callout-mtx", NULL, MTX_DEF | MTX_RECURSE); 425 426 callout_msg[0].pm_callback = &callout_proc_msg; 427 callout_msg[1].pm_callback = &callout_proc_msg; 428 } 429 SYSINIT(callout_system_init, SI_SUB_LOCK, SI_ORDER_MIDDLE, callout_system_init, NULL); 430 431 static void 432 callout_callback(struct callout *c) 433 { 434 mtx_lock(c->mtx); 435 436 mtx_lock(&mtx_callout); 437 if (c->entry.le_prev != NULL) { 438 LIST_REMOVE(c, entry); 439 c->entry.le_prev = NULL; 440 } 441 mtx_unlock(&mtx_callout); 442 443 if (c->c_func != NULL) 444 (c->c_func) (c->c_arg); 445 446 if (!(c->flags & CALLOUT_RETURNUNLOCKED)) 447 mtx_unlock(c->mtx); 448 } 449 450 void 451 callout_process(int timeout) 452 { 453 ticks += timeout; 454 usb_proc_msignal(usb_process + 2, &callout_msg[0], &callout_msg[1]); 455 } 456 457 static void 458 callout_proc_msg(struct usb_proc_msg *pmsg) 459 { 460 struct callout *c; 461 int delta; 462 463 repeat: 464 mtx_lock(&mtx_callout); 465 466 LIST_FOREACH(c, &head_callout, entry) { 467 468 delta = c->timeout - ticks; 469 if (delta < 0) { 470 mtx_unlock(&mtx_callout); 471 472 callout_callback(c); 473 474 goto repeat; 475 } 476 } 477 mtx_unlock(&mtx_callout); 478 } 479 480 void 481 callout_init_mtx(struct callout *c, struct mtx *mtx, int flags) 482 { 483 memset(c, 0, sizeof(*c)); 484 485 if (mtx == NULL) 486 mtx = &Giant; 487 488 c->mtx = mtx; 489 c->flags = (flags & CALLOUT_RETURNUNLOCKED); 490 } 491 492 void 493 callout_reset(struct callout *c, int to_ticks, 494 void (*func) (void *), void *arg) 495 { 496 callout_stop(c); 497 498 c->c_func = func; 499 c->c_arg = arg; 500 c->timeout = ticks + to_ticks; 501 502 mtx_lock(&mtx_callout); 503 LIST_INSERT_HEAD(&head_callout, c, entry); 504 mtx_unlock(&mtx_callout); 505 } 506 507 void 508 callout_stop(struct callout *c) 509 { 510 mtx_lock(&mtx_callout); 511 512 if (c->entry.le_prev != NULL) { 513 LIST_REMOVE(c, entry); 514 c->entry.le_prev = NULL; 515 } 516 mtx_unlock(&mtx_callout); 517 518 c->c_func = NULL; 519 c->c_arg = NULL; 520 } 521 522 void 523 callout_drain(struct callout *c) 524 { 525 if (c->mtx == NULL) 526 return; /* not initialised */ 527 528 mtx_lock(c->mtx); 529 callout_stop(c); 530 mtx_unlock(c->mtx); 531 } 532 533 int 534 callout_pending(struct callout *c) 535 { 536 int retval; 537 538 mtx_lock(&mtx_callout); 539 retval = (c->entry.le_prev != NULL); 540 mtx_unlock(&mtx_callout); 541 542 return (retval); 543 } 544 545 /*------------------------------------------------------------------------* 546 * Implementation of device API 547 *------------------------------------------------------------------------*/ 548 549 static const char unknown_string[] = { "unknown" }; 550 551 static TAILQ_HEAD(, module_data) module_head = 552 TAILQ_HEAD_INITIALIZER(module_head); 553 554 static uint8_t 555 devclass_equal(const char *a, const char *b) 556 { 557 char ta, tb; 558 559 if (a == b) 560 return (1); 561 562 while (1) { 563 ta = *a; 564 tb = *b; 565 if (ta != tb) 566 return (0); 567 if (ta == 0) 568 break; 569 a++; 570 b++; 571 } 572 return (1); 573 } 574 575 int 576 bus_generic_resume(device_t dev) 577 { 578 return (0); 579 } 580 581 int 582 bus_generic_shutdown(device_t dev) 583 { 584 return (0); 585 } 586 587 int 588 bus_generic_suspend(device_t dev) 589 { 590 return (0); 591 } 592 593 int 594 bus_generic_print_child(device_t dev, device_t child) 595 { 596 return (0); 597 } 598 599 void 600 bus_generic_driver_added(device_t dev, driver_t *driver) 601 { 602 return; 603 } 604 605 device_t 606 device_get_parent(device_t dev) 607 { 608 return (dev ? dev->dev_parent : NULL); 609 } 610 611 void 612 device_set_interrupt(device_t dev, driver_filter_t *filter, 613 driver_intr_t *fn, void *arg) 614 { 615 dev->dev_irq_filter = filter; 616 dev->dev_irq_fn = fn; 617 dev->dev_irq_arg = arg; 618 } 619 620 void 621 device_run_interrupts(device_t parent) 622 { 623 device_t child; 624 625 if (parent == NULL) 626 return; 627 628 TAILQ_FOREACH(child, &parent->dev_children, dev_link) { 629 int status; 630 if (child->dev_irq_filter != NULL) 631 status = child->dev_irq_filter(child->dev_irq_arg); 632 else 633 status = FILTER_SCHEDULE_THREAD; 634 635 if (status == FILTER_SCHEDULE_THREAD) { 636 if (child->dev_irq_fn != NULL) 637 (child->dev_irq_fn) (child->dev_irq_arg); 638 } 639 } 640 } 641 642 void 643 device_set_ivars(device_t dev, void *ivars) 644 { 645 dev->dev_aux = ivars; 646 } 647 648 void * 649 device_get_ivars(device_t dev) 650 { 651 return (dev ? dev->dev_aux : NULL); 652 } 653 654 int 655 device_get_unit(device_t dev) 656 { 657 return (dev ? dev->dev_unit : 0); 658 } 659 660 int 661 bus_generic_detach(device_t dev) 662 { 663 device_t child; 664 int error; 665 666 if (!dev->dev_attached) 667 return (EBUSY); 668 669 TAILQ_FOREACH(child, &dev->dev_children, dev_link) { 670 if ((error = device_detach(child)) != 0) 671 return (error); 672 } 673 return (0); 674 } 675 676 const char * 677 device_get_nameunit(device_t dev) 678 { 679 if (dev && dev->dev_nameunit[0]) 680 return (dev->dev_nameunit); 681 682 return (unknown_string); 683 } 684 685 static uint8_t 686 devclass_create(devclass_t *dc_pp) 687 { 688 if (dc_pp == NULL) { 689 return (1); 690 } 691 if (dc_pp[0] == NULL) { 692 dc_pp[0] = malloc(sizeof(**(dc_pp)), 693 M_DEVBUF, M_WAITOK | M_ZERO); 694 695 if (dc_pp[0] == NULL) { 696 return (1); 697 } 698 } 699 return (0); 700 } 701 702 static const struct module_data * 703 devclass_find_create(const char *classname) 704 { 705 const struct module_data *mod; 706 707 TAILQ_FOREACH(mod, &module_head, entry) { 708 if (devclass_equal(mod->mod_name, classname)) { 709 if (devclass_create(mod->devclass_pp)) { 710 continue; 711 } 712 return (mod); 713 } 714 } 715 return (NULL); 716 } 717 718 static uint8_t 719 devclass_add_device(const struct module_data *mod, device_t dev) 720 { 721 device_t *pp_dev; 722 device_t *end; 723 uint8_t unit; 724 725 pp_dev = mod->devclass_pp[0]->dev_list; 726 end = pp_dev + DEVCLASS_MAXUNIT; 727 unit = 0; 728 729 while (pp_dev != end) { 730 if (*pp_dev == NULL) { 731 *pp_dev = dev; 732 dev->dev_unit = unit; 733 dev->dev_module = mod; 734 snprintf(dev->dev_nameunit, 735 sizeof(dev->dev_nameunit), 736 "%s%d", device_get_name(dev), unit); 737 return (0); 738 } 739 pp_dev++; 740 unit++; 741 } 742 DPRINTF("Could not add device to devclass.\n"); 743 return (1); 744 } 745 746 static void 747 devclass_delete_device(const struct module_data *mod, device_t dev) 748 { 749 if (mod == NULL) { 750 return; 751 } 752 mod->devclass_pp[0]->dev_list[dev->dev_unit] = NULL; 753 dev->dev_module = NULL; 754 } 755 756 static device_t 757 make_device(device_t parent, const char *name) 758 { 759 device_t dev = NULL; 760 const struct module_data *mod = NULL; 761 762 if (name) { 763 764 mod = devclass_find_create(name); 765 766 if (!mod) { 767 768 DPRINTF("%s:%d:%s: can't find device " 769 "class %s\n", __FILE__, __LINE__, 770 __FUNCTION__, name); 771 772 goto done; 773 } 774 } 775 dev = malloc(sizeof(*dev), 776 M_DEVBUF, M_WAITOK | M_ZERO); 777 778 if (dev == NULL) 779 goto done; 780 781 dev->dev_parent = parent; 782 TAILQ_INIT(&dev->dev_children); 783 784 if (name) { 785 dev->dev_fixed_class = 1; 786 if (devclass_add_device(mod, dev)) { 787 goto error; 788 } 789 } 790 done: 791 return (dev); 792 793 error: 794 if (dev) { 795 free(dev, M_DEVBUF); 796 } 797 return (NULL); 798 } 799 800 device_t 801 device_add_child(device_t dev, const char *name, int unit) 802 { 803 device_t child; 804 805 if (unit != -1) { 806 device_printf(dev, "Unit is not -1\n"); 807 } 808 child = make_device(dev, name); 809 if (child == NULL) { 810 device_printf(dev, "Could not add child '%s'\n", name); 811 goto done; 812 } 813 if (dev == NULL) { 814 /* no parent */ 815 goto done; 816 } 817 TAILQ_INSERT_TAIL(&dev->dev_children, child, dev_link); 818 done: 819 return (child); 820 } 821 822 int 823 device_delete_child(device_t dev, device_t child) 824 { 825 int error = 0; 826 device_t grandchild; 827 828 /* detach parent before deleting children, if any */ 829 error = device_detach(child); 830 if (error) 831 goto done; 832 833 /* remove children second */ 834 while ((grandchild = TAILQ_FIRST(&child->dev_children))) { 835 error = device_delete_child(child, grandchild); 836 if (error) { 837 device_printf(dev, "Error deleting child!\n"); 838 goto done; 839 } 840 } 841 842 devclass_delete_device(child->dev_module, child); 843 844 if (dev != NULL) { 845 /* remove child from parent */ 846 TAILQ_REMOVE(&dev->dev_children, child, dev_link); 847 } 848 free(child, M_DEVBUF); 849 850 done: 851 return (error); 852 } 853 854 int 855 device_delete_children(device_t dev) 856 { 857 device_t child; 858 int error = 0; 859 860 while ((child = TAILQ_FIRST(&dev->dev_children))) { 861 error = device_delete_child(dev, child); 862 if (error) { 863 device_printf(dev, "Error deleting child!\n"); 864 break; 865 } 866 } 867 return (error); 868 } 869 870 void 871 device_quiet(device_t dev) 872 { 873 dev->dev_quiet = 1; 874 } 875 876 const char * 877 device_get_desc(device_t dev) 878 { 879 if (dev) 880 return &(dev->dev_desc[0]); 881 return (unknown_string); 882 } 883 884 static int 885 default_method(void) 886 { 887 /* do nothing */ 888 DPRINTF("Default method called\n"); 889 return (0); 890 } 891 892 void * 893 device_get_method(device_t dev, const char *what) 894 { 895 const struct device_method *mtod; 896 897 mtod = dev->dev_module->driver->methods; 898 while (mtod->func != NULL) { 899 if (devclass_equal(mtod->desc, what)) { 900 return (mtod->func); 901 } 902 mtod++; 903 } 904 return ((void *)&default_method); 905 } 906 907 const char * 908 device_get_name(device_t dev) 909 { 910 if (dev == NULL) 911 return (unknown_string); 912 913 return (dev->dev_module->driver->name); 914 } 915 916 static int 917 device_allocate_softc(device_t dev) 918 { 919 const struct module_data *mod; 920 921 mod = dev->dev_module; 922 923 if ((dev->dev_softc_alloc == 0) && 924 (mod->driver->size != 0)) { 925 dev->dev_sc = malloc(mod->driver->size, 926 M_DEVBUF, M_WAITOK | M_ZERO); 927 928 if (dev->dev_sc == NULL) 929 return (ENOMEM); 930 931 dev->dev_softc_alloc = 1; 932 } 933 return (0); 934 } 935 936 int 937 device_probe_and_attach(device_t dev) 938 { 939 const struct module_data *mod; 940 const char *bus_name_parent; 941 942 bus_name_parent = device_get_name(device_get_parent(dev)); 943 944 if (dev->dev_attached) 945 return (0); /* fail-safe */ 946 947 if (dev->dev_fixed_class) { 948 949 mod = dev->dev_module; 950 951 if (DEVICE_PROBE(dev) <= 0) { 952 953 if (device_allocate_softc(dev) == 0) { 954 955 if (DEVICE_ATTACH(dev) == 0) { 956 /* success */ 957 dev->dev_attached = 1; 958 return (0); 959 } 960 } 961 } 962 device_detach(dev); 963 964 goto error; 965 } 966 /* 967 * Else find a module for our device, if any 968 */ 969 970 TAILQ_FOREACH(mod, &module_head, entry) { 971 if (devclass_equal(mod->bus_name, bus_name_parent)) { 972 if (devclass_create(mod->devclass_pp)) { 973 continue; 974 } 975 if (devclass_add_device(mod, dev)) { 976 continue; 977 } 978 if (DEVICE_PROBE(dev) <= 0) { 979 980 if (device_allocate_softc(dev) == 0) { 981 982 if (DEVICE_ATTACH(dev) == 0) { 983 /* success */ 984 dev->dev_attached = 1; 985 return (0); 986 } 987 } 988 } 989 /* else try next driver */ 990 991 device_detach(dev); 992 } 993 } 994 995 error: 996 return (ENODEV); 997 } 998 999 int 1000 device_detach(device_t dev) 1001 { 1002 const struct module_data *mod = dev->dev_module; 1003 int error; 1004 1005 if (dev->dev_attached) { 1006 1007 error = DEVICE_DETACH(dev); 1008 if (error) { 1009 return error; 1010 } 1011 dev->dev_attached = 0; 1012 } 1013 device_set_softc(dev, NULL); 1014 1015 if (dev->dev_fixed_class == 0) 1016 devclass_delete_device(mod, dev); 1017 1018 return (0); 1019 } 1020 1021 void 1022 device_set_softc(device_t dev, void *softc) 1023 { 1024 if (dev->dev_softc_alloc) { 1025 free(dev->dev_sc, M_DEVBUF); 1026 dev->dev_sc = NULL; 1027 } 1028 dev->dev_sc = softc; 1029 dev->dev_softc_alloc = 0; 1030 } 1031 1032 void * 1033 device_get_softc(device_t dev) 1034 { 1035 if (dev == NULL) 1036 return (NULL); 1037 1038 return (dev->dev_sc); 1039 } 1040 1041 int 1042 device_is_attached(device_t dev) 1043 { 1044 return (dev->dev_attached); 1045 } 1046 1047 void 1048 device_set_desc(device_t dev, const char *desc) 1049 { 1050 snprintf(dev->dev_desc, sizeof(dev->dev_desc), "%s", desc); 1051 } 1052 1053 void 1054 device_set_desc_copy(device_t dev, const char *desc) 1055 { 1056 device_set_desc(dev, desc); 1057 } 1058 1059 void * 1060 devclass_get_softc(devclass_t dc, int unit) 1061 { 1062 return (device_get_softc(devclass_get_device(dc, unit))); 1063 } 1064 1065 int 1066 devclass_get_maxunit(devclass_t dc) 1067 { 1068 int max_unit = 0; 1069 1070 if (dc) { 1071 max_unit = DEVCLASS_MAXUNIT; 1072 while (max_unit--) { 1073 if (dc->dev_list[max_unit]) { 1074 break; 1075 } 1076 } 1077 max_unit++; 1078 } 1079 return (max_unit); 1080 } 1081 1082 device_t 1083 devclass_get_device(devclass_t dc, int unit) 1084 { 1085 return (((unit < 0) || (unit >= DEVCLASS_MAXUNIT) || (dc == NULL)) ? 1086 NULL : dc->dev_list[unit]); 1087 } 1088 1089 devclass_t 1090 devclass_find(const char *classname) 1091 { 1092 const struct module_data *mod; 1093 1094 TAILQ_FOREACH(mod, &module_head, entry) { 1095 if (devclass_equal(mod->driver->name, classname)) 1096 return (mod->devclass_pp[0]); 1097 } 1098 return (NULL); 1099 } 1100 1101 void 1102 module_register(void *data) 1103 { 1104 struct module_data *mdata = data; 1105 1106 TAILQ_INSERT_TAIL(&module_head, mdata, entry); 1107 } 1108 1109 /*------------------------------------------------------------------------* 1110 * System startup 1111 *------------------------------------------------------------------------*/ 1112 1113 static void 1114 sysinit_run(const void **ppdata) 1115 { 1116 const struct sysinit *psys; 1117 1118 while ((psys = *ppdata) != NULL) { 1119 (psys->func) (psys->data); 1120 ppdata++; 1121 } 1122 } 1123 1124 /*------------------------------------------------------------------------* 1125 * USB process API 1126 *------------------------------------------------------------------------*/ 1127 1128 static int usb_do_process(struct usb_process *); 1129 static int usb_proc_level = -1; 1130 static struct mtx usb_proc_mtx; 1131 1132 void 1133 usb_idle(void) 1134 { 1135 int old_level = usb_proc_level; 1136 int old_giant = Giant.owned; 1137 int worked; 1138 1139 device_run_interrupts(usb_pci_root); 1140 1141 do { 1142 worked = 0; 1143 Giant.owned = 0; 1144 1145 while (++usb_proc_level < USB_PROC_MAX) 1146 worked |= usb_do_process(usb_process + usb_proc_level); 1147 1148 usb_proc_level = old_level; 1149 Giant.owned = old_giant; 1150 1151 } while (worked); 1152 } 1153 1154 void 1155 usb_init(void) 1156 { 1157 sysinit_run(sysinit_data); 1158 } 1159 1160 void 1161 usb_uninit(void) 1162 { 1163 sysinit_run(sysuninit_data); 1164 } 1165 1166 static void 1167 usb_process_init_sub(struct usb_process *up) 1168 { 1169 TAILQ_INIT(&up->up_qhead); 1170 1171 cv_init(&up->up_cv, "-"); 1172 cv_init(&up->up_drain, "usbdrain"); 1173 1174 up->up_mtx = &usb_proc_mtx; 1175 } 1176 1177 static void 1178 usb_process_init(void *arg) 1179 { 1180 uint8_t x; 1181 1182 mtx_init(&usb_proc_mtx, "usb-proc-mtx", NULL, MTX_DEF | MTX_RECURSE); 1183 1184 for (x = 0; x != USB_PROC_MAX; x++) 1185 usb_process_init_sub(&usb_process[x]); 1186 1187 } 1188 SYSINIT(usb_process_init, SI_SUB_LOCK, SI_ORDER_MIDDLE, usb_process_init, NULL); 1189 1190 static int 1191 usb_do_process(struct usb_process *up) 1192 { 1193 struct usb_proc_msg *pm; 1194 int worked = 0; 1195 1196 mtx_lock(&usb_proc_mtx); 1197 1198 repeat: 1199 pm = TAILQ_FIRST(&up->up_qhead); 1200 1201 if (pm != NULL) { 1202 1203 worked = 1; 1204 1205 (pm->pm_callback) (pm); 1206 1207 if (pm == TAILQ_FIRST(&up->up_qhead)) { 1208 /* nothing changed */ 1209 TAILQ_REMOVE(&up->up_qhead, pm, pm_qentry); 1210 pm->pm_qentry.tqe_prev = NULL; 1211 } 1212 goto repeat; 1213 } 1214 mtx_unlock(&usb_proc_mtx); 1215 1216 return (worked); 1217 } 1218 1219 void * 1220 usb_proc_msignal(struct usb_process *up, void *_pm0, void *_pm1) 1221 { 1222 struct usb_proc_msg *pm0 = _pm0; 1223 struct usb_proc_msg *pm1 = _pm1; 1224 struct usb_proc_msg *pm2; 1225 usb_size_t d; 1226 uint8_t t; 1227 1228 t = 0; 1229 1230 if (pm0->pm_qentry.tqe_prev) { 1231 t |= 1; 1232 } 1233 if (pm1->pm_qentry.tqe_prev) { 1234 t |= 2; 1235 } 1236 if (t == 0) { 1237 /* 1238 * No entries are queued. Queue "pm0" and use the existing 1239 * message number. 1240 */ 1241 pm2 = pm0; 1242 } else if (t == 1) { 1243 /* Check if we need to increment the message number. */ 1244 if (pm0->pm_num == up->up_msg_num) { 1245 up->up_msg_num++; 1246 } 1247 pm2 = pm1; 1248 } else if (t == 2) { 1249 /* Check if we need to increment the message number. */ 1250 if (pm1->pm_num == up->up_msg_num) { 1251 up->up_msg_num++; 1252 } 1253 pm2 = pm0; 1254 } else if (t == 3) { 1255 /* 1256 * Both entries are queued. Re-queue the entry closest to 1257 * the end. 1258 */ 1259 d = (pm1->pm_num - pm0->pm_num); 1260 1261 /* Check sign after subtraction */ 1262 if (d & 0x80000000) { 1263 pm2 = pm0; 1264 } else { 1265 pm2 = pm1; 1266 } 1267 1268 TAILQ_REMOVE(&up->up_qhead, pm2, pm_qentry); 1269 } else { 1270 pm2 = NULL; /* panic - should not happen */ 1271 } 1272 1273 /* Put message last on queue */ 1274 1275 pm2->pm_num = up->up_msg_num; 1276 TAILQ_INSERT_TAIL(&up->up_qhead, pm2, pm_qentry); 1277 1278 return (pm2); 1279 } 1280 1281 /*------------------------------------------------------------------------* 1282 * usb_proc_is_gone 1283 * 1284 * Return values: 1285 * 0: USB process is running 1286 * Else: USB process is tearing down 1287 *------------------------------------------------------------------------*/ 1288 uint8_t 1289 usb_proc_is_gone(struct usb_process *up) 1290 { 1291 return (0); 1292 } 1293 1294 /*------------------------------------------------------------------------* 1295 * usb_proc_mwait 1296 * 1297 * This function will return when the USB process message pointed to 1298 * by "pm" is no longer on a queue. This function must be called 1299 * having "usb_proc_mtx" locked. 1300 *------------------------------------------------------------------------*/ 1301 void 1302 usb_proc_mwait(struct usb_process *up, void *_pm0, void *_pm1) 1303 { 1304 struct usb_proc_msg *pm0 = _pm0; 1305 struct usb_proc_msg *pm1 = _pm1; 1306 1307 /* Just remove the messages from the queue. */ 1308 if (pm0->pm_qentry.tqe_prev) { 1309 TAILQ_REMOVE(&up->up_qhead, pm0, pm_qentry); 1310 pm0->pm_qentry.tqe_prev = NULL; 1311 } 1312 if (pm1->pm_qentry.tqe_prev) { 1313 TAILQ_REMOVE(&up->up_qhead, pm1, pm_qentry); 1314 pm1->pm_qentry.tqe_prev = NULL; 1315 } 1316 } 1317 1318 /*------------------------------------------------------------------------* 1319 * SYSTEM attach 1320 *------------------------------------------------------------------------*/ 1321 1322 #ifdef USB_PCI_PROBE_LIST 1323 static device_method_t pci_methods[] = { 1324 DEVMETHOD_END 1325 }; 1326 1327 static driver_t pci_driver = { 1328 .name = "pci", 1329 .methods = pci_methods, 1330 }; 1331 1332 static devclass_t pci_devclass; 1333 1334 DRIVER_MODULE(pci, pci, pci_driver, pci_devclass, 0, 0); 1335 1336 static const char *usb_pci_devices[] = { 1337 USB_PCI_PROBE_LIST 1338 }; 1339 1340 #define USB_PCI_USB_MAX (sizeof(usb_pci_devices) / sizeof(void *)) 1341 1342 static device_t usb_pci_dev[USB_PCI_USB_MAX]; 1343 1344 static void 1345 usb_pci_mod_load(void *arg) 1346 { 1347 uint32_t x; 1348 1349 usb_pci_root = device_add_child(NULL, "pci", -1); 1350 if (usb_pci_root == NULL) 1351 return; 1352 1353 for (x = 0; x != USB_PCI_USB_MAX; x++) { 1354 usb_pci_dev[x] = device_add_child(usb_pci_root, usb_pci_devices[x], -1); 1355 if (usb_pci_dev[x] == NULL) 1356 continue; 1357 if (device_probe_and_attach(usb_pci_dev[x])) { 1358 device_printf(usb_pci_dev[x], 1359 "WARNING: Probe and attach failed!\n"); 1360 } 1361 } 1362 } 1363 SYSINIT(usb_pci_mod_load, SI_SUB_RUN_SCHEDULER, SI_ORDER_MIDDLE, usb_pci_mod_load, 0); 1364 1365 static void 1366 usb_pci_mod_unload(void *arg) 1367 { 1368 uint32_t x; 1369 1370 for (x = 0; x != USB_PCI_USB_MAX; x++) { 1371 if (usb_pci_dev[x]) { 1372 device_detach(usb_pci_dev[x]); 1373 device_delete_child(usb_pci_root, usb_pci_dev[x]); 1374 } 1375 } 1376 if (usb_pci_root) 1377 device_delete_child(NULL, usb_pci_root); 1378 } 1379 SYSUNINIT(usb_pci_mod_unload, SI_SUB_RUN_SCHEDULER, SI_ORDER_MIDDLE, usb_pci_mod_unload, 0); 1380 #endif 1381 1382 /*------------------------------------------------------------------------* 1383 * MALLOC API 1384 *------------------------------------------------------------------------*/ 1385 1386 #ifndef HAVE_MALLOC 1387 #define USB_POOL_ALIGN 8 1388 1389 static uint8_t usb_pool[USB_POOL_SIZE] __aligned(USB_POOL_ALIGN); 1390 static uint32_t usb_pool_rem = USB_POOL_SIZE; 1391 static uint32_t usb_pool_entries; 1392 1393 struct malloc_hdr { 1394 TAILQ_ENTRY(malloc_hdr) entry; 1395 uint32_t size; 1396 } __aligned(USB_POOL_ALIGN); 1397 1398 static TAILQ_HEAD(, malloc_hdr) malloc_head = 1399 TAILQ_HEAD_INITIALIZER(malloc_head); 1400 1401 void * 1402 usb_malloc(unsigned long size) 1403 { 1404 struct malloc_hdr *hdr; 1405 1406 size = (size + USB_POOL_ALIGN - 1) & ~(USB_POOL_ALIGN - 1); 1407 size += sizeof(struct malloc_hdr); 1408 1409 TAILQ_FOREACH(hdr, &malloc_head, entry) { 1410 if (hdr->size == size) 1411 break; 1412 } 1413 1414 if (hdr) { 1415 DPRINTF("MALLOC: Entries = %d; Remainder = %d; Size = %d\n", 1416 (int)usb_pool_entries, (int)usb_pool_rem, (int)size); 1417 1418 TAILQ_REMOVE(&malloc_head, hdr, entry); 1419 memset(hdr + 1, 0, hdr->size - sizeof(*hdr)); 1420 return (hdr + 1); 1421 } 1422 if (usb_pool_rem >= size) { 1423 hdr = (void *)(usb_pool + USB_POOL_SIZE - usb_pool_rem); 1424 hdr->size = size; 1425 1426 usb_pool_rem -= size; 1427 usb_pool_entries++; 1428 1429 DPRINTF("MALLOC: Entries = %d; Remainder = %d; Size = %d\n", 1430 (int)usb_pool_entries, (int)usb_pool_rem, (int)size); 1431 1432 memset(hdr + 1, 0, hdr->size - sizeof(*hdr)); 1433 return (hdr + 1); 1434 } 1435 return (NULL); 1436 } 1437 1438 void 1439 usb_free(void *arg) 1440 { 1441 struct malloc_hdr *hdr; 1442 1443 if (arg == NULL) 1444 return; 1445 1446 hdr = arg; 1447 hdr--; 1448 1449 TAILQ_INSERT_TAIL(&malloc_head, hdr, entry); 1450 } 1451 #endif 1452 1453 char * 1454 usb_strdup(const char *str) 1455 { 1456 char *tmp; 1457 int len; 1458 1459 len = 1 + strlen(str); 1460 1461 tmp = malloc(len,XXX,XXX); 1462 if (tmp == NULL) 1463 return (NULL); 1464 1465 memcpy(tmp, str, len); 1466 return (tmp); 1467 } 1468