/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2016 Joyent, Inc.
 */

#include <stddef.h>
#include <sys/mdb_modapi.h>
#include <mdb/mdb_ks.h>

#include <sys/usb/usba.h>
#include <sys/ddi_impldefs.h>
#include <sys/usb/usba/usba_types.h>
#include <sys/usb/usba/usba_impl.h>
#include <sys/usb/usba/hcdi_impl.h>
#include <sys/usb/hubd/hub.h>
#include <sys/usb/hubd/hubdvar.h>
#include <sys/file.h>
#include <sys/sunndi.h>
#include <unistd.h>


/*
 * Prototypes
 */
/* usba.c */
extern uintptr_t mdb_usba_get_usba_device(uintptr_t);
extern uintptr_t mdb_usba_hcdi_get_hcdi(struct dev_info *);

/*
 * Defines
 */
/* dcmd options */
#define USB_DUMP_VERBOSE        0x01
#define USB_DUMP_ACTIVE_PIPES   0x02

/* Hardcoded slop factor designed into debug buf logic */
#define USB_DEBUG_SIZE_EXTRA_ALLOC 8


/*
 * Callback arg struct for find_dip (callback func used in usba_device2devinfo).
 */
typedef struct usba_device2devinfo_data {
        uintptr_t       u2d_target_usb_dev_p;   /* one we're looking for */
        uintptr_t       *u2d_dip_addr;          /* Where to store result */
        boolean_t       u2d_found;              /* Match found */
} usba_device2devinfo_cbdata_t;


/*
 * Callback for usba_device2dip.
 * Callback called from the devinfo_children walk invoked in usba_device2dip.
 *
 * For the current dip, get the (potential) pointer to its usba_device_t
 * struct.
 * See if this pointer matches the address of the usba_device_t we're looking
 * for (passed in as usb_dev_p).  If so, stuff its value in u2d_dip_addr,
 * and terminate the walk.
 *
 * - dip_addr is the address in core of the dip currently being processed by the
 * walk
 * - local_dip is a pointer to a copy of the struct dev_info in local memory
 * - cb_data is the addr of the callback arg the walker was invoked with
 * (passed through transparently from walk invoker).
 *
 * Returns:
 * - WALK_NEXT on success (match not found yet)
 * - WALK_ERR on errors.
 * - WALK_DONE is returned, cb_data.found is set to TRUE, and
 * *cb_data.u2d_dip_addr is set to the matched dip addr if a dip corresponding
 * to the desired usba_device_t* is found.
 */
/*ARGSUSED*/
static int
find_dip(uintptr_t dip_addr, const void *local_dip, void *cb_arg)
{
        uintptr_t                       cur_usb_dev;
        usba_device2devinfo_cbdata_t    *cb_data =
            (usba_device2devinfo_cbdata_t *)cb_arg;

        if ((cur_usb_dev = mdb_usba_get_usba_device(dip_addr)) == 0) {
                /*
                 * If there's no corresponding usba_device_t, this dip isn't
                 * a usb node.  Might be an sd node.  Ignore it.
                 */

                return (WALK_NEXT);
        }

        if (cur_usb_dev == cb_data->u2d_target_usb_dev_p) {
                *cb_data->u2d_dip_addr = dip_addr;
                cb_data->u2d_found = TRUE;

                return (WALK_DONE);
        }

        return (WALK_NEXT);
}


/*
 * Given a usba_device pointer, figure out which dip is associated with it.
 * Relies on usba_device.usb_root_hub_dip being accurate.
 *
 * - usb_dev_addr is a pointer to a usba_device_t in core.
 * - dip_addr is the address of a uintptr_t to receive the address in core
 * of the found dip (if any).
 *
 * Returns:
 *  0 on success (no match found)
 *  1 on success (match found)
 * -1 on errors.
 */
