usb_hub_acpi.c

Go to the documentation of this file.

/* $FreeBSD$ */
/*-
 * SPDX-License-Identifier: BSD-2-Clause-NetBSD
 *
 * Copyright (c) 1998 The NetBSD Foundation, Inc. All rights reserved.
 * Copyright (c) 1998 Lennart Augustsson. All rights reserved.
 * Copyright (c) 2008-2010 Hans Petter Selasky. All rights reserved.
 * Copyright (c) 2019 Takanori Watanabe.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
 
/*
 * USB spec: http://www.usb.org/developers/docs/usbspec.zip
 */
 
#ifdef USB_GLOBAL_INCLUDE_FILE
#include USB_GLOBAL_INCLUDE_FILE
#else
#include <sys/stdint.h>
#include <sys/stddef.h>
#include <sys/param.h>
#include <sys/queue.h>
#include <sys/types.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include <sys/module.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#include <sys/condvar.h>
#include <sys/sysctl.h>
#include <sys/sx.h>
#include <sys/unistd.h>
#include <sys/callout.h>
#include <sys/malloc.h>
#include <sys/priv.h>
 
#include <dev/usb/usb.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdi_util.h>
 
#define USB_DEBUG_VAR uhub_debug
 
#include <dev/usb/usb_core.h>
#include <dev/usb/usb_process.h>
#include <dev/usb/usb_device.h>
#include <dev/usb/usb_request.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_hub.h>
#include <dev/usb/usb_util.h>
#include <dev/usb/usb_busdma.h>
#include <dev/usb/usb_transfer.h>
#include <dev/usb/usb_dynamic.h>
 
#include <dev/usb/usb_controller.h>
#include <dev/usb/usb_bus.h>
#endif                                  /* USB_GLOBAL_INCLUDE_FILE */
#include <dev/usb/usb_hub_private.h>
#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>
#include <dev/acpica/acpivar.h>
#include <sys/sbuf.h>
 
#define ACPI_PLD_SIZE 20
struct acpi_uhub_port {
        ACPI_HANDLE handle;
#define    ACPI_UPC_CONNECTABLE 0x80000000
#define    ACPI_UPC_PORTTYPE(x) ((x)&0xff)
        uint32_t upc;
        uint8_t pld[ACPI_PLD_SIZE];
};
 
struct acpi_uhub_softc {
        struct uhub_softc usc;
        uint8_t nports;
        ACPI_HANDLE ah;
        struct acpi_uhub_port *port;
};
 
static UINT32
acpi_uhub_find_rh_cb(ACPI_HANDLE ah, UINT32 nl, void *ctx, void **status)
{
        ACPI_DEVICE_INFO *devinfo;
        UINT32 ret;
 
        *status = NULL;
        devinfo = NULL;
 
        ret = AcpiGetObjectInfo(ah, &devinfo);
        if (ACPI_SUCCESS(ret)) {
                if ((devinfo->Valid & ACPI_VALID_ADR) &&
                    (devinfo->Address == 0)) {
                        ret = AE_CTRL_TERMINATE;
                        *status = ah;
                }
                AcpiOsFree(devinfo);
        }
        return (ret);
}
 
static const char *
acpi_uhub_upc_type(uint8_t type)
{
        const char *typelist[] = {"TypeA", "MiniAB", "Express",
                                  "USB3-A", "USB3-B", "USB-MicroB",
                                  "USB3-MicroAB", "USB3-PowerB",
                                  "TypeC-USB2", "TypeC-Switch",
                                  "TypeC-nonSwitch"};
        const int last = sizeof(typelist) / sizeof(typelist[0]);
 
        if (type == 0xff) {
                return "Proprietary";
        }
 
        return (type < last) ? typelist[type] : "Unknown";
}
 
