dma.c

浏览该文件的文档.

 
#include <xwcd/ds/standard.h>
#include <string.h>
#include <xwcd/ds/soc/dma.h>
 
__xwds_api
xwer_t xwds_dma_req(struct xwds_soc * soc, xwid_t ch)
{
        const struct xwds_soc_driver * drv;
        xwer_t rc;
 
        XWDS_VALIDATE(soc, "nullptr", -EFAULT);
        XWDS_VALIDATE(((xwid_t)ch < soc->dma.ch_num), "out-of-range", -ERANGE);
 
        rc = xwds_soc_grab(soc);
        if (rc < 0) {
                goto err_soc_grab;
        }
        drv = xwds_cast(const struct xwds_soc_driver *, soc->dev.drv);
        if ((drv) && (drv->dma_req)) {
                rc = drv->dma_req(soc, ch);
                if (rc < 0) {
                        goto err_drv_dma_req;
                }
        }
        return XWOK;
 
err_drv_dma_req:
        xwds_soc_put(soc);
err_soc_grab:
        return rc;
}
 
__xwds_api
xwer_t xwds_dma_rls(struct xwds_soc * soc, xwid_t ch)
{
        const struct xwds_soc_driver * drv;
        xwer_t rc;
 
        XWDS_VALIDATE(soc, "nullptr", -EFAULT);
        XWDS_VALIDATE(((xwid_t)ch < soc->dma.ch_num), "out-of-range", -ERANGE);
 
        drv = xwds_cast(const struct xwds_soc_driver *, soc->dev.drv);
        if ((drv) && (drv->dma_rls)) {
                rc = drv->dma_rls(soc, ch);
                if (rc < 0) {
                        goto err_drv_dma_rls;
                }
        }
        xwds_soc_put(soc);
        return XWOK;
 
err_drv_dma_rls:
        return rc;
}
 
__xwds_api
xwer_t xwds_dma_cfg(struct xwds_soc * soc, xwid_t ch, void * cfg,
                    xwds_dma_f cb, xwds_dma_cbarg_t arg)
{
        const struct xwds_soc_driver * drv;
        xwer_t rc;
 
        XWDS_VALIDATE(soc, "nullptr", -EFAULT);
        XWDS_VALIDATE(((xwid_t)ch < soc->dma.ch_num), "out-of-range", -ERANGE);
 
#if defined(XWCDCFG_ds_SOC_DMA_ROCBT) && (1 == XWCDCFG_ds_SOC_DMA_ROCBT)
        XWOS_UNUSED(cb);
        XWOS_UNUSED(arg);
#else
        if (soc->dma.chcbs) {
                soc->dma.chcbs[ch] = cb;
        }
        if (soc->dma.chcbargs) {
                soc->dma.chcbargs[ch] = arg;
        }
#endif
        drv = xwds_cast(const struct xwds_soc_driver *, soc->dev.drv);
        if ((drv) && (drv->dma_cfg)) {
                rc = drv->dma_cfg(soc, ch, cfg);
                if (rc < 0) {
                        goto err_drv_dma_cfg;
                }
        }
        return XWOK;
 
err_drv_dma_cfg:
#if !defined(XWCDCFG_ds_SOC_DMA_ROCBT) || (1 != XWCDCFG_ds_SOC_DMA_ROCBT)
        if (soc->dma.chcbs) {
                soc->dma.chcbs[ch] = NULL;
        }
        if (soc->dma.chcbargs) {
                soc->dma.chcbargs[ch] = NULL;
        }
#endif
        return rc;
}
 
__xwds_api
xwer_t xwds_dma_enable(struct xwds_soc * soc, xwid_t ch)
{
        const struct xwds_soc_driver * drv;
        xwer_t rc;
 
        XWDS_VALIDATE(soc, "nullptr", -EFAULT);
        XWDS_VALIDATE(((xwid_t)ch < soc->dma.ch_num), "out-of-range", -ERANGE);
 
        drv = xwds_cast(const struct xwds_soc_driver *, soc->dev.drv);
        if ((drv) && (drv->dma_enable)) {
                rc = drv->dma_enable(soc, ch);
                if (rc < 0) {
                        goto err_drv_dma_enable;
                }
        }
        return XWOK;
 
err_drv_dma_enable:
        return rc;
}
 
__xwds_api
xwer_t xwds_dma_disable(struct xwds_soc * soc, xwid_t ch)
{
        const struct xwds_soc_driver * drv;
        xwer_t rc;
 
        XWDS_VALIDATE(soc, "nullptr", -EFAULT);
        XWDS_VALIDATE(((xwid_t)ch < soc->dma.ch_num), "out-of-range", -ERANGE);
 
        drv = xwds_cast(const struct xwds_soc_driver *, soc->dev.drv);
        if ((drv) && (drv->dma_disable)) {
                rc = drv->dma_disable(soc, ch);
                if (rc < 0) {
                        goto err_drv_dma_disable;
                }
        }
        return XWOK;
 
err_drv_dma_disable:
        return rc;
}
 
__xwds_api
xwer_t xwds_dma_start(struct xwds_soc * soc, xwid_t ch)
{
        const struct xwds_soc_driver * drv;
        xwer_t rc;
 
        XWDS_VALIDATE(soc, "nullptr", -EFAULT);
        XWDS_VALIDATE(((xwid_t)ch < soc->dma.ch_num), "out-of-range", -ERANGE);
 
        drv = xwds_cast(const struct xwds_soc_driver *, soc->dev.drv);
        if ((drv) && (drv->dma_start)) {
                rc = drv->dma_start(soc, ch);
                if (rc < 0) {
                        goto err_drv_dma_start;
                }
        }
        return XWOK;
 
err_drv_dma_start:
        return rc;
}
 
__xwds_api
xwer_t xwds_dma_stop(struct xwds_soc * soc, xwid_t ch)
{
        const struct xwds_soc_driver * drv;
        xwer_t rc;
 
        XWDS_VALIDATE(soc, "nullptr", -EFAULT);
        XWDS_VALIDATE(((xwid_t)ch < soc->dma.ch_num), "out-of-range", -ERANGE);
 
        drv = xwds_cast(const struct xwds_soc_driver *, soc->dev.drv);
        if ((drv) && (drv->dma_stop)) {
                rc = drv->dma_stop(soc, ch);
                if (rc < 0) {
                        goto err_drv_dma_stop;
                }
        }
        return XWOK;
 
err_drv_dma_stop:
        return rc;
}