// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 2019 Spreadtrum Communications Inc.

#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/spinlock.h>

#include "sprd-mcdt.h"

/* MCDT registers definition */
#define MCDT_CH0_TXD            0x0
#define MCDT_CH0_RXD            0x28
#define MCDT_DAC0_WTMK          0x60
#define MCDT_ADC0_WTMK          0x88
#define MCDT_DMA_EN             0xb0

#define MCDT_INT_EN0            0xb4
#define MCDT_INT_EN1            0xb8
#define MCDT_INT_EN2            0xbc

#define MCDT_INT_CLR0           0xc0
#define MCDT_INT_CLR1           0xc4
#define MCDT_INT_CLR2           0xc8

#define MCDT_INT_RAW1           0xcc
#define MCDT_INT_RAW2           0xd0
#define MCDT_INT_RAW3           0xd4

#define MCDT_INT_MSK1           0xd8
#define MCDT_INT_MSK2           0xdc
#define MCDT_INT_MSK3           0xe0

#define MCDT_DAC0_FIFO_ADDR_ST  0xe4
#define MCDT_ADC0_FIFO_ADDR_ST  0xe8

#define MCDT_CH_FIFO_ST0        0x134
#define MCDT_CH_FIFO_ST1        0x138
#define MCDT_CH_FIFO_ST2        0x13c

#define MCDT_INT_MSK_CFG0       0x140
#define MCDT_INT_MSK_CFG1       0x144

#define MCDT_DMA_CFG0           0x148
#define MCDT_FIFO_CLR           0x14c
#define MCDT_DMA_CFG1           0x150
#define MCDT_DMA_CFG2           0x154
#define MCDT_DMA_CFG3           0x158
#define MCDT_DMA_CFG4           0x15c
#define MCDT_DMA_CFG5           0x160

/* Channel water mark definition */
#define MCDT_CH_FIFO_AE_SHIFT   16
#define MCDT_CH_FIFO_AE_MASK    GENMASK(24, 16)
#define MCDT_CH_FIFO_AF_MASK    GENMASK(8, 0)

/* DMA channel select definition */
#define MCDT_DMA_CH0_SEL_MASK   GENMASK(3, 0)
#define MCDT_DMA_CH0_SEL_SHIFT  0
#define MCDT_DMA_CH1_SEL_MASK   GENMASK(7, 4)
#define MCDT_DMA_CH1_SEL_SHIFT  4
#define MCDT_DMA_CH2_SEL_MASK   GENMASK(11, 8)
#define MCDT_DMA_CH2_SEL_SHIFT  8
#define MCDT_DMA_CH3_SEL_MASK   GENMASK(15, 12)
#define MCDT_DMA_CH3_SEL_SHIFT  12
#define MCDT_DMA_CH4_SEL_MASK   GENMASK(19, 16)
#define MCDT_DMA_CH4_SEL_SHIFT  16
#define MCDT_DAC_DMA_SHIFT      16

/* DMA channel ACK select definition */
#define MCDT_DMA_ACK_SEL_MASK   GENMASK(3, 0)

/* Channel FIFO definition */
#define MCDT_CH_FIFO_ADDR_SHIFT 16
#define MCDT_CH_FIFO_ADDR_MASK  GENMASK(9, 0)
#define MCDT_ADC_FIFO_SHIFT     16
#define MCDT_FIFO_LENGTH        512

#define MCDT_ADC_CHANNEL_NUM    10
#define MCDT_DAC_CHANNEL_NUM    10
#define MCDT_CHANNEL_NUM        (MCDT_ADC_CHANNEL_NUM + MCDT_DAC_CHANNEL_NUM)

enum sprd_mcdt_fifo_int {
        MCDT_ADC_FIFO_AE_INT,
        MCDT_ADC_FIFO_AF_INT,
        MCDT_DAC_FIFO_AE_INT,
        MCDT_DAC_FIFO_AF_INT,
        MCDT_ADC_FIFO_OV_INT,
        MCDT_DAC_FIFO_OV_INT
};

enum sprd_mcdt_fifo_sts {
        MCDT_ADC_FIFO_REAL_FULL,
        MCDT_ADC_FIFO_REAL_EMPTY,
        MCDT_ADC_FIFO_AF,
        MCDT_ADC_FIFO_AE,
        MCDT_DAC_FIFO_REAL_FULL,
        MCDT_DAC_FIFO_REAL_EMPTY,
        MCDT_DAC_FIFO_AF,
        MCDT_DAC_FIFO_AE
};

struct sprd_mcdt_dev {
        struct device *dev;
        void __iomem *base;
        spinlock_t lock;
        struct sprd_mcdt_chan chan[MCDT_CHANNEL_NUM];
};