static int
usba_device2dip(uintptr_t usb_dev_addr, uintptr_t *dip_addr)
{
        usba_device_t                   usb_dev;
        usba_device2devinfo_cbdata_t    cb_data;

        /*
         * Walk all USB children of the root hub devinfo.
         * The callback func looks for a match on the usba_device address.
         */
        cb_data.u2d_target_usb_dev_p = usb_dev_addr;
        cb_data.u2d_dip_addr = dip_addr;
        cb_data.u2d_found = FALSE;

        if (mdb_vread(&usb_dev, sizeof (usba_device_t),
            usb_dev_addr) == -1) {
                mdb_warn("failed to read usba_device struct");

                return (-1);
        }

        /*
         * Walk devinfo children starting with the root hub node,
         * looking for a match on the usba_device pointer (which is what
         * find_dip does).
         * Result is placed in cb_data.dip_addr.
         */
        if (mdb_pwalk("devinfo_children", find_dip, &cb_data,
            (uintptr_t)usb_dev.usb_root_hub_dip) != 0) {
                mdb_warn("failed to walk devinfo_children");

                return (-1);
        }

        if (cb_data.u2d_found == TRUE) {

                return (1);
        }

        return (0);
}


/*
 * Generic walker usba_list_entry_t walker.
 * Works for any usba_list_entry_t list.
 */
int
usba_list_walk_init(mdb_walk_state_t *wsp)
{
        /* Must have a start addr.  */
        if (wsp->walk_addr == 0) {
                mdb_warn("not a global walk.  Starting address required\n");

                return (WALK_ERR);
        }

        return (WALK_NEXT);
}


/*
 * Generic list walker step routine.
 * NOTE: multiple walkers share this routine.
 */
int
usba_list_walk_step(mdb_walk_state_t *wsp)
{
        int                     status;
        usba_list_entry_t       list_entry;

        if (mdb_vread(&list_entry, sizeof (usba_list_entry_t),
            (uintptr_t)wsp->walk_addr) == -1) {
                mdb_warn("failed to read usba_list_entry_t at %p",
                    wsp->walk_addr);

                return (WALK_ERR);
        }

        status = wsp->walk_callback(wsp->walk_addr, &list_entry,
            wsp->walk_cbdata);
        wsp->walk_addr = (uintptr_t)list_entry.next;

        /* Check if we're at the last element */
        if (wsp->walk_addr == 0) {

                return (WALK_DONE);
        }

        return (status);
}


/*
 * usb_pipe_handle walker
 * Given a pointer to a usba_device_t, walk the array of endpoint
 * pipe_handle lists.
 * For each list, traverse the list, invoking the callback on each element.
 *
 * Note this function takes the address of a usba_device struct (which is
 * easily obtainable), but actually traverses a sub-portion of the struct
 * (which address is not so easily obtainable).
 */
int
usb_pipe_handle_walk_init(mdb_walk_state_t *wsp)
{
        if (wsp->walk_addr == 0) {
                mdb_warn("not a global walk; usba_device_t required\n");

                return (WALK_ERR);
        }

        wsp->walk_data = mdb_alloc((sizeof (usba_ph_impl_t)) * USBA_N_ENDPOINTS,
            UM_SLEEP | UM_GC);

        /*
         * Read the usb_ph_list array into local memory.
         * Set start address to first element/endpoint in usb_pipehandle_list
         */
        if (mdb_vread(wsp->walk_data,
            (sizeof (usba_ph_impl_t)) * USBA_N_ENDPOINTS,
            (uintptr_t)((size_t)(wsp->walk_addr) +
            offsetof(usba_device_t, usb_ph_list))) == -1) {
                mdb_warn("failed to read usb_pipehandle_list at %p",
                    wsp->walk_addr);

                return (WALK_ERR);
        }

        wsp->walk_arg = 0;

        return (WALK_NEXT);
}


