/*
 * Copyright (c) 2008-2016 Solarflare Communications Inc.
 * All rights reserved.
 *
 * 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 COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.
 *
 * The views and conclusions contained in the software and documentation are
 * those of the authors and should not be interpreted as representing official
 * policies, either expressed or implied, of the FreeBSD Project.
 */

#include <sys/ddi.h>

#include "sfxge.h"
#include "efx.h"

static int
sfxge_dma_buffer_unbind_handle(efsys_mem_t *esmp)
{
        int rc;

        esmp->esm_addr = 0;
        rc = ddi_dma_unbind_handle(esmp->esm_dma_handle);
        if (rc != DDI_SUCCESS)
                goto fail1;

        return (0);

fail1:
        DTRACE_PROBE1(fail1, int, rc);

        return (rc);
}

static void
sfxge_dma_buffer_mem_free(efsys_mem_t *esmp)
{
        esmp->esm_base = NULL;
        ddi_dma_mem_free(&(esmp->esm_acc_handle));
        esmp->esm_acc_handle = NULL;
}

static void
sfxge_dma_buffer_handle_free(ddi_dma_handle_t *dhandlep)
{
        ddi_dma_free_handle(dhandlep);
        *dhandlep = NULL;
}

int
sfxge_dma_buffer_create(efsys_mem_t *esmp, const sfxge_dma_buffer_attr_t *sdbap)
{
        int err;
        int rc;
        size_t unit;
        ddi_dma_cookie_t dmac;
        unsigned int ncookies;

        /* Allocate a DMA handle */
        err = ddi_dma_alloc_handle(sdbap->sdba_dip, sdbap->sdba_dattrp,
            sdbap->sdba_callback, NULL, &(esmp->esm_dma_handle));
        switch (err) {
        case DDI_SUCCESS:
                break;

        case DDI_DMA_BADATTR:
                rc = EINVAL;
                goto fail1;

        case DDI_DMA_NORESOURCES:
                rc = ENOMEM;
                goto fail1;

        default:
                rc = EFAULT;
                goto fail1;
        }

        /* Allocate some DMA memory */
        err = ddi_dma_mem_alloc(esmp->esm_dma_handle, sdbap->sdba_length,
            sdbap->sdba_devaccp, sdbap->sdba_memflags,
            sdbap->sdba_callback, NULL,
            &(esmp->esm_base), &unit, &(esmp->esm_acc_handle));
        switch (err) {
        case DDI_SUCCESS:
                break;

        case DDI_FAILURE:
                /*FALLTHRU*/
        default:
                rc = EFAULT;
                goto fail2;
        }

        if (sdbap->sdba_zeroinit)
                bzero(esmp->esm_base, sdbap->sdba_length);

        /* Bind the DMA memory to the DMA handle */
        /* We aren't handling partial mappings */
        ASSERT3U(sdbap->sdba_bindflags & DDI_DMA_PARTIAL, !=, DDI_DMA_PARTIAL);
        err = ddi_dma_addr_bind_handle(esmp->esm_dma_handle, NULL,
            esmp->esm_base, sdbap->sdba_length, sdbap->sdba_bindflags,
            sdbap->sdba_callback, NULL, &dmac, &ncookies);
        switch (err) {
        case DDI_DMA_MAPPED:
                break;

        case DDI_DMA_INUSE:
                rc = EEXIST;
                goto fail3;

        case DDI_DMA_NORESOURCES:
                rc = ENOMEM;
                goto fail3;

        case DDI_DMA_NOMAPPING:
                rc = ENOTSUP;
                goto fail3;

        case DDI_DMA_TOOBIG:
                rc = EFBIG;
                goto fail3;

        default:
                rc = EFAULT;
                goto fail3;
        }
        ASSERT3U(ncookies, >=, 1);
        ASSERT3U(ncookies, <=, sdbap->sdba_maxcookies);

        esmp->esm_addr = dmac.dmac_laddress;
        esmp->esm_size = dmac.dmac_size;
        DTRACE_PROBE1(addr, efsys_dma_addr_t, esmp->esm_addr);

        return (0);

fail3:
        DTRACE_PROBE(fail3);

        sfxge_dma_buffer_mem_free(esmp);

fail2:
        DTRACE_PROBE(fail2);

        sfxge_dma_buffer_handle_free(&(esmp->esm_dma_handle));
        esmp->esm_dma_handle = NULL;

fail1:
        DTRACE_PROBE1(fail1, int, rc);

        return (-1);
}

void
sfxge_dma_buffer_destroy(efsys_mem_t *esmp)
{
        int rc;

        rc = sfxge_dma_buffer_unbind_handle(esmp);
        if (rc != 0) {
                cmn_err(CE_WARN, SFXGE_CMN_ERR "DMA Unbind failed rc=%d", rc);
        }
        sfxge_dma_buffer_mem_free(esmp);
        sfxge_dma_buffer_handle_free(&(esmp->esm_dma_handle));
}