static int
acpi_uhub_parse_upc(device_t dev, unsigned int p, ACPI_HANDLE ah, struct sysctl_oid_list *poid)
{
        ACPI_BUFFER buf;
        struct acpi_uhub_softc *sc = device_get_softc(dev);
        struct acpi_uhub_port *port = &sc->port[p - 1];
 
        buf.Pointer = NULL;
        buf.Length = ACPI_ALLOCATE_BUFFER;
 
        if (AcpiEvaluateObject(ah, "_UPC", NULL, &buf) == AE_OK) {
                ACPI_OBJECT *obj = buf.Pointer;
                UINT64 porttypenum, conn;
                uint8_t *connectable;
 
                acpi_PkgInt(obj, 0, &conn);
                acpi_PkgInt(obj, 1, &porttypenum);
                connectable = conn ? "" : "non";
 
                port->upc = porttypenum;
                port->upc |= (conn) ? (ACPI_UPC_CONNECTABLE) : 0;
 
                if (usb_debug)
                        device_printf(dev, "Port %u %sconnectable %s\n",
                            p, connectable,
                            acpi_uhub_upc_type(porttypenum));
 
                SYSCTL_ADD_U32(
                    device_get_sysctl_ctx(dev),
                    poid, OID_AUTO,
                    "upc",
                    CTLFLAG_RD | CTLFLAG_MPSAFE,
                    SYSCTL_NULL_U32_PTR, port->upc,
                    "UPC value. MSB is visible flag");
        }
        AcpiOsFree(buf.Pointer);
 
        return (0);
}
static int
acpi_uhub_port_sysctl(SYSCTL_HANDLER_ARGS)
{
        struct acpi_uhub_port *port = oidp->oid_arg1;
        struct sbuf sb;
        int error;
 
        sbuf_new_for_sysctl(&sb, NULL, 256, req);
        sbuf_printf(&sb, "Handle %s\n", acpi_name(port->handle));
        if (port->upc == 0xffffffff) {
                sbuf_printf(&sb, "\tNo information\n");
                goto end;
        }
        sbuf_printf(&sb, "\t");
        if (port->upc & ACPI_UPC_CONNECTABLE) {
                sbuf_printf(&sb, "Connectable ");
        }
        sbuf_printf(&sb, "%s port\n", acpi_uhub_upc_type(port->upc & 0xff));
 
        if ((port->pld[0] & 0x80) == 0) {
                sbuf_printf(&sb,
                    "\tColor:#%02x%02x%02x\n",
                    port->pld[1], port->pld[2],
                    port->pld[3]);
        }
        sbuf_printf(&sb, "\tWidth %d mm Height %d mm\n",
            port->pld[4] | (port->pld[5] << 8),
            port->pld[6] | (port->pld[7] << 8));
        if (port->pld[8] & 1) {
                sbuf_printf(&sb, "\tVisible\n");
        }
        if (port->pld[8] & 2) {
                sbuf_printf(&sb, "\tDock\n");
        }
        if (port->pld[8] & 4) {
                sbuf_printf(&sb, "\tLid\n");
        } {
                int panelpos = (port->pld[8] >> 3) & 7;
                const char *panposstr[] = {"Top", "Bottom", "Left",
                                           "Right", "Front", "Back",
                                           "Unknown", "Invalid"};
                const char *shapestr[] = {
                        "Round", "Oval", "Square", "VRect", "HRect",
                        "VTrape", "HTrape", "Unknown", "Chamferd",
                        "Rsvd", "Rsvd", "Rsvd", "Rsvd",
                        "Rsvd", "Rsvd", "Rsvd", "Rsvd"};
 
                sbuf_printf(&sb, "\tPanelPosition: %s\n", panposstr[panelpos]);
                if (panelpos < 6) {
                        const char *posstr[] = {"Upper", "Center",
                        "Lower", "Invalid"};
 
                        sbuf_printf(&sb, "\tVertPosition: %s\n",
                            posstr[(port->pld[8] >> 6) & 3]);
                        sbuf_printf(&sb, "\tHorizPosition: %s\n",
                            posstr[(port->pld[9]) & 3]);
                }
                sbuf_printf(&sb, "\tShape: %s\n",
                    shapestr[(port->pld[9] >> 2) & 0xf]);
                sbuf_printf(&sb, "\tGroup Orientation %s\n",
                    ((port->pld[9] >> 6) & 1) ? "Vertical" :
                    "Horizontal");
                sbuf_printf(&sb, "\tGroupToken %x\n",
                    ((port->pld[9] >> 7)
                    | (port->pld[10] << 1)) & 0xff);
                sbuf_printf(&sb, "\tGroupPosition %x\n",
                    ((port->pld[10] >> 7)
                    | (port->pld[11] << 1)) & 0xff);
                sbuf_printf(&sb, "\t%s %s %s\n",
                    (port->pld[11] & 0x80) ?
                    "Bay" : "",
                    (port->pld[12] & 1) ? "Eject" : "",
                    (port->pld[12] & 2) ? "OSPM" : ""
                    );
        }
        if ((port->pld[0] & 0x7f) >= 2) {
                sbuf_printf(&sb, "\tVOFF%d mm HOFF %dmm",
                    port->pld[16] | (port->pld[17] << 8),
                    port->pld[18] | (port->pld[19] << 8));
        }
 
end:
        error = sbuf_finish(&sb);
        sbuf_delete(&sb);
        return (error);
}
 