int
usb_pipe_handle_walk_step(mdb_walk_state_t *wsp)
{
        int status;
        usba_ph_impl_t *impl_list = (usba_ph_impl_t *)(wsp->walk_data);
        intptr_t index = (intptr_t)wsp->walk_arg;

        /* Find the first valid endpoint, starting from where we left off. */
        while ((index < USBA_N_ENDPOINTS) &&
            (impl_list[index].usba_ph_data == NULL)) {
                index++;
        }

        /* No more valid endpoints. */
        if (index >= USBA_N_ENDPOINTS) {

                return (WALK_DONE);
        }

        status = wsp->walk_callback((uintptr_t)impl_list[index].usba_ph_data,
            wsp->walk_data, wsp->walk_cbdata);

        /* Set up to start at next pipe handle next time. */
        wsp->walk_arg = (void *)(index + 1);

        return (status);
}


/*
 * Given the address of a usba_pipe_handle_data_t, dump summary info.
 */
/*ARGSUSED*/
int
usb_pipe_handle(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
        char                    *dir, *type, *state;
        usb_ep_descr_t          ept_descr;
        usba_pipe_handle_data_t pipe_handle;
        usba_ph_impl_t          ph_impl;

        if (!(flags & DCMD_ADDRSPEC)) {

                return (DCMD_USAGE);
        }

        if (mdb_vread(&pipe_handle,
            sizeof (usba_pipe_handle_data_t), addr) == -1) {
                mdb_warn("failed to read pipe handle at %p", addr);

                return (DCMD_ERR);
        }

        if (mdb_vread(&ph_impl, sizeof (usba_ph_impl_t),
            (uintptr_t)pipe_handle.p_ph_impl) == -1) {
                state = "*******";
        } else {
                switch (ph_impl.usba_ph_state) {
                case USB_PIPE_STATE_CLOSED:
                        state = "CLOSED ";
                        break;

                case USB_PIPE_STATE_IDLE:
                        state = "IDLE   ";
                        break;

                case USB_PIPE_STATE_ACTIVE:
                        state = "ACTIVE ";
                        break;

                case USB_PIPE_STATE_ERROR:
                        state = "ERROR  ";
                        break;

                case USB_PIPE_STATE_CLOSING:
                        state = "CLOSING";
                        break;

                default:
                        state = "ILLEGAL";
                        break;
                }
        }

        bcopy(&pipe_handle.p_ep, &ept_descr, sizeof (usb_ep_descr_t));

        if (DCMD_HDRSPEC(flags)) {
                mdb_printf("\n    %<u>%-3s %5s %3s %7s %-?s %-?s %-?s%</u>\n",
                    "EP", "TYPE ", "DIR", "STATE  ", "P_HANDLE", "P_POLICY",
                    "EP DESCR");
        }

        dir = ((ept_descr.bEndpointAddress & USB_EP_DIR_MASK) &
            USB_EP_DIR_IN) ? "In " : "Out";
        switch (ept_descr.bmAttributes & USB_EP_ATTR_MASK) {
        case USB_EP_ATTR_CONTROL:
                type = "Cntrl";
                break;

        case USB_EP_ATTR_ISOCH:
                type = "Isoch";
                break;

        case USB_EP_ATTR_BULK:
                type = "Bulk ";
                break;

        case USB_EP_ATTR_INTR:
                type = "Intr ";
                break;

        default:
                type = "*****";
                break;
        }

        mdb_printf("    %3d %5s %3s %7s %-?p %-?p %-?p\n",
            ept_descr.bEndpointAddress & USB_EP_NUM_MASK, type, dir, state,
            addr, addr + offsetof(usba_pipe_handle_data_t, p_policy),
            addr + offsetof(usba_pipe_handle_data_t, p_ep));

        return (DCMD_OK);
}


/*
 * usba_device walker:
 *
 * walks the chain of usba_device structs headed by usba_device_list in usba.c
 * NOTE: It uses the generic list walk step routine usba_list_walk_step.
 * No walk_fini routine is needed.
 */