static LIST_HEAD(sprd_mcdt_chan_list);
static DEFINE_MUTEX(sprd_mcdt_list_mutex);

static void sprd_mcdt_update(struct sprd_mcdt_dev *mcdt, u32 reg, u32 val,
                             u32 mask)
{
        u32 orig = readl_relaxed(mcdt->base + reg);
        u32 tmp;

        tmp = (orig & ~mask) | val;
        writel_relaxed(tmp, mcdt->base + reg);
}

static void sprd_mcdt_dac_set_watermark(struct sprd_mcdt_dev *mcdt, u8 channel,
                                        u32 full, u32 empty)
{
        u32 reg = MCDT_DAC0_WTMK + channel * 4;
        u32 water_mark =
                (empty << MCDT_CH_FIFO_AE_SHIFT) & MCDT_CH_FIFO_AE_MASK;

        water_mark |= full & MCDT_CH_FIFO_AF_MASK;
        sprd_mcdt_update(mcdt, reg, water_mark,
                         MCDT_CH_FIFO_AE_MASK | MCDT_CH_FIFO_AF_MASK);
}

static void sprd_mcdt_adc_set_watermark(struct sprd_mcdt_dev *mcdt, u8 channel,
                                        u32 full, u32 empty)
{
        u32 reg = MCDT_ADC0_WTMK + channel * 4;
        u32 water_mark =
                (empty << MCDT_CH_FIFO_AE_SHIFT) & MCDT_CH_FIFO_AE_MASK;

        water_mark |= full & MCDT_CH_FIFO_AF_MASK;
        sprd_mcdt_update(mcdt, reg, water_mark,
                         MCDT_CH_FIFO_AE_MASK | MCDT_CH_FIFO_AF_MASK);
}

static void sprd_mcdt_dac_dma_enable(struct sprd_mcdt_dev *mcdt, u8 channel,
                                     bool enable)
{
        u32 shift = MCDT_DAC_DMA_SHIFT + channel;

        if (enable)
                sprd_mcdt_update(mcdt, MCDT_DMA_EN, BIT(shift), BIT(shift));
        else
                sprd_mcdt_update(mcdt, MCDT_DMA_EN, 0, BIT(shift));
}

static void sprd_mcdt_adc_dma_enable(struct sprd_mcdt_dev *mcdt, u8 channel,
                                     bool enable)
{
        if (enable)
                sprd_mcdt_update(mcdt, MCDT_DMA_EN, BIT(channel), BIT(channel));
        else
                sprd_mcdt_update(mcdt, MCDT_DMA_EN, 0, BIT(channel));
}

static void sprd_mcdt_ap_int_enable(struct sprd_mcdt_dev *mcdt, u8 channel,
                                    bool enable)
{
        if (enable)
                sprd_mcdt_update(mcdt, MCDT_INT_MSK_CFG0, BIT(channel),
                                 BIT(channel));
        else
                sprd_mcdt_update(mcdt, MCDT_INT_MSK_CFG0, 0, BIT(channel));
}

static void sprd_mcdt_dac_write_fifo(struct sprd_mcdt_dev *mcdt, u8 channel,
                                     u32 val)
{
        u32 reg = MCDT_CH0_TXD + channel * 4;

        writel_relaxed(val, mcdt->base + reg);
}

static void sprd_mcdt_adc_read_fifo(struct sprd_mcdt_dev *mcdt, u8 channel,
                                    u32 *val)
{
        u32 reg = MCDT_CH0_RXD + channel * 4;

        *val = readl_relaxed(mcdt->base + reg);
}

static void sprd_mcdt_dac_dma_chn_select(struct sprd_mcdt_dev *mcdt, u8 channel,
                                         enum sprd_mcdt_dma_chan dma_chan)
{
        switch (dma_chan) {
        case SPRD_MCDT_DMA_CH0:
                sprd_mcdt_update(mcdt, MCDT_DMA_CFG0,
                                 channel << MCDT_DMA_CH0_SEL_SHIFT,
                                 MCDT_DMA_CH0_SEL_MASK);
                break;

        case SPRD_MCDT_DMA_CH1:
                sprd_mcdt_update(mcdt, MCDT_DMA_CFG0,
                                 channel << MCDT_DMA_CH1_SEL_SHIFT,
                                 MCDT_DMA_CH1_SEL_MASK);
                break;

        case SPRD_MCDT_DMA_CH2:
                sprd_mcdt_update(mcdt, MCDT_DMA_CFG0,
                                 channel << MCDT_DMA_CH2_SEL_SHIFT,
                                 MCDT_DMA_CH2_SEL_MASK);
                break;

        case SPRD_MCDT_DMA_CH3:
                sprd_mcdt_update(mcdt, MCDT_DMA_CFG0,
                                 channel << MCDT_DMA_CH3_SEL_SHIFT,
                                 MCDT_DMA_CH3_SEL_MASK);
                break;

        case SPRD_MCDT_DMA_CH4:
                sprd_mcdt_update(mcdt, MCDT_DMA_CFG0,
                                 channel << MCDT_DMA_CH4_SEL_SHIFT,
                                 MCDT_DMA_CH4_SEL_MASK);
                break;
        }
}

