stand/kshim/bsd_kernel.c

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