sys/dev/usb/usb_hub_acpi.c

   1 /* $FreeBSD$ */
   2 /*-
   3  * SPDX-License-Identifier: BSD-2-Clause-NetBSD
   4  *
   5  * Copyright (c) 1998 The NetBSD Foundation, Inc. All rights reserved.
   6  * Copyright (c) 1998 Lennart Augustsson. All rights reserved.
   7  * Copyright (c) 2008-2010 Hans Petter Selasky. All rights reserved.
   8  * Copyright (c) 2019 Takanori Watanabe.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * USB spec: http://www.usb.org/developers/docs/usbspec.zip
  34  */
  35
  36 #ifdef USB_GLOBAL_INCLUDE_FILE
  37 #include USB_GLOBAL_INCLUDE_FILE
  38 #else
  39 #include <sys/stdint.h>
  40 #include <sys/stddef.h>
  41 #include <sys/param.h>
  42 #include <sys/queue.h>
  43 #include <sys/types.h>
  44 #include <sys/systm.h>
  45 #include <sys/kernel.h>
  46 #include <sys/bus.h>
  47 #include <sys/module.h>
  48 #include <sys/lock.h>
  49 #include <sys/mutex.h>
  50 #include <sys/condvar.h>
  51 #include <sys/sysctl.h>
  52 #include <sys/sx.h>
  53 #include <sys/unistd.h>
  54 #include <sys/callout.h>
  55 #include <sys/malloc.h>
  56 #include <sys/priv.h>
  57
  58 #include <dev/usb/usb.h>
  59 #include <dev/usb/usbdi.h>
  60 #include <dev/usb/usbdi_util.h>
  61
  62 #define USB_DEBUG_VAR uhub_debug
  63
  64 #include <dev/usb/usb_core.h>
  65 #include <dev/usb/usb_process.h>
  66 #include <dev/usb/usb_device.h>
  67 #include <dev/usb/usb_request.h>
  68 #include <dev/usb/usb_debug.h>
  69 #include <dev/usb/usb_hub.h>
  70 #include <dev/usb/usb_util.h>
  71 #include <dev/usb/usb_busdma.h>
  72 #include <dev/usb/usb_transfer.h>
  73 #include <dev/usb/usb_dynamic.h>
  74
  75 #include <dev/usb/usb_controller.h>
  76 #include <dev/usb/usb_bus.h>
  77 #endif                                  /* USB_GLOBAL_INCLUDE_FILE */
  78 #include <dev/usb/usb_hub_private.h>
  79 #include <contrib/dev/acpica/include/acpi.h>
  80 #include <contrib/dev/acpica/include/accommon.h>
  81 #include <dev/acpica/acpivar.h>
  82 #include <sys/sbuf.h>
  83
  84 #define ACPI_PLD_SIZE 20
  85 struct acpi_uhub_port {
  86         ACPI_HANDLE handle;
  87 #define    ACPI_UPC_CONNECTABLE 0x80000000
  88 #define    ACPI_UPC_PORTTYPE(x) ((x)&0xff)
  89         uint32_t upc;
  90         uint8_t pld[ACPI_PLD_SIZE];
  91 };
  92
  93 struct acpi_uhub_softc {
  94         struct uhub_softc usc;
  95         uint8_t nports;
  96         ACPI_HANDLE ah;
  97         struct acpi_uhub_port *port;
  98 };
  99
 100 static UINT32
 101 acpi_uhub_find_rh_cb(ACPI_HANDLE ah, UINT32 nl, void *ctx, void **status)
 102 {
 103         ACPI_DEVICE_INFO *devinfo;
 104         UINT32 ret;
 105
 106         *status = NULL;
 107         devinfo = NULL;
 108
 109         ret = AcpiGetObjectInfo(ah, &devinfo);
 110         if (ACPI_SUCCESS(ret)) {
 111                 if ((devinfo->Valid & ACPI_VALID_ADR) &&
 112                     (devinfo->Address == 0)) {
 113                         ret = AE_CTRL_TERMINATE;
 114                         *status = ah;
 115                 }
 116                 AcpiOsFree(devinfo);
 117         }
 118         return (ret);
 119 }
 120
 121 static const char *
 122 acpi_uhub_upc_type(uint8_t type)
 123 {
 124         const char *typelist[] = {"TypeA", "MiniAB", "Express",
 125                                   "USB3-A", "USB3-B", "USB-MicroB",
 126                                   "USB3-MicroAB", "USB3-PowerB",
 127                                   "TypeC-USB2", "TypeC-Switch",
 128                                   "TypeC-nonSwitch"};
 129         const int last = sizeof(typelist) / sizeof(typelist[0]);
 130
 131         if (type == 0xff) {
 132                 return "Proprietary";
 133         }
 134
 135         return (type < last) ? typelist[type] : "Unknown";
 136 }
 137
 138 static int
 139 acpi_uhub_parse_upc(device_t dev, unsigned int p, ACPI_HANDLE ah, struct sysctl_oid_list *poid)
 140 {
 141         ACPI_BUFFER buf;
 142         struct acpi_uhub_softc *sc = device_get_softc(dev);
 143         struct acpi_uhub_port *port = &sc->port[p - 1];
 144
 145         buf.Pointer = NULL;
 146         buf.Length = ACPI_ALLOCATE_BUFFER;
 147
 148         if (AcpiEvaluateObject(ah, "_UPC", NULL, &buf) == AE_OK) {
 149                 ACPI_OBJECT *obj = buf.Pointer;
 150                 UINT64 porttypenum, conn;
 151                 uint8_t *connectable;
 152
 153                 acpi_PkgInt(obj, 0, &conn);
 154                 acpi_PkgInt(obj, 1, &porttypenum);
 155                 connectable = conn ? "" : "non";
 156
 157                 port->upc = porttypenum;
 158                 port->upc |= (conn) ? (ACPI_UPC_CONNECTABLE) : 0;
 159
 160                 if (usb_debug)
 161                         device_printf(dev, "Port %u %sconnectable %s\n",
 162                             p, connectable,
 163                             acpi_uhub_upc_type(porttypenum));
 164
 165                 SYSCTL_ADD_U32(
 166                     device_get_sysctl_ctx(dev),
 167                     poid, OID_AUTO,
 168                     "upc",
 169                     CTLFLAG_RD | CTLFLAG_MPSAFE,
 170                     SYSCTL_NULL_U32_PTR, port->upc,
 171                     "UPC value. MSB is visible flag");
 172         }
 173         AcpiOsFree(buf.Pointer);
 174
 175         return (0);
 176 }
 177 static int
 178 acpi_uhub_port_sysctl(SYSCTL_HANDLER_ARGS)
 179 {
 180         struct acpi_uhub_port *port = oidp->oid_arg1;
 181         struct sbuf sb;
 182         int error;
 183
 184         sbuf_new_for_sysctl(&sb, NULL, 256, req);
 185         sbuf_printf(&sb, "Handle %s\n", acpi_name(port->handle));
 186         if (port->upc == 0xffffffff) {
 187                 sbuf_printf(&sb, "\tNo information\n");
 188                 goto end;
 189         }
 190         sbuf_printf(&sb, "\t");
 191         if (port->upc & ACPI_UPC_CONNECTABLE) {
 192                 sbuf_printf(&sb, "Connectable ");
 193         }
 194         sbuf_printf(&sb, "%s port\n", acpi_uhub_upc_type(port->upc & 0xff));
 195
 196         if ((port->pld[0] & 0x80) == 0) {
 197                 sbuf_printf(&sb,
 198                     "\tColor:#%02x%02x%02x\n",
 199                     port->pld[1], port->pld[2],
 200                     port->pld[3]);
 201         }
 202         sbuf_printf(&sb, "\tWidth %d mm Height %d mm\n",
 203             port->pld[4] | (port->pld[5] << 8),
 204             port->pld[6] | (port->pld[7] << 8));
 205         if (port->pld[8] & 1) {
 206                 sbuf_printf(&sb, "\tVisible\n");
 207         }
 208         if (port->pld[8] & 2) {
 209                 sbuf_printf(&sb, "\tDock\n");
 210         }
 211         if (port->pld[8] & 4) {
 212                 sbuf_printf(&sb, "\tLid\n");
 213         } {
 214                 int panelpos = (port->pld[8] >> 3) & 7;
 215                 const char *panposstr[] = {"Top", "Bottom", "Left",
 216                                            "Right", "Front", "Back",
 217                                            "Unknown", "Invalid"};
 218                 const char *shapestr[] = {
 219                         "Round", "Oval", "Square", "VRect", "HRect",
 220                         "VTrape", "HTrape", "Unknown", "Chamferd",
 221                         "Rsvd", "Rsvd", "Rsvd", "Rsvd",
 222                         "Rsvd", "Rsvd", "Rsvd", "Rsvd"};
 223
 224                 sbuf_printf(&sb, "\tPanelPosition: %s\n", panposstr[panelpos]);
 225                 if (panelpos < 6) {
 226                         const char *posstr[] = {"Upper", "Center",
 227                         "Lower", "Invalid"};
 228
 229                         sbuf_printf(&sb, "\tVertPosition: %s\n",
 230                             posstr[(port->pld[8] >> 6) & 3]);
 231                         sbuf_printf(&sb, "\tHorizPosition: %s\n",
 232                             posstr[(port->pld[9]) & 3]);
 233                 }
 234                 sbuf_printf(&sb, "\tShape: %s\n",
 235                     shapestr[(port->pld[9] >> 2) & 0xf]);
 236                 sbuf_printf(&sb, "\tGroup Orientation %s\n",
 237                     ((port->pld[9] >> 6) & 1) ? "Vertical" :
 238                     "Horizontal");
 239                 sbuf_printf(&sb, "\tGroupToken %x\n",
 240                     ((port->pld[9] >> 7)
 241                     | (port->pld[10] << 1)) & 0xff);
 242                 sbuf_printf(&sb, "\tGroupPosition %x\n",
 243                     ((port->pld[10] >> 7)
 244                     | (port->pld[11] << 1)) & 0xff);
 245                 sbuf_printf(&sb, "\t%s %s %s\n",
 246                     (port->pld[11] & 0x80) ?
 247                     "Bay" : "",
 248                     (port->pld[12] & 1) ? "Eject" : "",
 249                     (port->pld[12] & 2) ? "OSPM" : ""
 250                     );
 251         }
 252         if ((port->pld[0] & 0x7f) >= 2) {
 253                 sbuf_printf(&sb, "\tVOFF%d mm HOFF %dmm",
 254                     port->pld[16] | (port->pld[17] << 8),
 255                     port->pld[18] | (port->pld[19] << 8));
 256         }
 257
 258 end:
 259         error = sbuf_finish(&sb);
 260         sbuf_delete(&sb);
 261         return (error);
 262 }
 263
 264 static int
 265 acpi_uhub_parse_pld(device_t dev, unsigned int p, ACPI_HANDLE ah, struct sysctl_oid_list *tree)
 266 {
 267         ACPI_BUFFER buf;
 268         struct acpi_uhub_softc *sc = device_get_softc(dev);
 269         struct acpi_uhub_port *port = &sc->port[p - 1];
 270
 271         buf.Pointer = NULL;
 272         buf.Length = ACPI_ALLOCATE_BUFFER;
 273
 274         if (AcpiEvaluateObject(ah, "_PLD", NULL, &buf) == AE_OK) {
 275                 ACPI_OBJECT *obj;
 276                 unsigned char *resbuf;
 277                 int len;
 278
 279                 obj = buf.Pointer;
 280
 281                 if (obj->Type == ACPI_TYPE_PACKAGE
 282                     && obj->Package.Elements[0].Type == ACPI_TYPE_BUFFER) {
 283                         ACPI_OBJECT *obj1;
 284
 285                         obj1 = &obj->Package.Elements[0];
 286                         len = obj1->Buffer.Length;
 287                         resbuf = obj1->Buffer.Pointer;
 288                 } else if (obj->Type == ACPI_TYPE_BUFFER) {
 289                         len = obj->Buffer.Length;
 290                         resbuf = obj->Buffer.Pointer;
 291                 } else {
 292                         goto skip;
 293                 }
 294                 len = (len < ACPI_PLD_SIZE) ? len : ACPI_PLD_SIZE;
 295                 memcpy(port->pld, resbuf, len);
 296                 SYSCTL_ADD_OPAQUE(
 297                     device_get_sysctl_ctx(dev), tree, OID_AUTO,
 298                     "pldraw", CTLFLAG_RD | CTLFLAG_MPSAFE,
 299                     port->pld, len, "A", "Raw PLD value");
 300
 301                 if (usb_debug) {
 302                         device_printf(dev, "Revision:%d\n",
 303                             resbuf[0] & 0x7f);
 304                         if ((resbuf[0] & 0x80) == 0) {
 305                                 device_printf(dev,
 306                                     "Color:#%02x%02x%02x\n",
 307                                     resbuf[1], resbuf[2],
 308                                     resbuf[3]);
 309                         }
 310                         device_printf(dev, "Width %d mm Height %d mm\n",
 311                             resbuf[4] | (resbuf[5] << 8),
 312                             resbuf[6] | (resbuf[7] << 8));
 313                         if (resbuf[8] & 1) {
 314                                 device_printf(dev, "Visible\n");
 315                         }
 316                         if (resbuf[8] & 2) {
 317                                 device_printf(dev, "Dock\n");
 318                         }
 319                         if (resbuf[8] & 4) {
 320                                 device_printf(dev, "Lid\n");
 321                         }
 322                         device_printf(dev, "PanelPosition: %d\n",
 323                             (resbuf[8] >> 3) & 7);
 324                         device_printf(dev, "VertPosition: %d\n",
 325                             (resbuf[8] >> 6) & 3);
 326                         device_printf(dev, "HorizPosition: %d\n",
 327                             (resbuf[9]) & 3);
 328                         device_printf(dev, "Shape: %d\n",
 329                             (resbuf[9] >> 2) & 0xf);
 330                         device_printf(dev, "80: %02x, %02x, %02x\n",
 331                             resbuf[9], resbuf[10], resbuf[11]);
 332                         device_printf(dev, "96: %02x, %02x, %02x, %02x\n",
 333                             resbuf[12], resbuf[13],
 334                             resbuf[14], resbuf[15]);
 335
 336                         if ((resbuf[0] & 0x7f) >= 2) {
 337                                 device_printf(dev, "VOFF%d mm HOFF %dmm",
 338                                     resbuf[16] | (resbuf[17] << 8),
 339                                     resbuf[18] | (resbuf[19] << 8));
 340                         }
 341                 }
 342         skip:
 343                 AcpiOsFree(buf.Pointer);
 344         }
 345         return (0);
 346 }
 347
 348 static ACPI_STATUS
 349 acpi_uhub_find_rh(device_t dev, ACPI_HANDLE *ah)
 350 {
 351         device_t grand;
 352         ACPI_HANDLE gah;
 353
 354         *ah = NULL;
 355         grand = device_get_parent(device_get_parent(dev));
 356
 357         if ((gah = acpi_get_handle(grand)) == NULL)
 358                 return (AE_ERROR);
 359
 360         return (AcpiWalkNamespace(ACPI_TYPE_DEVICE, gah, 1,
 361             acpi_uhub_find_rh_cb, NULL, dev, ah));
 362 }
 363
 364 static ACPI_STATUS
 365 acpi_usb_hub_port_probe_cb(ACPI_HANDLE ah, UINT32 lv, void *ctx, void **rv)
 366 {
 367         ACPI_DEVICE_INFO *devinfo;
 368         device_t dev = ctx;
 369         struct acpi_uhub_softc *sc = device_get_softc(dev);
 370         UINT32 ret;
 371
 372         ret = AcpiGetObjectInfo(ah, &devinfo);
 373         if (ACPI_SUCCESS(ret)) {
 374                 if ((devinfo->Valid & ACPI_VALID_ADR) &&
 375                     (devinfo->Address > 0) &&
 376                     (devinfo->Address <= (uint64_t)sc->nports)) {
 377                         char buf[] = "portXXX";
 378                         struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
 379                         struct sysctl_oid *oid;
 380                         struct sysctl_oid_list *tree;
 381
 382                         snprintf(buf, sizeof(buf), "port%ju",
 383                             (uintmax_t)devinfo->Address);
 384                         oid = SYSCTL_ADD_NODE(ctx,
 385                             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 386                                 OID_AUTO, buf, CTLFLAG_RD | CTLFLAG_MPSAFE,
 387                                 NULL, "port nodes");
 388                         tree = SYSCTL_CHILDREN(oid);
 389                         sc->port[devinfo->Address - 1].handle = ah;
 390                         sc->port[devinfo->Address - 1].upc = 0xffffffff;
 391                         acpi_uhub_parse_upc(dev, devinfo->Address, ah, tree);
 392                         acpi_uhub_parse_pld(dev, devinfo->Address, ah, tree);
 393                         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), tree,
 394                             OID_AUTO, "info",
 395                             CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
 396                             &sc->port[devinfo->Address - 1], 0,
 397                             acpi_uhub_port_sysctl, "A", "Port information");
 398                 }
 399                 AcpiOsFree(devinfo);
 400         }
 401         return (AE_OK);
 402 }
 403
 404 static ACPI_STATUS
 405 acpi_usb_hub_port_probe(device_t dev, ACPI_HANDLE ah)
 406 {
 407         return (AcpiWalkNamespace(ACPI_TYPE_DEVICE,
 408             ah, 1,
 409             acpi_usb_hub_port_probe_cb,
 410             NULL, dev, NULL));
 411 }
 412
 413 static int
 414 acpi_uhub_root_probe(device_t dev)
 415 {
 416         ACPI_STATUS status;
 417         ACPI_HANDLE ah;
 418
 419         if (acpi_disabled("usb"))
 420                 return (ENXIO);
 421
 422         status = acpi_uhub_find_rh(dev, &ah);
 423         if (ACPI_SUCCESS(status) && ah != NULL &&
 424             uhub_probe(dev) <= 0) {
 425                 /* success prior than non-ACPI USB HUB */
 426                 return (BUS_PROBE_DEFAULT + 1);
 427         }
 428         return (ENXIO);
 429 }
 430
 431 static int
 432 acpi_uhub_probe(device_t dev)
 433 {
 434         ACPI_HANDLE ah;
 435
 436         if (acpi_disabled("usb"))
 437                 return (ENXIO);
 438
 439         ah = acpi_get_handle(dev);
 440         if (ah == NULL)
 441                 return (ENXIO);
 442
 443         if (uhub_probe(dev) <= 0) {
 444                 /* success prior than non-ACPI USB HUB */
 445                 return (BUS_PROBE_DEFAULT + 1);
 446         }
 447         return (ENXIO);
 448 }
 449 static int
 450 acpi_uhub_attach_common(device_t dev)
 451 {
 452         struct usb_hub *uh;
 453         struct acpi_uhub_softc *sc = device_get_softc(dev);
 454         ACPI_STATUS status;
 455         int ret = ENXIO;
 456
 457         uh = sc->usc.sc_udev->hub;
 458         sc->nports = uh->nports;
 459         sc->port = malloc(sizeof(struct acpi_uhub_port) * uh->nports,
 460             M_USBDEV, M_WAITOK | M_ZERO);
 461         status = acpi_usb_hub_port_probe(dev, sc->ah);
 462
 463         if (ACPI_SUCCESS(status)){
 464                 ret = 0;
 465         }
 466
 467         return (ret);
 468 }
 469
 470 static int
 471 acpi_uhub_detach(device_t dev)
 472 {
 473         struct acpi_uhub_softc *sc = device_get_softc(dev);
 474
 475         free(sc->port, M_USBDEV);
 476
 477         return (uhub_detach(dev));
 478 }
 479
 480 static int
 481 acpi_uhub_root_attach(device_t dev)
 482 {
 483         int ret;
 484         struct acpi_uhub_softc *sc = device_get_softc(dev);
 485
 486         if (ACPI_FAILURE(acpi_uhub_find_rh(dev, &sc->ah)) ||
 487             (sc->ah == NULL)) {
 488                 return (ENXIO);
 489         }
 490         if ((ret = uhub_attach(dev)) != 0) {
 491                 return (ret);
 492         }
 493
 494         if ((ret = acpi_uhub_attach_common(dev)) != 0) {
 495                 acpi_uhub_detach(dev);
 496         }
 497         return ret;
 498 }
 499
 500 static int
 501 acpi_uhub_attach(device_t dev)
 502 {
 503         int ret;
 504         struct acpi_uhub_softc *sc = device_get_softc(dev);
 505
 506         sc->ah = acpi_get_handle(dev);
 507
 508         if (sc->ah == NULL) {
 509                 return (ENXIO);
 510         }
 511         if ((ret = uhub_attach(dev)) != 0) {
 512                 return (ret);
 513         }
 514
 515         if ((ret = acpi_uhub_attach_common(dev)) != 0) {
 516                 acpi_uhub_detach(dev);
 517         }
 518
 519         return (ret);
 520 }
 521
 522 static int
 523 acpi_uhub_read_ivar(device_t dev, device_t child, int idx, uintptr_t *res)
 524 {
 525         struct hub_result hres;
 526         struct acpi_uhub_softc *sc = device_get_softc(dev);
 527         ACPI_HANDLE ah;
 528
 529         mtx_lock(&Giant);
 530         uhub_find_iface_index(sc->usc.sc_udev->hub, child, &hres);
 531         mtx_unlock(&Giant);
 532
 533         if ((idx == ACPI_IVAR_HANDLE) &&
 534             (hres.portno > 0) &&
 535             (hres.portno <= sc->nports) &&
 536             (ah = sc->port[hres.portno - 1].handle)) {
 537                 *res = (uintptr_t)ah;
 538                 return (0);
 539         }
 540         return (ENXIO);
 541 }
 542
 543 static int
 544 acpi_uhub_child_location_string(device_t parent, device_t child,
 545     char *buf, size_t buflen)
 546 {
 547         ACPI_HANDLE ah;
 548
 549         uhub_child_location_string(parent, child, buf, buflen);
 550
 551         ah = acpi_get_handle(child);
 552         if (ah != NULL) {
 553                 strlcat(buf, " handle=", buflen);
 554                 strlcat(buf, acpi_name(ah), buflen);
 555         }
 556         return (0);
 557 }
 558
 559 static device_method_t acpi_uhub_methods[] = {
 560         DEVMETHOD(device_probe, acpi_uhub_probe),
 561         DEVMETHOD(device_attach, acpi_uhub_attach),
 562         DEVMETHOD(device_detach, acpi_uhub_detach),
 563         DEVMETHOD(bus_child_location_str, acpi_uhub_child_location_string),
 564         DEVMETHOD(bus_read_ivar, acpi_uhub_read_ivar),
 565         DEVMETHOD_END
 566
 567 };
 568
 569 static device_method_t acpi_uhub_root_methods[] = {
 570         DEVMETHOD(device_probe, acpi_uhub_root_probe),
 571         DEVMETHOD(device_attach, acpi_uhub_root_attach),
 572         DEVMETHOD(device_detach, acpi_uhub_detach),
 573         DEVMETHOD(bus_read_ivar, acpi_uhub_read_ivar),
 574         DEVMETHOD(bus_child_location_str, acpi_uhub_child_location_string),
 575         DEVMETHOD_END
 576 };
 577
 578 static devclass_t uhub_devclass;
 579 extern driver_t uhub_driver;
 580 static kobj_class_t uhub_baseclasses[] = {&uhub_driver, NULL};
 581
 582 static driver_t acpi_uhub_driver = {
 583         .name = "uhub",
 584         .methods = acpi_uhub_methods,
 585         .size = sizeof(struct acpi_uhub_softc),
 586         .baseclasses = uhub_baseclasses,
 587 };
 588
 589 static driver_t acpi_uhub_root_driver = {
 590         .name = "uhub",
 591         .methods = acpi_uhub_root_methods,
 592         .size = sizeof(struct acpi_uhub_softc),
 593         .baseclasses = uhub_baseclasses,
 594 };
 595
 596 DRIVER_MODULE(uacpi, uhub, acpi_uhub_driver, uhub_devclass, 0, 0);
 597 DRIVER_MODULE(uacpi, usbus, acpi_uhub_root_driver, uhub_devclass, 0, 0);
 598
 599 MODULE_DEPEND(uacpi, acpi, 1, 1, 1);
 600 MODULE_DEPEND(uacpi, usb, 1, 1, 1);
 601
 602 MODULE_VERSION(uacpi, 1);