static void sprd_mcdt_adc_dma_chn_select(struct sprd_mcdt_dev *mcdt, u8 channel,
                                         enum sprd_mcdt_dma_chan dma_chan)
{
        switch (dma_chan) {
        case SPRD_MCDT_DMA_CH0:
                sprd_mcdt_update(mcdt, MCDT_DMA_CFG1,
                                 channel << MCDT_DMA_CH0_SEL_SHIFT,
                                 MCDT_DMA_CH0_SEL_MASK);
                break;

        case SPRD_MCDT_DMA_CH1:
                sprd_mcdt_update(mcdt, MCDT_DMA_CFG1,
                                 channel << MCDT_DMA_CH1_SEL_SHIFT,
                                 MCDT_DMA_CH1_SEL_MASK);
                break;

        case SPRD_MCDT_DMA_CH2:
                sprd_mcdt_update(mcdt, MCDT_DMA_CFG1,
                                 channel << MCDT_DMA_CH2_SEL_SHIFT,
                                 MCDT_DMA_CH2_SEL_MASK);
                break;

        case SPRD_MCDT_DMA_CH3:
                sprd_mcdt_update(mcdt, MCDT_DMA_CFG1,
                                 channel << MCDT_DMA_CH3_SEL_SHIFT,
                                 MCDT_DMA_CH3_SEL_MASK);
                break;

        case SPRD_MCDT_DMA_CH4:
                sprd_mcdt_update(mcdt, MCDT_DMA_CFG1,
                                 channel << MCDT_DMA_CH4_SEL_SHIFT,
                                 MCDT_DMA_CH4_SEL_MASK);
                break;
        }
}

static u32 sprd_mcdt_dma_ack_shift(u8 channel)
{
        switch (channel) {
        default:
        case 0:
        case 8:
                return 0;
        case 1:
        case 9:
                return 4;
        case 2:
                return 8;
        case 3:
                return 12;
        case 4:
                return 16;
        case 5:
                return 20;
        case 6:
                return 24;
        case 7:
                return 28;
        }
}

static void sprd_mcdt_dac_dma_ack_select(struct sprd_mcdt_dev *mcdt, u8 channel,
                                         enum sprd_mcdt_dma_chan dma_chan)
{
        u32 reg, shift = sprd_mcdt_dma_ack_shift(channel), ack = dma_chan;

        switch (channel) {
        case 0 ... 7:
                reg = MCDT_DMA_CFG2;
                break;

        case 8 ... 9:
                reg = MCDT_DMA_CFG3;
                break;

        default:
                return;
        }

        sprd_mcdt_update(mcdt, reg, ack << shift,
                         MCDT_DMA_ACK_SEL_MASK << shift);
}

static void sprd_mcdt_adc_dma_ack_select(struct sprd_mcdt_dev *mcdt, u8 channel,
                                         enum sprd_mcdt_dma_chan dma_chan)
{
        u32 reg, shift = sprd_mcdt_dma_ack_shift(channel), ack = dma_chan;

        switch (channel) {
        case 0 ... 7:
                reg = MCDT_DMA_CFG4;
                break;

        case 8 ... 9:
                reg = MCDT_DMA_CFG5;
                break;

        default:
                return;
        }

        sprd_mcdt_update(mcdt, reg, ack << shift,
                         MCDT_DMA_ACK_SEL_MASK << shift);
}

static bool sprd_mcdt_chan_fifo_sts(struct sprd_mcdt_dev *mcdt, u8 channel,
                                    enum sprd_mcdt_fifo_sts fifo_sts)
{
        u32 reg, shift;

        switch (channel) {
        case 0 ... 3:
                reg = MCDT_CH_FIFO_ST0;
                break;
        case 4 ... 7:
                reg = MCDT_CH_FIFO_ST1;
                break;
        case 8 ... 9:
                reg = MCDT_CH_FIFO_ST2;
                break;
        default:
                return false;
        }

