/*
 * 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.
 */

/*
 * Device Context Base Address Array (DCBAA) Management and Scratchpad
 * management. This is also used to manage the device slot contexts in shared
 * memory.
 *
 * Please see the big theory statement in xhci.c for more information.
 */

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

static void
xhci_scratchpad_fini(xhci_t *xhcip)
{
        xhci_scratchpad_t *xsp = &xhcip->xhci_scratchpad;

        if (xsp->xsp_scratch_dma != NULL) {
                int i, npages;
                npages = xhcip->xhci_caps.xcap_max_scratch;
                for (i = 0; i < npages; i++) {
                        xhci_dma_free(&xsp->xsp_scratch_dma[i]);
                }
                kmem_free(xsp->xsp_scratch_dma,
                    sizeof (xhci_dma_buffer_t) * npages);
                xsp->xsp_scratch_dma = NULL;
        }
        xhci_dma_free(&xsp->xsp_addr_dma);
        xsp->xsp_addrs = NULL;
}

void
xhci_context_fini(xhci_t *xhcip)
{
        xhci_scratchpad_fini(xhcip);
        xhci_dma_free(&xhcip->xhci_dcbaa.xdc_dma);
        xhcip->xhci_dcbaa.xdc_base_addrs = NULL;
}

static int
xhci_scratchpad_alloc(xhci_t *xhcip)
{
        int npages, i;
        xhci_scratchpad_t *xsp;
        ddi_device_acc_attr_t acc;
        ddi_dma_attr_t attr;

        /*
         * First allocate the scratchpad table, then the actual pages.
         */
        ASSERT(xhcip->xhci_caps.xcap_max_scratch > 0);
        npages = xhcip->xhci_caps.xcap_max_scratch;
        xhci_dma_acc_attr(xhcip, &acc);
        xhci_dma_dma_attr(xhcip, &attr);
        xsp = &xhcip->xhci_scratchpad;
        if (xhci_dma_alloc(xhcip, &xsp->xsp_addr_dma, &attr, &acc,
            B_TRUE, sizeof (uint64_t) * npages, B_FALSE) == B_FALSE) {
                xhci_log(xhcip, "!failed to allocate DMA memory for device "
                    "context");
                return (ENOMEM);
        }

        xsp->xsp_addrs = (void *)xsp->xsp_addr_dma.xdb_va;

        /*
         * Note that the scratchpad memory itself can actually be relaxed, which
         * is almost better, since we'll never actually access this memory
         * ourselves, only use it to tear things down. As such, we also bump up
         * the segment boundary restrictions, since we don't really have any for
         * this memory.
         */
        xhci_dma_scratchpad_attr(xhcip, &attr);
        xsp->xsp_scratch_dma = kmem_zalloc(sizeof (xhci_dma_buffer_t) * npages,
            KM_SLEEP);
        for (i = 0; i < npages; i++) {
                if (xhci_dma_alloc(xhcip, &xsp->xsp_scratch_dma[i], &attr, &acc,
                    B_TRUE, xhcip->xhci_caps.xcap_pagesize, B_FALSE) ==
                    B_FALSE) {
                        /*
                         * It is safe for us to call xhci_scratchpad_fini() in a
                         * partially constructed state. Because we've zeroed the
                         * structures in the above allocation, the DMA buffer
                         * teardown code can handle these zeroed or partially
                         * initialized structures correctly.
                         */
                        xhci_scratchpad_fini(xhcip);
                        xhci_log(xhcip, "!failed to allocate DMA memory for "
                            "device scratchpad");
                        return (ENOMEM);
                }
        }

        return (0);
}

/*
 * We always allocate the DCBAA based on its maximum possible size, simplifying
 * the code and at worst wasting only a couple hundred bytes.
 */
static int
xhci_dcbaa_alloc(xhci_t *xhcip)
{
        xhci_dcbaa_t *dcb;
        ddi_device_acc_attr_t acc;
        ddi_dma_attr_t attr;

        dcb = &xhcip->xhci_dcbaa;
        xhci_dma_acc_attr(xhcip, &acc);
        xhci_dma_dma_attr(xhcip, &attr);
        if (xhci_dma_alloc(xhcip, &dcb->xdc_dma, &attr, &acc,
            B_FALSE, sizeof (uint64_t) * XHCI_MAX_SLOTS, B_FALSE) == B_FALSE) {
                xhci_log(xhcip, "!failed to allocate DMA memory for device "
                    "context");
                return (ENOMEM);
        }

        /*
         * This lint gag is safe, because we always have at least a 64-byte
         * alignment from the DMA attributes.
         */
        /* LINTED: E_BAD_PTR_CAST_ALIGN */
        dcb->xdc_base_addrs = (uint64_t *)dcb->xdc_dma.xdb_va;
        return (0);
}