static int
acpi_uhub_parse_pld(device_t dev, unsigned int p, ACPI_HANDLE ah, struct sysctl_oid_list *tree)
{
        ACPI_BUFFER buf;
        struct acpi_uhub_softc *sc = device_get_softc(dev);
        struct acpi_uhub_port *port = &sc->port[p - 1];
 
        buf.Pointer = NULL;
        buf.Length = ACPI_ALLOCATE_BUFFER;
 
        if (AcpiEvaluateObject(ah, "_PLD", NULL, &buf) == AE_OK) {
                ACPI_OBJECT *obj;
                unsigned char *resbuf;
                int len;
 
                obj = buf.Pointer;
 
                if (obj->Type == ACPI_TYPE_PACKAGE
                    && obj->Package.Elements[0].Type == ACPI_TYPE_BUFFER) {
                        ACPI_OBJECT *obj1;
 
                        obj1 = &obj->Package.Elements[0];
                        len = obj1->Buffer.Length;
                        resbuf = obj1->Buffer.Pointer;
                } else if (obj->Type == ACPI_TYPE_BUFFER) {
                        len = obj->Buffer.Length;
                        resbuf = obj->Buffer.Pointer;
                } else {
                        goto skip;
                }
                len = (len < ACPI_PLD_SIZE) ? len : ACPI_PLD_SIZE;
                memcpy(port->pld, resbuf, len);
                SYSCTL_ADD_OPAQUE(
                    device_get_sysctl_ctx(dev), tree, OID_AUTO,
                    "pldraw", CTLFLAG_RD | CTLFLAG_MPSAFE,
                    port->pld, len, "A", "Raw PLD value");
 
                if (usb_debug) {
                        device_printf(dev, "Revision:%d\n",
                            resbuf[0] & 0x7f);
                        if ((resbuf[0] & 0x80) == 0) {
                                device_printf(dev,
                                    "Color:#%02x%02x%02x\n",
                                    resbuf[1], resbuf[2],
                                    resbuf[3]);
                        }
                        device_printf(dev, "Width %d mm Height %d mm\n",
                            resbuf[4] | (resbuf[5] << 8),
                            resbuf[6] | (resbuf[7] << 8));
                        if (resbuf[8] & 1) {
                                device_printf(dev, "Visible\n");
                        }
                        if (resbuf[8] & 2) {
                                device_printf(dev, "Dock\n");
                        }
                        if (resbuf[8] & 4) {
                                device_printf(dev, "Lid\n");
                        }
                        device_printf(dev, "PanelPosition: %d\n",
                            (resbuf[8] >> 3) & 7);
                        device_printf(dev, "VertPosition: %d\n",
                            (resbuf[8] >> 6) & 3);
                        device_printf(dev, "HorizPosition: %d\n",
                            (resbuf[9]) & 3);
                        device_printf(dev, "Shape: %d\n",
                            (resbuf[9] >> 2) & 0xf);
                        device_printf(dev, "80: %02x, %02x, %02x\n",
                            resbuf[9], resbuf[10], resbuf[11]);
                        device_printf(dev, "96: %02x, %02x, %02x, %02x\n",
                            resbuf[12], resbuf[13],
                            resbuf[14], resbuf[15]);
 
                        if ((resbuf[0] & 0x7f) >= 2) {
                                device_printf(dev, "VOFF%d mm HOFF %dmm",
                                    resbuf[16] | (resbuf[17] << 8),
                                    resbuf[18] | (resbuf[19] << 8));
                        }
                }
        skip:
                AcpiOsFree(buf.Pointer);
        }
        return (0);
}
 
static ACPI_STATUS
acpi_uhub_find_rh(device_t dev, ACPI_HANDLE *ah)
{
        device_t grand;
        ACPI_HANDLE gah;
 
        *ah = NULL;
        grand = device_get_parent(device_get_parent(dev));
 
        if ((gah = acpi_get_handle(grand)) == NULL)
                return (AE_ERROR);
 
        return (AcpiWalkNamespace(ACPI_TYPE_DEVICE, gah, 1,
            acpi_uhub_find_rh_cb, NULL, dev, ah));
}
 