        switch (channel) {
        case 0:
        case 4:
        case 8:
                shift = fifo_sts;
                break;

        case 1:
        case 5:
        case 9:
                shift = 8 + fifo_sts;
                break;

        case 2:
        case 6:
                shift = 16 + fifo_sts;
                break;

        case 3:
        case 7:
                shift = 24 + fifo_sts;
                break;

        default:
                return false;
        }

        return !!(readl_relaxed(mcdt->base + reg) & BIT(shift));
}

static void sprd_mcdt_dac_fifo_clear(struct sprd_mcdt_dev *mcdt, u8 channel)
{
        sprd_mcdt_update(mcdt, MCDT_FIFO_CLR, BIT(channel), BIT(channel));
}

static void sprd_mcdt_adc_fifo_clear(struct sprd_mcdt_dev *mcdt, u8 channel)
{
        u32 shift = MCDT_ADC_FIFO_SHIFT + channel;

        sprd_mcdt_update(mcdt, MCDT_FIFO_CLR, BIT(shift), BIT(shift));
}

static u32 sprd_mcdt_dac_fifo_avail(struct sprd_mcdt_dev *mcdt, u8 channel)
{
        u32 reg = MCDT_DAC0_FIFO_ADDR_ST + channel * 8;
        u32 r_addr = (readl_relaxed(mcdt->base + reg) >>
                      MCDT_CH_FIFO_ADDR_SHIFT) & MCDT_CH_FIFO_ADDR_MASK;
        u32 w_addr = readl_relaxed(mcdt->base + reg) & MCDT_CH_FIFO_ADDR_MASK;

        if (w_addr >= r_addr)
                return 4 * (MCDT_FIFO_LENGTH - w_addr + r_addr);
        else
                return 4 * (r_addr - w_addr);
}

static u32 sprd_mcdt_adc_fifo_avail(struct sprd_mcdt_dev *mcdt, u8 channel)
{
        u32 reg = MCDT_ADC0_FIFO_ADDR_ST + channel * 8;
        u32 r_addr = (readl_relaxed(mcdt->base + reg) >>
                      MCDT_CH_FIFO_ADDR_SHIFT) & MCDT_CH_FIFO_ADDR_MASK;
        u32 w_addr = readl_relaxed(mcdt->base + reg) & MCDT_CH_FIFO_ADDR_MASK;

        if (w_addr >= r_addr)
                return 4 * (w_addr - r_addr);
        else
                return 4 * (MCDT_FIFO_LENGTH - r_addr + w_addr);
}

static u32 sprd_mcdt_int_type_shift(u8 channel,
                                    enum sprd_mcdt_fifo_int int_type)
{
        switch (channel) {
        case 0:
        case 4:
        case 8:
                return int_type;

        case 1:
        case 5:
        case 9:
                return  8 + int_type;

        case 2:
        case 6:
                return 16 + int_type;

        case 3:
        case 7:
                return 24 + int_type;

        default:
                return 0;
        }
}

static void sprd_mcdt_chan_int_en(struct sprd_mcdt_dev *mcdt, u8 channel,
                                  enum sprd_mcdt_fifo_int int_type, bool enable)
{
        u32 reg, shift = sprd_mcdt_int_type_shift(channel, int_type);

        switch (channel) {
        case 0 ... 3:
                reg = MCDT_INT_EN0;
                break;
        case 4 ... 7:
                reg = MCDT_INT_EN1;
                break;
        case 8 ... 9:
                reg = MCDT_INT_EN2;
                break;
        default:
                return;
        }

        if (enable)
                sprd_mcdt_update(mcdt, reg, BIT(shift), BIT(shift));
        else
                sprd_mcdt_update(mcdt, reg, 0, BIT(shift));
}

static void sprd_mcdt_chan_int_clear(struct sprd_mcdt_dev *mcdt, u8 channel,
                                     enum sprd_mcdt_fifo_int int_type)
{
        u32 reg, shift = sprd_mcdt_int_type_shift(channel, int_type);

        switch (channel) {
        case 0 ... 3:
                reg = MCDT_INT_CLR0;
                break;
        case 4 ... 7:
                reg = MCDT_INT_CLR1;
                break;
        case 8 ... 9:
                reg = MCDT_INT_CLR2;
                break;
        default:
                return;
        }

        sprd_mcdt_update(mcdt, reg, BIT(shift), BIT(shift));
}

static bool sprd_mcdt_chan_int_sts(struct sprd_mcdt_dev *mcdt, u8 channel,
                                   enum sprd_mcdt_fifo_int int_type)
{
        u32 reg, shift = sprd_mcdt_int_type_shift(channel, int_type);

        switch (channel) {
        case 0 ... 3:
                reg = MCDT_INT_MSK1;
                break;
        case 4 ... 7:
                reg = MCDT_INT_MSK2;
                break;
        case 8 ... 9:
                reg = MCDT_INT_MSK3;
                break;
        default:
                return false;
        }

