io/sfxge/sfxge_dma.c

/*
 * 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));
}