int
usba_device_walk_init(mdb_walk_state_t *wsp)
{
        usba_list_entry_t       list_entry;

        if (wsp->walk_addr != 0) {
                mdb_warn(
                    "global walk only.  Must be invoked without an address\n");

                return (WALK_ERR);
        }

        if (mdb_readvar(&list_entry, "usba_device_list") == -1) {
                mdb_warn("failed to read usba_device_list");

                return (WALK_ERR);
        }

        /* List head is not part of usba_device_t, get first usba_device_t */
        wsp->walk_addr = (uintptr_t)list_entry.next;

        return (WALK_NEXT);
}

int
usba_hubd_walk_init(mdb_walk_state_t *wsp)
{
        if (wsp->walk_addr != 0) {
                mdb_warn("hubd only supports global walks.\n");
                return (WALK_ERR);
        }

        if (mdb_layered_walk("usba_device", wsp) == -1) {
                mdb_warn("couldn't walk 'usba_device'");
                return (WALK_ERR);
        }

        return (WALK_NEXT);
}

/*
 * Getting the hub state is annoying. The root hubs are stored on dev_info_t
 * while the normal hubs are stored as soft state.
 */
int
usba_hubd_walk_step(mdb_walk_state_t *wsp)
{
        usba_device_t ud;
        hubd_t hubd;
        struct dev_info dev_info;
        uintptr_t state_addr;

        if (mdb_vread(&ud, sizeof (ud), wsp->walk_addr) != sizeof (ud)) {
                mdb_warn("failed to read usba_device_t at %p", wsp->walk_addr);
                return (WALK_ERR);
        }

        if (ud.usb_root_hubd != NULL) {
                if (mdb_vread(&hubd, sizeof (hubd),
                    (uintptr_t)ud.usb_root_hubd) != sizeof (hubd)) {
                        mdb_warn("failed to read hubd at %p", ud.usb_root_hubd);
                        return (WALK_ERR);
                }
                return (wsp->walk_callback((uintptr_t)ud.usb_root_hubd, &hubd,
                    wsp->walk_cbdata));
        }

        if (ud.usb_hubdi == NULL)
                return (WALK_NEXT);

        /*
         * For non-root hubs, the hubd_t is stored in the soft state. Figure out
         * the instance from the dev_info_t and then get its soft state.
         */
        if (mdb_vread(&dev_info, sizeof (struct dev_info),
            (uintptr_t)ud.usb_dip) != sizeof (struct dev_info)) {
                mdb_warn("failed to read dev_info_t for device %p at %p",
                    wsp->walk_addr, ud.usb_dip);
                return (WALK_ERR);
        }

        if (mdb_get_soft_state_byname("hubd_statep", dev_info.devi_instance,
            &state_addr, &hubd, sizeof (hubd)) == -1) {
                mdb_warn("failed to read hubd soft state for instance %d from "
                    "usb device %p", dev_info.devi_instance, wsp->walk_addr);
                return (WALK_ERR);
        }

        return (wsp->walk_callback(state_addr, &hubd, wsp->walk_cbdata));
}

/*
 * usba_device dcmd
 *      Given the address of a usba_device struct, dump summary info
 *      -v:     Print more (verbose) info
 *      -p:     Walk/dump all open pipes for this usba_device
 */