        return !!(readl_relaxed(mcdt->base + reg) & BIT(shift));
}

static irqreturn_t sprd_mcdt_irq_handler(int irq, void *dev_id)
{
        struct sprd_mcdt_dev *mcdt = (struct sprd_mcdt_dev *)dev_id;
        int i;

        spin_lock(&mcdt->lock);

        for (i = 0; i < MCDT_ADC_CHANNEL_NUM; i++) {
                if (sprd_mcdt_chan_int_sts(mcdt, i, MCDT_ADC_FIFO_AF_INT)) {
                        struct sprd_mcdt_chan *chan = &mcdt->chan[i];

                        sprd_mcdt_chan_int_clear(mcdt, i, MCDT_ADC_FIFO_AF_INT);
                        if (chan->cb)
                                chan->cb->notify(chan->cb->data);
                }
        }

        for (i = 0; i < MCDT_DAC_CHANNEL_NUM; i++) {
                if (sprd_mcdt_chan_int_sts(mcdt, i, MCDT_DAC_FIFO_AE_INT)) {
                        struct sprd_mcdt_chan *chan =
                                &mcdt->chan[i + MCDT_ADC_CHANNEL_NUM];

                        sprd_mcdt_chan_int_clear(mcdt, i, MCDT_DAC_FIFO_AE_INT);
                        if (chan->cb)
                                chan->cb->notify(chan->cb->data);
                }
        }

        spin_unlock(&mcdt->lock);

        return IRQ_HANDLED;
}

/**
 * sprd_mcdt_chan_write - write data to the MCDT channel's fifo
 * @chan: the MCDT channel
 * @tx_buf: send buffer
 * @size: data size
 *
 * Note: We can not write data to the channel fifo when enabling the DMA mode,
 * otherwise the channel fifo data will be invalid.
 *
 * If there are not enough space of the channel fifo, it will return errors
 * to users.
 *
 * Returns 0 on success, or an appropriate error code on failure.
 */
int sprd_mcdt_chan_write(struct sprd_mcdt_chan *chan, char *tx_buf, u32 size)
{
        struct sprd_mcdt_dev *mcdt = chan->mcdt;
        unsigned long flags;
        int avail, i = 0, words = size / 4;
        u32 *buf = (u32 *)tx_buf;

        spin_lock_irqsave(&mcdt->lock, flags);

        if (chan->dma_enable) {
                dev_err(mcdt->dev,
                        "Can not write data when DMA mode enabled\n");
                spin_unlock_irqrestore(&mcdt->lock, flags);
                return -EINVAL;
        }

        if (sprd_mcdt_chan_fifo_sts(mcdt, chan->id, MCDT_DAC_FIFO_REAL_FULL)) {
                dev_err(mcdt->dev, "Channel fifo is full now\n");
                spin_unlock_irqrestore(&mcdt->lock, flags);
                return -EBUSY;
        }

        avail = sprd_mcdt_dac_fifo_avail(mcdt, chan->id);
        if (size > avail) {
                dev_err(mcdt->dev,
                        "Data size is larger than the available fifo size\n");
                spin_unlock_irqrestore(&mcdt->lock, flags);
                return -EBUSY;
        }

        while (i++ < words)
                sprd_mcdt_dac_write_fifo(mcdt, chan->id, *buf++);

        spin_unlock_irqrestore(&mcdt->lock, flags);
        return 0;
}
EXPORT_SYMBOL_GPL(sprd_mcdt_chan_write);

/**
 * sprd_mcdt_chan_read - read data from the MCDT channel's fifo
 * @chan: the MCDT channel
 * @rx_buf: receive buffer
 * @size: data size
 *
 * Note: We can not read data from the channel fifo when enabling the DMA mode,
 * otherwise the reading data will be invalid.
 *
 * Usually user need start to read data once receiving the fifo full interrupt.
 *
 * Returns data size of reading successfully, or an error code on failure.
 */