/*
 * We are called to initialize the DCBAA every time that we start the
 * controller. This happens both the first time we bring it up and after we
 * reset it from errors. Therefore to initialize the DCBAA we need to do the
 * following:
 *
 *   o Allocate DMA memory (if it doesn't already exist)
 *   o If scratchpad slots have been requested, allocate and program them if
 *     necessary
 *   o Program the DCBAAP register.
 */
int
xhci_context_init(xhci_t *xhcip)
{
        int ret;
        xhci_dcbaa_t *dcb = &xhcip->xhci_dcbaa;

        if (dcb->xdc_base_addrs == NULL) {
                if ((ret = xhci_dcbaa_alloc(xhcip)) != 0)
                        return (ret);
        }

        bzero(dcb->xdc_base_addrs, sizeof (uint64_t) * XHCI_MAX_SLOTS);
        if (xhcip->xhci_caps.xcap_max_scratch != 0) {
                int i, npages;
                xhci_scratchpad_t *xsp = &xhcip->xhci_scratchpad;

                if (xsp->xsp_addrs == NULL &&
                    (ret = xhci_scratchpad_alloc(xhcip)) != 0) {
                        xhci_context_fini(xhcip);
                        return (ret);
                }

                dcb->xdc_base_addrs[XHCI_DCBAA_SCRATCHPAD_INDEX] =
                    LE_64(xhci_dma_pa(&xsp->xsp_addr_dma));

                npages = xhcip->xhci_caps.xcap_max_scratch;
                for (i = 0; i < npages; i++) {
                        xsp->xsp_addrs[i] =
                            LE_64(xhci_dma_pa(&xsp->xsp_scratch_dma[i]));
                }

                XHCI_DMA_SYNC(xsp->xsp_addr_dma, DDI_DMA_SYNC_FORDEV);
                if (xhci_check_dma_handle(xhcip, &xsp->xsp_addr_dma) !=
                    DDI_FM_OK) {
                        ddi_fm_service_impact(xhcip->xhci_dip,
                            DDI_SERVICE_LOST);
                        return (EIO);
                }
        }

        XHCI_DMA_SYNC(dcb->xdc_dma, DDI_DMA_SYNC_FORDEV);
        if (xhci_check_dma_handle(xhcip, &dcb->xdc_dma) != DDI_FM_OK) {
                ddi_fm_service_impact(xhcip->xhci_dip, DDI_SERVICE_LOST);
                return (EIO);
        }

        xhci_put64(xhcip, XHCI_R_OPER, XHCI_DCBAAP,
            LE_64(xhci_dma_pa(&dcb->xdc_dma)));
        if (xhci_check_regs_acc(xhcip) != DDI_FM_OK) {
                ddi_fm_service_impact(xhcip->xhci_dip,
                    DDI_SERVICE_LOST);
                return (EIO);
        }

        return (0);
}

/*
 * Initialize the default output context. It should already have been zeroed, so
 * all we need to do is insert it into the right place in the device context
 * array.
 */
boolean_t
xhci_context_slot_output_init(xhci_t *xhcip, xhci_device_t *xd)
{
        xhci_dcbaa_t *dcb = &xhcip->xhci_dcbaa;
        VERIFY(xd->xd_slot > 0 &&
            xd->xd_slot <= xhcip->xhci_caps.xcap_max_slots);

        xhcip->xhci_dcbaa.xdc_base_addrs[xd->xd_slot] =
            LE_64(xhci_dma_pa(&xd->xd_octx));
        XHCI_DMA_SYNC(dcb->xdc_dma, DDI_DMA_SYNC_FORDEV);
        if (xhci_check_dma_handle(xhcip, &dcb->xdc_dma) != DDI_FM_OK) {
                xhci_error(xhcip, "failed to initialize slot output context "
                    "for device on port %d, slot %d: fatal FM error "
                    "synchronizing DCBAA slot DMA memory", xd->xd_slot,
                    xd->xd_port);
                xhci_fm_runtime_reset(xhcip);
                return (B_FALSE);
        }

        return (B_TRUE);
}

void
xhci_context_slot_output_fini(xhci_t *xhcip, xhci_device_t *xd)
{
        xhci_dcbaa_t *dcb = &xhcip->xhci_dcbaa;
        VERIFY(xd->xd_slot > 0 &&
            xd->xd_slot <= xhcip->xhci_caps.xcap_max_slots);

        xhcip->xhci_dcbaa.xdc_base_addrs[xd->xd_slot] = 0ULL;
        XHCI_DMA_SYNC(dcb->xdc_dma, DDI_DMA_SYNC_FORDEV);
        if (xhci_check_dma_handle(xhcip, &dcb->xdc_dma) != DDI_FM_OK) {
                xhci_error(xhcip, "failed to finalize slot output context "
                    "for device on port %d, slot %d: fatal FM error "
                    "synchronizing DCBAA slot DMA memory", xd->xd_slot,
                    xd->xd_port);
                xhci_fm_runtime_reset(xhcip);
        }
}