/*ARGSUSED*/
int
usba_device(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
        int             status;
        char            pathname[MAXNAMELEN];
        char            dname[MODMAXNAMELEN] = "<unatt>"; /* Driver name */
        char            drv_statep[MODMAXNAMELEN+ 10];
        uint_t          usb_flag  = 0;
        boolean_t       no_driver_attached = FALSE;
        uintptr_t       dip_addr;
        struct dev_info devinfo;

        if (!(flags & DCMD_ADDRSPEC)) {
                /* Global walk */
                if (mdb_walk_dcmd("usba_device", "usba_device", argc,
                    argv) == -1) {
                        mdb_warn("failed to walk usba_device");

                        return (DCMD_ERR);
                }

                return (DCMD_OK);
        }

        if (mdb_getopts(argc, argv,
            'p', MDB_OPT_SETBITS, USB_DUMP_ACTIVE_PIPES, &usb_flag,
            'v', MDB_OPT_SETBITS, USB_DUMP_VERBOSE, &usb_flag, NULL) != argc) {

                return (DCMD_USAGE);
        }

        if (usb_flag && !(DCMD_HDRSPEC(flags))) {
                mdb_printf("\n");
        }

        if (DCMD_HDRSPEC(flags)) {
                mdb_printf("%<u>%-15s %4s %-?s %-42s%</u>\n",
                    "NAME", "INST", "DIP", "PATH                             ");
        }

        status = usba_device2dip(addr, &dip_addr);
        /*
         * -1 = error
         * 0 = no error, no match
         * 1 = no error, match
         */
        if (status != 1) {
                if (status == -1) {
                        mdb_warn("error looking for dip for usba_device %p",
                            addr);
                } else {
                        mdb_warn("failed to find dip for usba_device %p\n",
                            addr);
                }
                mdb_warn("dip and statep unobtainable\n");

                return (DCMD_ERR);
        }

        /* Figure out what driver (name) is attached to this node. */
        (void) mdb_devinfo2driver(dip_addr, (char *)dname, sizeof (dname));

        if (mdb_vread(&devinfo, sizeof (struct dev_info),
            dip_addr) == -1) {
                mdb_warn("failed to read devinfo");

                return (DCMD_ERR);
        }

        if (!(DDI_CF2(&devinfo))) {
                no_driver_attached = TRUE;
        }

        (void) mdb_ddi_pathname(dip_addr, pathname, sizeof (pathname));
        mdb_printf("%-15s %2d   %-?p %s\n", dname, devinfo.devi_instance,
            dip_addr, pathname);

        if (usb_flag & USB_DUMP_VERBOSE) {
                int             i;
                uintptr_t       statep = 0;
                char            *string_descr;
                char            **config_cloud, **conf_str_descr;
                usb_dev_descr_t usb_dev_descr;
                usba_device_t   usba_device_struct;

                if (mdb_vread(&usba_device_struct,
                    sizeof (usba_device_t), addr) == -1) {
                        mdb_warn("failed to read usba_device struct");

                        return (DCMD_ERR);
                }

                mdb_printf("    usba_device: %-16p\n\n", (usba_device_t *)addr);

                if (mdb_vread(&usb_dev_descr, sizeof (usb_dev_descr),
                    (uintptr_t)usba_device_struct.usb_dev_descr) == -1) {
                        mdb_warn("failed to read usb_dev_descr_t struct");

                        return (DCMD_ERR);
                }

                mdb_printf("\n    idVendor: 0x%04x idProduct: 0x%04x "
                    "usb_addr: 0x%02x\n", usb_dev_descr.idVendor,
                    usb_dev_descr.idProduct, usba_device_struct.usb_addr);

                /* Get the string descriptor string into local space. */
                string_descr = (char *)mdb_alloc(USB_MAXSTRINGLEN, UM_GC);

                if (usba_device_struct.usb_mfg_str == NULL) {
                        (void) strcpy(string_descr, "<No Manufacturer String>");
                } else {
                        if (mdb_readstr(string_descr, USB_MAXSTRINGLEN,
                            (uintptr_t)usba_device_struct.usb_mfg_str) == -1) {
                                mdb_warn("failed to read manufacturer "
                                    "string descriptor");
                                (void) strcpy(string_descr, "???");
                        }
                }
                mdb_printf("\n    Manufacturer String:\t%s\n", string_descr);

                if (usba_device_struct.usb_product_str == NULL) {
                        (void) strcpy(string_descr, "<No Product String>");
                } else {
                        if (mdb_readstr(string_descr, USB_MAXSTRINGLEN,
                            (uintptr_t)usba_device_struct.usb_product_str) ==
                            -1) {
                                mdb_warn("failed to read product string "
                                    "descriptor");
                                (void) strcpy(string_descr, "???");
                        }
                }
                mdb_printf("    Product String:\t\t%s\n", string_descr);

                if (usba_device_struct.usb_serialno_str == NULL) {
                        (void) strcpy(string_descr, "<No SerialNumber String>");
                } else {
                        if (mdb_readstr(string_descr, USB_MAXSTRINGLEN,
                            (uintptr_t)usba_device_struct.usb_serialno_str) ==
                            -1) {
                                mdb_warn("failed to read serial number string "
                                    "descriptor");
                                (void) strcpy(string_descr, "???");
                        }
                }
                mdb_printf("    SerialNumber String:\t%s\n", string_descr);

                if (no_driver_attached) {
                        mdb_printf("\n");
                } else {
                        mdb_printf("      state_p: ");

                        /*
                         * Given the dip, find the associated statep. The
                         * convention to generate this soft state anchor is:
                         *      <driver_name>_statep
                         */
                        (void) mdb_snprintf(drv_statep, sizeof (drv_statep),
                            "%s_statep", dname);
                        if (mdb_devinfo2statep(dip_addr, drv_statep,
                            &statep) == -1) {
                                mdb_warn("failed to find %s state struct for "
                                    "dip %p", drv_statep, dip_addr);

                                return (DCMD_ERR);
                        }
                        mdb_printf("%-?p\n", statep);
                }

                config_cloud = (char **)mdb_alloc(sizeof (void *) *
                    usba_device_struct.usb_n_cfgs, UM_GC);

                conf_str_descr = (char **)mdb_alloc(sizeof (void *) *
                    usba_device_struct.usb_n_cfgs, UM_GC);

                if ((usba_device_struct.usb_cfg_array) &&
                    (usba_device_struct.usb_cfg_str_descr)) {
                        if ((mdb_vread(config_cloud,  sizeof (void *) *
                            usba_device_struct.usb_n_cfgs,
                            (uintptr_t)usba_device_struct.usb_cfg_array) ==
                            -1) || (mdb_vread(conf_str_descr, sizeof (void *)
                            * usba_device_struct.usb_n_cfgs, (uintptr_t)
                            usba_device_struct.usb_cfg_str_descr)) == -1) {

                                mdb_warn("failed to read config cloud "
                                    "pointers");

                        } else {

                                mdb_printf("\n    Device Config Clouds:\n"
                                    "    Index\tConfig\t\tConfiguration "
                                    "String\n"
                                    "    -----\t------\t\t"
                                    "--------------------\n");

                                for (i = 0; i < usba_device_struct.usb_n_cfgs;
                                    i++) {
                                        if (mdb_readstr(string_descr,
                                            USB_MAXSTRINGLEN,
                                            (uintptr_t)conf_str_descr[i]) ==
                                            -1) {
                                                (void) strcpy(string_descr,
                                                    "<No Configuration "
                                                    "String>");
                                        }
                                        mdb_printf("    %4d\t0x%p\t%s\n", i,
                                            config_cloud[i], string_descr);
                                }
                        }
                }

                mdb_printf("\n    Active configuration index: %d\n",
                    usba_device_struct.usb_active_cfg_ndx);
        }

        if (usb_flag & USB_DUMP_ACTIVE_PIPES) {

                if (mdb_pwalk_dcmd("usb_pipe_handle", "usb_pipe_handle",
                    0, NULL, addr) == -1) {
                        mdb_warn("failed to walk usb_pipe_handle");
                        return (DCMD_ERR);
                }
        }

        return (DCMD_OK);
}