int sprd_mcdt_chan_read(struct sprd_mcdt_chan *chan, char *rx_buf, u32 size)
{
        struct sprd_mcdt_dev *mcdt = chan->mcdt;
        unsigned long flags;
        int i = 0, avail, words = size / 4;
        u32 *buf = (u32 *)rx_buf;

        spin_lock_irqsave(&mcdt->lock, flags);

        if (chan->dma_enable) {
                dev_err(mcdt->dev, "Can not read data when DMA mode enabled\n");
                spin_unlock_irqrestore(&mcdt->lock, flags);
                return -EINVAL;
        }

        if (sprd_mcdt_chan_fifo_sts(mcdt, chan->id, MCDT_ADC_FIFO_REAL_EMPTY)) {
                dev_err(mcdt->dev, "Channel fifo is empty\n");
                spin_unlock_irqrestore(&mcdt->lock, flags);
                return -EBUSY;
        }

        avail = sprd_mcdt_adc_fifo_avail(mcdt, chan->id);
        if (size > avail)
                words = avail / 4;

        while (i++ < words)
                sprd_mcdt_adc_read_fifo(mcdt, chan->id, buf++);

        spin_unlock_irqrestore(&mcdt->lock, flags);
        return words * 4;
}
EXPORT_SYMBOL_GPL(sprd_mcdt_chan_read);

/**
 * sprd_mcdt_chan_int_enable - enable the interrupt mode for the MCDT channel
 * @chan: the MCDT channel
 * @water_mark: water mark to trigger a interrupt
 * @cb: callback when a interrupt happened
 *
 * Now it only can enable fifo almost full interrupt for ADC channel and fifo
 * almost empty interrupt for DAC channel. Morevoer for interrupt mode, user
 * should use sprd_mcdt_chan_read() or sprd_mcdt_chan_write() to read or write
 * data manually.
 *
 * For ADC channel, user can start to read data once receiving one fifo full
 * interrupt. For DAC channel, user can start to write data once receiving one
 * fifo empty interrupt or just call sprd_mcdt_chan_write() to write data
 * directly.
 *
 * Returns 0 on success, or an error code on failure.
 */
int sprd_mcdt_chan_int_enable(struct sprd_mcdt_chan *chan, u32 water_mark,
                              struct sprd_mcdt_chan_callback *cb)
{
        struct sprd_mcdt_dev *mcdt = chan->mcdt;
        unsigned long flags;
        int ret = 0;

        spin_lock_irqsave(&mcdt->lock, flags);

        if (chan->dma_enable || chan->int_enable) {
                dev_err(mcdt->dev, "Failed to set interrupt mode.\n");
                spin_unlock_irqrestore(&mcdt->lock, flags);
                return -EINVAL;
        }

        switch (chan->type) {
        case SPRD_MCDT_ADC_CHAN:
                sprd_mcdt_adc_fifo_clear(mcdt, chan->id);
                sprd_mcdt_adc_set_watermark(mcdt, chan->id, water_mark,
                                            MCDT_FIFO_LENGTH - 1);
                sprd_mcdt_chan_int_en(mcdt, chan->id,
                                      MCDT_ADC_FIFO_AF_INT, true);
                sprd_mcdt_ap_int_enable(mcdt, chan->id, true);
                break;

        case SPRD_MCDT_DAC_CHAN:
                sprd_mcdt_dac_fifo_clear(mcdt, chan->id);
                sprd_mcdt_dac_set_watermark(mcdt, chan->id,
                                            MCDT_FIFO_LENGTH - 1, water_mark);
                sprd_mcdt_chan_int_en(mcdt, chan->id,
                                      MCDT_DAC_FIFO_AE_INT, true);
                sprd_mcdt_ap_int_enable(mcdt, chan->id, true);
                break;

        default:
                dev_err(mcdt->dev, "Unsupported channel type\n");
                ret = -EINVAL;
        }

        if (!ret) {
                chan->cb = cb;
                chan->int_enable = true;
        }

        spin_unlock_irqrestore(&mcdt->lock, flags);

        return ret;
}
EXPORT_SYMBOL_GPL(sprd_mcdt_chan_int_enable);

/**
 * sprd_mcdt_chan_int_disable - disable the interrupt mode for the MCDT channel
 * @chan: the MCDT channel
 */
void sprd_mcdt_chan_int_disable(struct sprd_mcdt_chan *chan)
{
        struct sprd_mcdt_dev *mcdt = chan->mcdt;
        unsigned long flags;

        spin_lock_irqsave(&mcdt->lock, flags);

        if (!chan->int_enable) {
                spin_unlock_irqrestore(&mcdt->lock, flags);
                return;
        }

        switch (chan->type) {
        case SPRD_MCDT_ADC_CHAN:
                sprd_mcdt_chan_int_en(mcdt, chan->id,
                                      MCDT_ADC_FIFO_AF_INT, false);
                sprd_mcdt_chan_int_clear(mcdt, chan->id, MCDT_ADC_FIFO_AF_INT);
                sprd_mcdt_ap_int_enable(mcdt, chan->id, false);
                break;

        case SPRD_MCDT_DAC_CHAN:
                sprd_mcdt_chan_int_en(mcdt, chan->id,
                                      MCDT_DAC_FIFO_AE_INT, false);
                sprd_mcdt_chan_int_clear(mcdt, chan->id, MCDT_DAC_FIFO_AE_INT);
                sprd_mcdt_ap_int_enable(mcdt, chan->id, false);
                break;

        default:
                break;
        }

        chan->int_enable = false;
        spin_unlock_irqrestore(&mcdt->lock, flags);
}
EXPORT_SYMBOL_GPL(sprd_mcdt_chan_int_disable);

