/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2016 Joyent, Inc.
 */

/*
 * -------------------------
 * xHCI Interrupt Management
 * -------------------------
 *
 * Interrupts in the xHCI driver are quite straightforward. We only have a
 * single interrupt, which is always vector zero. Everything is configured to
 * use this interrupt.
 *
 * ------------------
 * Interrupt Claiming
 * ------------------
 *
 * One of the challenges is knowing when to claim interrupts. Generally
 * speaking, interrupts for MSI and MSI-X are directed to a specific vector for
 * a specific device. This allows us to have a bit more confidence on whether
 * the interrupt is for us. This is contrasted with traditional INTx (pin based)
 * interrupts in PCI where interrupts are shared between multiple devices.
 *
 * xHCI 1.1 / 5.5.2.1 documents the interrupt management register. One of the
 * quirks here is that when we acknowledge the PCI level MSI or MSI-X, the IP
 * bit is automatically cleared (see xHCI 1.1 / 4.17.5 for more info). However,
 * it's not for INTx based systems, thus making things a bit more confusing.
 * Because of this, we only check the IP bit when we're using INTx interrupts.
 *
 * This means that knowing whether or not we can claim something is challenging.
 * Particularly in the case where we have FM errors. In those cases we opt to
 * claim rather than not.
 */

#include <sys/usb/hcd/xhci/xhci.h>

boolean_t
xhci_ddi_intr_disable(xhci_t *xhcip)
{
        int ret;

        if (xhcip->xhci_intr_caps & DDI_INTR_FLAG_BLOCK) {
                if ((ret = ddi_intr_block_disable(&xhcip->xhci_intr_hdl,
                    xhcip->xhci_intr_num)) != DDI_SUCCESS) {
                        xhci_error(xhcip, "failed to block-disable interrupts: "
                            "%d", ret);
                        return (B_FALSE);
                }
        } else {
                if ((ret = ddi_intr_disable(xhcip->xhci_intr_hdl)) !=
                    DDI_SUCCESS) {
                        xhci_error(xhcip, "failed to disable interrupt: %d",
                            ret);
                        return (B_FALSE);
                }
        }

        return (B_TRUE);
}


boolean_t
xhci_ddi_intr_enable(xhci_t *xhcip)
{
        int ret;

        if (xhcip->xhci_intr_caps & DDI_INTR_FLAG_BLOCK) {
                if ((ret = ddi_intr_block_enable(&xhcip->xhci_intr_hdl,
                    xhcip->xhci_intr_num)) != DDI_SUCCESS) {
                        xhci_error(xhcip, "failed to block-enable interrupts: "
                            "%d", ret);
                        return (B_FALSE);
                }
        } else {
                if ((ret = ddi_intr_enable(xhcip->xhci_intr_hdl)) !=
                    DDI_SUCCESS) {
                        xhci_error(xhcip, "failed to enable interrupt: %d",
                            ret);
                        return (B_FALSE);
                }
        }

        return (B_TRUE);
}

/*
 * Configure the device for interrupts. We need to take care of three things.
 * Enabling interupt zero, setting interrupt zero's interrupt moderation, and
 * then enabling interrupts themselves globally.
 */
int
xhci_intr_conf(xhci_t *xhcip)
{
        uint32_t reg;

        reg = xhci_get32(xhcip, XHCI_R_RUN, XHCI_IMAN(0));
        reg |= XHCI_IMAN_INTR_ENA;
        xhci_put32(xhcip, XHCI_R_RUN, XHCI_IMAN(0), reg);

        xhci_put32(xhcip, XHCI_R_RUN, XHCI_IMOD(0), XHCI_IMOD_DEFAULT);

        reg = xhci_get32(xhcip, XHCI_R_OPER, XHCI_USBCMD);
        reg |= XHCI_CMD_INTE;
        xhci_put32(xhcip, XHCI_R_OPER, XHCI_USBCMD, reg);

        if (xhci_check_regs_acc(xhcip) != DDI_FM_OK) {
                ddi_fm_service_impact(xhcip->xhci_dip, DDI_SERVICE_LOST);
                return (EIO);
        }

        return (0);
}

uint_t
xhci_intr(caddr_t arg1, caddr_t arg2)
{
        uint32_t iman, status;

        xhci_t *xhcip = (xhci_t *)(void *)arg1;
        uintptr_t vector = (uintptr_t)arg2;

        ASSERT0(vector);

        /*
         * First read the status register.
         */
        status = xhci_get32(xhcip, XHCI_R_OPER, XHCI_USBSTS);
        if (xhci_check_regs_acc(xhcip) != DDI_FM_OK) {
                xhci_error(xhcip, "failed to read USB status register: "
                    "encountered fatal FM error, resetting device");
                xhci_fm_runtime_reset(xhcip);
                return (DDI_INTR_CLAIMED);
        }

        /*
         * Before we read the interrupt management register, check to see if we
         * have a fatal bit set. At which point, it's time to reset the world
         * anyway.
         */
        if ((status & (XHCI_STS_HSE | XHCI_STS_SRE | XHCI_STS_HCE)) != 0) {
                xhci_error(xhcip, "found fatal error bit in status register, "
                    "value: 0x%x: resetting device", status);
                xhci_fm_runtime_reset(xhcip);
                return (DDI_INTR_CLAIMED);
        }

        iman = xhci_get32(xhcip, XHCI_R_RUN, XHCI_IMAN(0));
        if (xhci_check_regs_acc(xhcip) != DDI_FM_OK) {
                xhci_error(xhcip, "failed to read interrupt register 0: "
                    "encountered fatal FM error, resetting device");
                xhci_fm_runtime_reset(xhcip);
                return (DDI_INTR_CLAIMED);
        }

        /*
         * When using shared interrupts, verify that this interrupt is for us.
         * Note that when using MSI and MSI-X, writing to various PCI registers
         * can automatically clear this for us.
         */
        if (xhcip->xhci_intr_type == DDI_INTR_TYPE_FIXED &&
            (iman & XHCI_IMAN_INTR_PEND) == 0) {
                return (DDI_INTR_UNCLAIMED);
        }

        /*
         * If we detect some kind of error condition here that's going to result
         * in a device reset being dispatched, we purposefully do not clear the
         * interrupt and enable it again.
         */
        if (xhci_event_process(xhcip) == B_FALSE) {
                return (DDI_INTR_CLAIMED);
        }

        xhci_put32(xhcip, XHCI_R_RUN, XHCI_IMAN(0), iman);
        if (xhci_check_regs_acc(xhcip) != DDI_FM_OK) {
                xhci_error(xhcip, "failed to write USB status register: "
                    "encountered fatal FM error, resetting device");
                xhci_fm_runtime_reset(xhcip);
        }

        return (DDI_INTR_CLAIMED);
}