/*
 * Dump the contents of the usba_debug_buf, from the oldest to newest,
 * wrapping around if necessary.
 */
/*ARGSUSED*/
int
usba_debug_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
        char    *debug_buf_addr;        /* addr in core */
        char    *local_debug_buf;       /* local copy of buf */
        int     debug_buf_size;
        char    *term_p;
        int     being_cleared;

        if (flags & DCMD_ADDRSPEC) {

                return (DCMD_USAGE);
        }

        if (mdb_readvar(&being_cleared, "usba_clear_debug_buf_flag") ==
            -1) {
                mdb_warn("failed to read usba_clear_debug_buf_flag");

                return (DCMD_ERR);
        }
        if (being_cleared) {

                return (DCMD_OK);
        }

        if (mdb_readvar(&debug_buf_addr, "usba_debug_buf") == -1) {
                mdb_warn("failed to read usba_debug_buf");

                return (DCMD_ERR);
        }

        if (debug_buf_addr == NULL) {
                mdb_warn("usba_debug_buf not allocated\n");

                return (DCMD_OK);
        }


        if (mdb_readvar(&debug_buf_size, "usba_debug_buf_size") == -1) {
                mdb_warn("failed to read usba_debug_buf_size");

                return (DCMD_ERR);
        }

        debug_buf_size += USB_DEBUG_SIZE_EXTRA_ALLOC;
        local_debug_buf = (char *)mdb_alloc(debug_buf_size, UM_SLEEP | UM_GC);

        if ((mdb_vread(local_debug_buf, debug_buf_size,
            (uintptr_t)debug_buf_addr)) == -1) {
                mdb_warn("failed to read usba_debug_buf at %p",
                    local_debug_buf);

                return (DCMD_ERR);
        }
        local_debug_buf[debug_buf_size - 1] = '\0';

        if (strlen(local_debug_buf) == 0) {

                return (DCMD_OK);
        }

        if ((term_p = strstr(local_debug_buf, ">>>>")) == NULL) {
                mdb_warn("failed to find terminator \">>>>\"\n");

                return (DCMD_ERR);
        }

        /*
         * Print the chunk of buffer from the terminator to the end.
         * This will print a null string if no wrap has occurred yet.
         */
        mdb_printf("%s", term_p+5);     /* after >>>>\0 to end of buf */
        mdb_printf("%s\n", local_debug_buf);    /* beg of buf to >>>>\0 */

        return (DCMD_OK);
}