/**
 * sprd_mcdt_chan_dma_enable - enable the DMA mode for the MCDT channel
 * @chan: the MCDT channel
 * @dma_chan: specify which DMA channel will be used for this MCDT channel
 * @water_mark: water mark to trigger a DMA request
 *
 * Enable the DMA mode for the MCDT channel, that means we can use DMA to
 * transfer data to the channel fifo and do not need reading/writing data
 * manually.
 *
 * Returns 0 on success, or an error code on failure.
 */
int sprd_mcdt_chan_dma_enable(struct sprd_mcdt_chan *chan,
                              enum sprd_mcdt_dma_chan dma_chan,
                              u32 water_mark)
{
        struct sprd_mcdt_dev *mcdt = chan->mcdt;
        unsigned long flags;
        int ret = 0;

        spin_lock_irqsave(&mcdt->lock, flags);

        if (chan->dma_enable || chan->int_enable ||
            dma_chan > SPRD_MCDT_DMA_CH4) {
                dev_err(mcdt->dev, "Failed to set DMA mode\n");
                spin_unlock_irqrestore(&mcdt->lock, flags);
                return -EINVAL;
        }

        switch (chan->type) {
        case SPRD_MCDT_ADC_CHAN:
                sprd_mcdt_adc_fifo_clear(mcdt, chan->id);
                sprd_mcdt_adc_set_watermark(mcdt, chan->id,
                                            water_mark, MCDT_FIFO_LENGTH - 1);
                sprd_mcdt_adc_dma_enable(mcdt, chan->id, true);
                sprd_mcdt_adc_dma_chn_select(mcdt, chan->id, dma_chan);
                sprd_mcdt_adc_dma_ack_select(mcdt, chan->id, dma_chan);
                break;

        case SPRD_MCDT_DAC_CHAN:
                sprd_mcdt_dac_fifo_clear(mcdt, chan->id);
                sprd_mcdt_dac_set_watermark(mcdt, chan->id,
                                            MCDT_FIFO_LENGTH - 1, water_mark);
                sprd_mcdt_dac_dma_enable(mcdt, chan->id, true);
                sprd_mcdt_dac_dma_chn_select(mcdt, chan->id, dma_chan);
                sprd_mcdt_dac_dma_ack_select(mcdt, chan->id, dma_chan);
                break;

        default:
                dev_err(mcdt->dev, "Unsupported channel type\n");
                ret = -EINVAL;
        }

        if (!ret)
                chan->dma_enable = true;

        spin_unlock_irqrestore(&mcdt->lock, flags);

        return ret;
}
EXPORT_SYMBOL_GPL(sprd_mcdt_chan_dma_enable);

/**
 * sprd_mcdt_chan_dma_disable - disable the DMA mode for the MCDT channel
 * @chan: the MCDT channel
 */
void sprd_mcdt_chan_dma_disable(struct sprd_mcdt_chan *chan)
{
        struct sprd_mcdt_dev *mcdt = chan->mcdt;
        unsigned long flags;

        spin_lock_irqsave(&mcdt->lock, flags);

        if (!chan->dma_enable) {
                spin_unlock_irqrestore(&mcdt->lock, flags);
                return;
        }

        switch (chan->type) {
        case SPRD_MCDT_ADC_CHAN:
                sprd_mcdt_adc_dma_enable(mcdt, chan->id, false);
                sprd_mcdt_adc_fifo_clear(mcdt, chan->id);
                break;

        case SPRD_MCDT_DAC_CHAN:
                sprd_mcdt_dac_dma_enable(mcdt, chan->id, false);
                sprd_mcdt_dac_fifo_clear(mcdt, chan->id);
                break;

        default:
                break;
        }

        chan->dma_enable = false;
        spin_unlock_irqrestore(&mcdt->lock, flags);
}
EXPORT_SYMBOL_GPL(sprd_mcdt_chan_dma_disable);

/**
 * sprd_mcdt_request_chan - request one MCDT channel
 * @channel: channel id
 * @type: channel type, it can be one ADC channel or DAC channel
 *
 * Rreturn NULL if no available channel.
 */
struct sprd_mcdt_chan *sprd_mcdt_request_chan(u8 channel,
                                              enum sprd_mcdt_channel_type type)
{
        struct sprd_mcdt_chan *temp;

