linux-imx

/*

 * drivers/dma/fsl-edma.c

 *

 * Copyright 2013-2014 Freescale Semiconductor, Inc.

 *

 * Driver for the Freescale eDMA engine with flexible channel multiplexing

 * capability for DMA request sources. The eDMA block can be found on some

 * Vybrid and Layerscape SoCs.

 *

 * This program is free software; you can redistribute  it and/or modify it

 * under  the terms of  the GNU General  Public License as published by the

 * Free Software Foundation;  either version 2 of the  License, or (at your

 * option) any later version.

 */

​

#include <linux/module.h>

#include <linux/interrupt.h>

#include <linux/clk.h>

#include <linux/of.h>

#include <linux/of_device.h>

#include <linux/of_address.h>

#include <linux/of_irq.h>

#include <linux/of_dma.h>

​

#include "fsl-edma-common.h"

​

static irqreturn_t fsl_edma_tx_handler(int irq, void *dev_id)

{

    struct fsl_edma_engine *fsl_edma = dev_id;

    unsigned int intr, ch;

    struct edma_regs *regs = &fsl_edma->regs;

    struct fsl_edma_chan *fsl_chan;

​

    intr = edma_readl(fsl_edma, regs->intl);

    if (!intr)

        return IRQ_NONE;

​

    for (ch = 0; ch < fsl_edma->n_chans; ch++) {

        if (intr & (0x1 << ch)) {

            edma_writeb(fsl_edma, EDMA_CINT_CINT(ch), regs->cint);

​

            fsl_chan = &fsl_edma->chans[ch];

​

            spin_lock(&fsl_chan->vchan.lock);

            if (!fsl_chan->edesc->iscyclic) {

                list_del(&fsl_chan->edesc->vdesc.node);

                vchan_cookie_complete(&fsl_chan->edesc->vdesc);

                fsl_chan->edesc = NULL;

                fsl_chan->status = DMA_COMPLETE;

                fsl_chan->idle = true;

            } else {

                vchan_cyclic_callback(&fsl_chan->edesc->vdesc);

            }

​

            if (!fsl_chan->edesc)

                fsl_edma_xfer_desc(fsl_chan);

​

            spin_unlock(&fsl_chan->vchan.lock);

        }

    }

    return IRQ_HANDLED;

}

​

static irqreturn_t fsl_edma_err_handler(int irq, void *dev_id)

{

    struct fsl_edma_engine *fsl_edma = dev_id;

    unsigned int err, ch;

    struct edma_regs *regs = &fsl_edma->regs;

​

    err = edma_readl(fsl_edma, regs->errl);

    if (!err)

        return IRQ_NONE;

​

    for (ch = 0; ch < fsl_edma->n_chans; ch++) {

        if (err & (0x1 << ch)) {

            fsl_edma_disable_request(&fsl_edma->chans[ch]);

            edma_writeb(fsl_edma, EDMA_CERR_CERR(ch), regs->cerr);

            fsl_edma->chans[ch].status = DMA_ERROR;

            fsl_edma->chans[ch].idle = true;

        }

    }

    return IRQ_HANDLED;

}

​

static irqreturn_t fsl_edma_irq_handler(int irq, void *dev_id)

{

    if (fsl_edma_tx_handler(irq, dev_id) == IRQ_HANDLED)

        return IRQ_HANDLED;

​

    return fsl_edma_err_handler(irq, dev_id);

}

​