/*ARGSUSED*/
int
usba_clear_debug_buf(
        uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
        int clear = 1;

        /* stop the tracing */
        if (mdb_writevar((void*)&clear, "usba_clear_debug_buf_flag") == -1) {
                mdb_warn("failed to set usba_clear_debug_buf_flag");

                return (DCMD_ERR);
        }

        return (DCMD_OK);
}

/* prtusb entries */
extern int prtusb(uintptr_t, uint_t, int, const mdb_arg_t *);

extern void prt_usb_usage(void);

/*
 * MDB module linkage information:
 *
 * We declare a list of structures describing our dcmds, and a function
 * named _mdb_init to return a pointer to our module information.
 */
static const mdb_dcmd_t dcmds[] = {
        { "usb_pipe_handle", ":",
            "print a usb_pipe_handle struct", usb_pipe_handle, NULL},
        { "usba_device", ": [-pv]",
            "print summary info for a usba_device_t struct", usba_device, NULL},
        { "usba_debug_buf", NULL,
            "print usba_debug_buf", usba_debug_buf, NULL},
        { "usba_clear_debug_buf", NULL,
            "clear usba_debug_buf", usba_clear_debug_buf, NULL},
        { "prtusb", "?[-t] [-v] [-i index]",
            "print trees and descriptors for usba_device_t",
            prtusb, prt_usb_usage},
        { NULL }
};

static const mdb_walker_t walkers[] = {
        /* Generic list walker. */
        { "usba_list_entry", "walk list of usba_list_entry_t structures",
            usba_list_walk_init, usba_list_walk_step, NULL, NULL },
        { "usb_pipe_handle", "walk USB pipe handles, given a usba_device_t ptr",
            usb_pipe_handle_walk_init, usb_pipe_handle_walk_step, NULL, NULL },
        { "usba_device", "walk global list of usba_device_t structures",
            usba_device_walk_init, usba_list_walk_step, NULL, NULL },
        { "hubd", "walk hubd instances", usba_hubd_walk_init,
            usba_hubd_walk_step, NULL, NULL },
        { NULL }
};

static const mdb_modinfo_t modinfo = {
        MDB_API_VERSION, dcmds, walkers
};

const mdb_modinfo_t *
_mdb_init(void)
{
        return (&modinfo);
}