static ACPI_STATUS
acpi_usb_hub_port_probe_cb(ACPI_HANDLE ah, UINT32 lv, void *ctx, void **rv)
{
        ACPI_DEVICE_INFO *devinfo;
        device_t dev = ctx;
        struct acpi_uhub_softc *sc = device_get_softc(dev);
        UINT32 ret;
 
        ret = AcpiGetObjectInfo(ah, &devinfo);
        if (ACPI_SUCCESS(ret)) {
                if ((devinfo->Valid & ACPI_VALID_ADR) &&
                    (devinfo->Address > 0) &&
                    (devinfo->Address <= (uint64_t)sc->nports)) {
                        char buf[] = "portXXX";
                        struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
                        struct sysctl_oid *oid;
                        struct sysctl_oid_list *tree;
                        
                        snprintf(buf, sizeof(buf), "port%ju",
                            (uintmax_t)devinfo->Address);
                        oid = SYSCTL_ADD_NODE(ctx,
                            SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
                                OID_AUTO, buf, CTLFLAG_RD | CTLFLAG_MPSAFE,
                                NULL, "port nodes");
                        tree = SYSCTL_CHILDREN(oid);
                        sc->port[devinfo->Address - 1].handle = ah;
                        sc->port[devinfo->Address - 1].upc = 0xffffffff;
                        acpi_uhub_parse_upc(dev, devinfo->Address, ah, tree);
                        acpi_uhub_parse_pld(dev, devinfo->Address, ah, tree);
                        SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), tree,
                            OID_AUTO, "info",
                            CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
                            &sc->port[devinfo->Address - 1], 0,
                            acpi_uhub_port_sysctl, "A", "Port information");
                }
                AcpiOsFree(devinfo);
        }
        return (AE_OK);
}
 
static ACPI_STATUS
acpi_usb_hub_port_probe(device_t dev, ACPI_HANDLE ah)
{
        return (AcpiWalkNamespace(ACPI_TYPE_DEVICE,
            ah, 1,
            acpi_usb_hub_port_probe_cb,
            NULL, dev, NULL));
}
 
static int
acpi_uhub_root_probe(device_t dev)
{
        ACPI_STATUS status;
        ACPI_HANDLE ah;
 
        if (acpi_disabled("usb"))
                return (ENXIO);
 
        status = acpi_uhub_find_rh(dev, &ah);
        if (ACPI_SUCCESS(status) && ah != NULL &&
            uhub_probe(dev) <= 0) {
                /* success prior than non-ACPI USB HUB */
                return (BUS_PROBE_DEFAULT + 1);
        }
        return (ENXIO);
}
 
static int
acpi_uhub_probe(device_t dev)
{
        ACPI_HANDLE ah;
 
        if (acpi_disabled("usb"))
                return (ENXIO);
 
        ah = acpi_get_handle(dev);
        if (ah == NULL)
                return (ENXIO);
 
        if (uhub_probe(dev) <= 0) {
                /* success prior than non-ACPI USB HUB */
                return (BUS_PROBE_DEFAULT + 1);
        }
        return (ENXIO);
}
static int
acpi_uhub_attach_common(device_t dev)
{
        struct usb_hub *uh;
        struct acpi_uhub_softc *sc = device_get_softc(dev);
        ACPI_STATUS status;
        int ret = ENXIO;
 
        uh = sc->usc.sc_udev->hub;
        sc->nports = uh->nports;
        sc->port = malloc(sizeof(struct acpi_uhub_port) * uh->nports,
            M_USBDEV, M_WAITOK | M_ZERO);
        status = acpi_usb_hub_port_probe(dev, sc->ah);
 
        if (ACPI_SUCCESS(status)){
                ret = 0;
        } 
 
        return (ret);
}
 
static int
acpi_uhub_detach(device_t dev)
{
        struct acpi_uhub_softc *sc = device_get_softc(dev);
 
        free(sc->port, M_USBDEV);
 
        return (uhub_detach(dev));
}
 
static int
acpi_uhub_root_attach(device_t dev)
{
        int ret;
        struct acpi_uhub_softc *sc = device_get_softc(dev);
 
        if (ACPI_FAILURE(acpi_uhub_find_rh(dev, &sc->ah)) ||
            (sc->ah == NULL)) {
                return (ENXIO);
        }
        if ((ret = uhub_attach(dev)) != 0) {
                return (ret);
        }
 
        if ((ret = acpi_uhub_attach_common(dev)) != 0) {
                acpi_uhub_detach(dev);
        }
        return ret;
}
 