        mutex_lock(&sprd_mcdt_list_mutex);

        list_for_each_entry(temp, &sprd_mcdt_chan_list, list) {
                if (temp->type == type && temp->id == channel) {
                        list_del_init(&temp->list);
                        break;
                }
        }

        if (list_entry_is_head(temp, &sprd_mcdt_chan_list, list))
                temp = NULL;

        mutex_unlock(&sprd_mcdt_list_mutex);

        return temp;
}
EXPORT_SYMBOL_GPL(sprd_mcdt_request_chan);

/**
 * sprd_mcdt_free_chan - free one MCDT channel
 * @chan: the channel to be freed
 */
void sprd_mcdt_free_chan(struct sprd_mcdt_chan *chan)
{
        struct sprd_mcdt_chan *temp;

        sprd_mcdt_chan_dma_disable(chan);
        sprd_mcdt_chan_int_disable(chan);

        mutex_lock(&sprd_mcdt_list_mutex);

        list_for_each_entry(temp, &sprd_mcdt_chan_list, list) {
                if (temp == chan) {
                        mutex_unlock(&sprd_mcdt_list_mutex);
                        return;
                }
        }

        list_add_tail(&chan->list, &sprd_mcdt_chan_list);
        mutex_unlock(&sprd_mcdt_list_mutex);
}
EXPORT_SYMBOL_GPL(sprd_mcdt_free_chan);

static void sprd_mcdt_init_chans(struct sprd_mcdt_dev *mcdt,
                                 struct resource *res)
{
        int i;

        for (i = 0; i < MCDT_CHANNEL_NUM; i++) {
                struct sprd_mcdt_chan *chan = &mcdt->chan[i];

                if (i < MCDT_ADC_CHANNEL_NUM) {
                        chan->id = i;
                        chan->type = SPRD_MCDT_ADC_CHAN;
                        chan->fifo_phys = res->start + MCDT_CH0_RXD + i * 4;
                } else {
                        chan->id = i - MCDT_ADC_CHANNEL_NUM;
                        chan->type = SPRD_MCDT_DAC_CHAN;
                        chan->fifo_phys = res->start + MCDT_CH0_TXD +
                                (i - MCDT_ADC_CHANNEL_NUM) * 4;
                }

                chan->mcdt = mcdt;
                INIT_LIST_HEAD(&chan->list);

                mutex_lock(&sprd_mcdt_list_mutex);
                list_add_tail(&chan->list, &sprd_mcdt_chan_list);
                mutex_unlock(&sprd_mcdt_list_mutex);
        }
}

static int sprd_mcdt_probe(struct platform_device *pdev)
{
        struct sprd_mcdt_dev *mcdt;
        struct resource *res;
        int ret, irq;

        mcdt = devm_kzalloc(&pdev->dev, sizeof(*mcdt), GFP_KERNEL);
        if (!mcdt)
                return -ENOMEM;

        mcdt->base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
        if (IS_ERR(mcdt->base))
                return PTR_ERR(mcdt->base);

        mcdt->dev = &pdev->dev;
        spin_lock_init(&mcdt->lock);
        platform_set_drvdata(pdev, mcdt);

        irq = platform_get_irq(pdev, 0);
        if (irq < 0)
                return irq;

        ret = devm_request_irq(&pdev->dev, irq, sprd_mcdt_irq_handler,
                               0, "sprd-mcdt", mcdt);
        if (ret) {
                dev_err(&pdev->dev, "Failed to request MCDT IRQ\n");
                return ret;
        }

        sprd_mcdt_init_chans(mcdt, res);

        return 0;
}

static void sprd_mcdt_remove(struct platform_device *pdev)
{
        struct sprd_mcdt_chan *chan, *temp;

        mutex_lock(&sprd_mcdt_list_mutex);

        list_for_each_entry_safe(chan, temp, &sprd_mcdt_chan_list, list)
                list_del(&chan->list);

        mutex_unlock(&sprd_mcdt_list_mutex);
}

static const struct of_device_id sprd_mcdt_of_match[] = {
        { .compatible = "sprd,sc9860-mcdt", },
        { }
};
MODULE_DEVICE_TABLE(of, sprd_mcdt_of_match);

static struct platform_driver sprd_mcdt_driver = {
        .probe = sprd_mcdt_probe,
        .remove = sprd_mcdt_remove,
        .driver = {
                .name = "sprd-mcdt",
                .of_match_table = sprd_mcdt_of_match,
        },
};

module_platform_driver(sprd_mcdt_driver);

MODULE_DESCRIPTION("Spreadtrum Multi-Channel Data Transfer Driver");
MODULE_LICENSE("GPL v2");