static int
acpi_uhub_attach(device_t dev)
{
        int ret;
        struct acpi_uhub_softc *sc = device_get_softc(dev);
 
        sc->ah = acpi_get_handle(dev);
 
        if (sc->ah == NULL) {
                return (ENXIO);
        }
        if ((ret = uhub_attach(dev)) != 0) {
                return (ret);
        }
 
        if ((ret = acpi_uhub_attach_common(dev)) != 0) {
                acpi_uhub_detach(dev);
        }
 
        return (ret);
}
 
static int
acpi_uhub_read_ivar(device_t dev, device_t child, int idx, uintptr_t *res)
{
        struct hub_result hres;
        struct acpi_uhub_softc *sc = device_get_softc(dev);
        ACPI_HANDLE ah;
 
        bus_topo_lock();
        uhub_find_iface_index(sc->usc.sc_udev->hub, child, &hres);
        bus_topo_unlock();
 
        if ((idx == ACPI_IVAR_HANDLE) &&
            (hres.portno > 0) &&
            (hres.portno <= sc->nports) &&
            (ah = sc->port[hres.portno - 1].handle)) {
                *res = (uintptr_t)ah;
                return (0);
        }
        return (ENXIO);
}
 
static int
acpi_uhub_child_location(device_t parent, device_t child, struct sbuf *sb)
{
        ACPI_HANDLE ah;
 
        uhub_child_location(parent, child, sb);
 
        ah = acpi_get_handle(child);
        if (ah != NULL)
                sbuf_printf(sb, " handle=%s", acpi_name(ah));
        return (0);
}
 
static int
acpi_uhub_get_device_path(device_t bus, device_t child, const char *locator, struct sbuf *sb)
{
        if (strcmp(locator, BUS_LOCATOR_ACPI) == 0)
                return (acpi_get_acpi_device_path(bus, child, locator, sb));
 
        /* Otherwise call the parent class' method. */
        return (uhub_get_device_path(bus, child, locator, sb));
}
 
static device_method_t acpi_uhub_methods[] = {
        DEVMETHOD(device_probe, acpi_uhub_probe),
        DEVMETHOD(device_attach, acpi_uhub_attach),
        DEVMETHOD(device_detach, acpi_uhub_detach),
        DEVMETHOD(bus_child_location, acpi_uhub_child_location),
        DEVMETHOD(bus_get_device_path, acpi_uhub_get_device_path),
        DEVMETHOD(bus_read_ivar, acpi_uhub_read_ivar),
        DEVMETHOD_END
 
};
 
static device_method_t acpi_uhub_root_methods[] = {
        DEVMETHOD(device_probe, acpi_uhub_root_probe),
        DEVMETHOD(device_attach, acpi_uhub_root_attach),
        DEVMETHOD(device_detach, acpi_uhub_detach),
        DEVMETHOD(bus_read_ivar, acpi_uhub_read_ivar),
        DEVMETHOD(bus_child_location, acpi_uhub_child_location),
        DEVMETHOD(bus_get_device_path, acpi_uhub_get_device_path),
        DEVMETHOD_END
};
 
static devclass_t uhub_devclass;
extern driver_t uhub_driver;
static kobj_class_t uhub_baseclasses[] = {&uhub_driver, NULL};
 
static driver_t acpi_uhub_driver = {
        .name = "uhub",
        .methods = acpi_uhub_methods,
        .size = sizeof(struct acpi_uhub_softc),
        .baseclasses = uhub_baseclasses,
};
 
static driver_t acpi_uhub_root_driver = {
        .name = "uhub",
        .methods = acpi_uhub_root_methods,
        .size = sizeof(struct acpi_uhub_softc),
        .baseclasses = uhub_baseclasses,
};
 
DRIVER_MODULE(uacpi, uhub, acpi_uhub_driver, uhub_devclass, 0, 0);
DRIVER_MODULE(uacpi, usbus, acpi_uhub_root_driver, uhub_devclass, 0, 0);
 
MODULE_DEPEND(uacpi, acpi, 1, 1, 1);
MODULE_DEPEND(uacpi, usb, 1, 1, 1);
 
MODULE_VERSION(uacpi, 1);