/*
 *
 *	Marvell Orion Alsa SOC Sound driver
 *
 *	Author: Yuval Elmaliah
 *	Copyright (C) 2008 Marvell Ltd.
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#include <linux/dma-mapping.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <linux/platform_device.h>
#include <sound/soc.h>
#include <sound/soc-dai.h>
#include <linux/mbus.h>
#include <linux/irqreturn.h>
#include <linux/version.h>
#include <linux/interrupt.h>
#include <asm/dma.h>
#include <linux/io.h>
#include <linux/scatterlist.h>
#include <asm/sizes.h>
#include <mvTypes.h>
#include <plat/i2s-orion.h>
#include "audio/mvAudioRegs.h"
#include "mv88fx-pcm.h"

#include "audio/mvAudio.h"
#include "ctrlEnv/mvCtrlEnvSpec.h"

#ifdef CONFIG_MACH_DOVE_RD_AVNG
#include <linux/gpio.h>
#include <asm/mach-types.h>
#endif

struct mv88fx_snd_chip *mv88fx_pcm_snd_chip;
EXPORT_SYMBOL_GPL(mv88fx_pcm_snd_chip);

static struct snd_pcm_hardware mv88fx_pcm_hardware = {
	.info = (SNDRV_PCM_INFO_INTERLEAVED |
		 SNDRV_PCM_INFO_MMAP |
		 SNDRV_PCM_INFO_MMAP_VALID |
		 SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_PAUSE),
	.formats = (SNDRV_PCM_FMTBIT_S16_LE |
		    SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE),
	.rates = (SNDRV_PCM_RATE_44100 |
		  SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000),
	.rate_min = 44100,
	.rate_max = 96000,
	.channels_min = 1,
	.channels_max = 2,
	.buffer_bytes_max = (16 * 1024 * 1024),
	.period_bytes_min = MV88FX_SND_MIN_PERIOD_BYTES,
	.period_bytes_max = MV88FX_SND_MAX_PERIOD_BYTES,
	.periods_min = MV88FX_SND_MIN_PERIODS,
	.periods_max = MV88FX_SND_MAX_PERIODS,
	.fifo_size = 0,

};

static void mv88fx_pcm_init_stream(struct mv88fx_snd_chip *chip,
				   struct mv88fx_snd_stream *stream,
				   int stream_id)
{
	memset(stream, 0, sizeof(*stream));
	if (stream_id == SNDRV_PCM_STREAM_PLAYBACK) {
		stream->dig_mode = 0;
		if (chip->pdata->i2s_play)
			stream->dig_mode |= I2S;
		if (chip->pdata->spdif_play)
			stream->dig_mode |= SPDIF;

		stream->mono_mode = MONO_BOTH;
		stream->stat_mem = 0;
		stream->clock_src = DCO_CLOCK;
	} else {
		if (chip->pdata->i2s_rec)
			stream->dig_mode = I2S;
		else if (chip->pdata->spdif_rec)
			stream->dig_mode = SPDIF;

		stream->mono_mode = MONO_LEFT;
		stream->stat_mem = 0;
		stream->clock_src = DCO_CLOCK;
	}
}


static int mv88fx_find_dram_cs(struct mbus_dram_target_info *dram,
			       u32 base, u32 size)
{
	int i;

	mv88fx_snd_debug("base=0x%x size=%u dram=%p", base, size, dram);

	for (i = 0; i < dram->num_cs; i++) {
		struct mbus_dram_window *cs = dram->cs + i;
		/* check if we fit into one memory window only */
		if ((base >= cs->base) &&
		    ((base + size) <= cs->base + cs->size))
			return i;

	}

	mv88fx_snd_error("");
	return -1;
}
static int mv88fx_config_dma_window(struct mv88fx_snd_chip *chip,
				    int dma, struct mbus_dram_target_info *dram)
{
	struct mbus_dram_window *cs;
	struct snd_pcm_substream *substream = chip->pcm->streams[dma].substream;

	int win;

#define WINDOW_CTRL(dma)		(0xA0C - ((dma) << 3))
#define WINDOW_BASE(dma)		(0xA08 - ((dma) << 3))

	mv88fx_snd_debug("");
	/*
	 * we have one window for each dma (playback dma and recording),
	 * confiure it to point to the dram window where the buffer falls in
	 */
	win = mv88fx_find_dram_cs(dram,
				  (u32) substream->dma_buffer.addr,
				  (u32) MV88FX_SND_MAX_PERIODS *
				  MV88FX_SND_MAX_PERIOD_BYTES);
	if (win < 0)
		return -1;

	cs = dram->cs + win;
	writel(((cs->size - 1) & 0xffff0000) |
	       (cs->mbus_attr << 8) |
	       (dram->mbus_dram_target_id << 4) | 1,
	       chip->base + MV_AUDIO_REGS_OFFSET(chip->port) + WINDOW_CTRL(dma));
	writel(cs->base,
	       chip->base + MV_AUDIO_REGS_OFFSET(chip->port) + WINDOW_BASE(dma));


#undef WINDOW_CTRL
#undef WINDOW_BASE

	return win;
}
static int mv88fx_conf_mbus_windows(struct mv88fx_snd_chip *chip,
				    struct mbus_dram_target_info *dram)
{
	mv88fx_snd_debug("");
	/*
	 * we have one window for playback and one for recording
	 */
	if (mv88fx_config_dma_window(chip, SNDRV_PCM_STREAM_PLAYBACK, dram) < 0)
		return -1;

	if (mv88fx_config_dma_window(chip, SNDRV_PCM_STREAM_CAPTURE, dram) < 0)
		return -1;
	return 0;
}


static irqreturn_t mv88fx_pcm_dma_interrupt(int irq, void *dev_id)
{
	struct mv88fx_snd_chip *chip = dev_id;
	struct snd_pcm_substream *play_stream =
	    chip->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
	struct snd_pcm_substream *capture_stream =
	    chip->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
	unsigned int status, mask;

	mv88fx_snd_debug("");

	spin_lock(&chip->reg_lock);

	/* read the active interrupt */
	mask = mv88fx_snd_readl(chip->base,
			MV_AUDIO_INT_MASK_REG(chip->port));
	status = mv88fx_snd_readl(chip->base,
			MV_AUDIO_INT_CAUSE_REG(chip->port)) & mask;

	do {

		if (status & ~(AICR_RECORD_BYTES_INT | AICR_PLAY_BYTES_INT)) {
			spin_unlock(&chip->reg_lock);
			snd_BUG();/* FIXME: should enable error interrupts */
			return IRQ_NONE;
		}

		/* acknowledge interrupt */
		mv88fx_snd_writel(chip->base,
			MV_AUDIO_INT_CAUSE_REG(chip->port), status);

		/* This is record event */
		if (status & AICR_RECORD_BYTES_INT) {
			mv88fx_snd_debug("capture");
			spin_unlock(&chip->reg_lock);
			if (capture_stream)
				snd_pcm_period_elapsed(capture_stream);
			spin_lock(&chip->reg_lock);
		}
		/* This is play event */
		if (status & AICR_PLAY_BYTES_INT) {
			mv88fx_snd_debug("playback");
			spin_unlock(&chip->reg_lock);
			if (play_stream)
				snd_pcm_period_elapsed(play_stream);
			spin_lock(&chip->reg_lock);

		}

		/* read the active interrupt */
		mask = mv88fx_snd_readl(chip->base,
				MV_AUDIO_INT_MASK_REG(chip->port));
		status = mv88fx_snd_readl(chip->base,
				MV_AUDIO_INT_CAUSE_REG(chip->port)) & mask;

	} while (status);

	spin_unlock(&chip->reg_lock);
	return IRQ_HANDLED;

}

static int mv88fx_pcm_hw_params(struct snd_pcm_substream *substream,
				struct snd_pcm_hw_params *params)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	int err = 0;

	mv88fx_snd_debug("substream=%p", substream);

	snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
	runtime->dma_bytes = params_buffer_bytes(params);
	return err;

}

static int mv88fx_pcm_hw_free(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct snd_dma_buffer *buf = runtime->dma_buffer_p;

	mv88fx_snd_debug("");

	if (runtime->dma_area == NULL)
		return 0;

	if (buf != &substream->dma_buffer)
		kfree(runtime->dma_buffer_p);

	snd_pcm_set_runtime_buffer(substream, NULL);
	return 0;
}

static int mv88fx_pcm_prepare(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct mv88fx_snd_stream *audio_stream = runtime->private_data;
	struct mv88fx_snd_chip *chip = mv88fx_pcm_get_chip();

	mv88fx_snd_debug("substream=%p chip=%p,chip->base=%p audio_stream=%p",
			 substream, chip, chip->base, audio_stream);

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		if ((audio_stream->dig_mode == I2S) &&
		    (chip->pcm_mode == NON_PCM)) {
			mv88fx_snd_error("");
			return -1;
		}

	return 0;
}

static int mv88fx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{
	mv88fx_snd_debug("");
	return 0;
}

static snd_pcm_uframes_t mv88fx_pcm_pointer(struct snd_pcm_substream *substream)
{
	struct mv88fx_snd_chip *chip = mv88fx_pcm_get_chip();
	struct snd_pcm_runtime *runtime = substream->runtime;
	snd_pcm_uframes_t offset;
	ssize_t size;

	mv88fx_snd_debug("");

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		size = (ssize_t) mv88fx_snd_readl(chip->base,
		       MV_AUDIO_PLAYBACK_BUFF_BYTE_CNTR_REG(chip->port));
		offset = bytes_to_frames(substream->runtime, size);
	} else {
		size = (ssize_t) mv88fx_snd_readl(chip->base,
			MV_AUDIO_RECORD_BUF_BYTE_CNTR_REG(chip->port));
		offset = bytes_to_frames(substream->runtime, size);
	}
	if (offset >= runtime->buffer_size)
		offset = 0;

	return offset;
}

static int mv88fx_pcm_open(struct snd_pcm_substream *substream)
{
	struct mv88fx_snd_chip *chip = mv88fx_pcm_get_chip();
	struct snd_pcm_runtime *runtime = substream->runtime;
	int err = 0;

	mv88fx_snd_debug("");

	runtime->private_data = &chip->stream[substream->stream];

	snd_soc_set_runtime_hwparams(substream, &mv88fx_pcm_hardware);

	err = snd_pcm_hw_constraint_minmax(runtime,
					   SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
					   chip->burst * 2,
					   AUDIO_REG_TO_SIZE(APBBCR_SIZE_MAX));
	if (err < 0)
		return err;

	err = snd_pcm_hw_constraint_step(runtime, 0,
					 SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
					 chip->burst);
	if (err < 0)
		return err;

	err = snd_pcm_hw_constraint_step(runtime, 0,
					 SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
					 chip->burst);
	if (err < 0)
		return err;

	err = snd_pcm_hw_constraint_minmax(runtime,
					   SNDRV_PCM_HW_PARAM_PERIODS,
					   MV88FX_SND_MIN_PERIODS,
					   MV88FX_SND_MAX_PERIODS);
	if (err < 0)
		return err;

	err = snd_pcm_hw_constraint_integer(runtime,
					    SNDRV_PCM_HW_PARAM_PERIODS);
	if (err < 0)
		return err;

	return 0;
}

static void mv88fx_pcm_reset_spdif_status(struct mv88fx_snd_chip *chip,
					  int usr_bits)
{
	int i;

	mv88fx_snd_debug("");

	for (i = 0; i < 4; i++) {
		chip->stream[SNDRV_PCM_STREAM_PLAYBACK].spdif_status[i] = 0;

		mv88fx_snd_writel(chip->base,
				  MV_AUDIO_SPDIF_PLAY_CH_STATUS_LEFT_REG(chip->
									 port,
									 i), 0);
		mv88fx_snd_writel(chip->base,
				  MV_AUDIO_SPDIF_PLAY_CH_STATUS_RIGHT_REG(chip->
									  port,
									  i),
				  0);
		if (usr_bits) {
			mv88fx_snd_writel(chip->base,
					  MV_AUDIO_SPDIF_PLAY_USR_BITS_LEFT_REG
					  (chip->port, i), 0);
			mv88fx_snd_writel(chip->base,
					  MV_AUDIO_SPDIF_PLAY_USR_BITS_RIGHT_REG
					  (chip->port, i), 0);
		}
	}

}

static int mv88fx_pcm_close(struct snd_pcm_substream *substream)
{
	struct mv88fx_snd_chip *chip = mv88fx_pcm_get_chip();

	mv88fx_snd_debug("");

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		chip->pcm_mode = PCM;
		mv88fx_pcm_reset_spdif_status(chip, 0);
	}
	return 0;
}

static int mv88fx_pcm_mmap(struct snd_pcm_substream *substream,
			   struct vm_area_struct *vma)
{
	struct snd_pcm_runtime *runtime = substream->runtime;

	mv88fx_snd_debug("");

	return dma_mmap_coherent(NULL, vma, runtime->dma_area,
				 runtime->dma_addr, runtime->dma_bytes);
}

struct snd_pcm_ops mv88fx_pcm_ops = {
	.open = mv88fx_pcm_open,
	.close = mv88fx_pcm_close,
	.ioctl = snd_pcm_lib_ioctl,
	.hw_params = mv88fx_pcm_hw_params,
	.hw_free = mv88fx_pcm_hw_free,
	.prepare = mv88fx_pcm_prepare,
	.trigger = mv88fx_pcm_trigger,
	.pointer = mv88fx_pcm_pointer,
	.mmap = mv88fx_pcm_mmap,
};

static int mv88fx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
{
	struct snd_pcm_substream *substream = pcm->streams[stream].substream;
	struct snd_dma_buffer *buf = &substream->dma_buffer;
	size_t size = MV88FX_SND_MAX_PERIODS * MV88FX_SND_MAX_PERIOD_BYTES;

	mv88fx_snd_debug("");

	buf->dev.type = SNDRV_DMA_TYPE_DEV;
	buf->dev.dev = pcm->card->dev;
	buf->private_data = NULL;
	buf->area = dma_alloc_coherent(pcm->card->dev,
				       size, &buf->addr, GFP_KERNEL);
	if (!buf->area) {
		mv88fx_snd_error("unable to allocate");
		return -ENOMEM;
	}
	buf->bytes = size;
	return 0;
}

static struct mv88fx_snd_chip *mv88fx_pcm_init(struct snd_pcm *pcm,
					       struct platform_device *pdev,
					       struct mv88fx_snd_machine_data
					       *machine_data)
{
	struct mv88fx_snd_chip *chip;

	mv88fx_snd_debug("");
	chip = mv88fx_pcm_snd_chip =
	    kzalloc(sizeof(struct mv88fx_snd_chip), GFP_KERNEL);
	if (!chip)
		return NULL;

	chip->base = machine_data->base;

	spin_lock_init(&chip->reg_lock);
	chip->dev = &pdev->dev;
	chip->port = machine_data->port;
	chip->pcm = pcm;
	chip->pdata = machine_data->pdata;
	chip->ch_stat_valid = 1;
	chip->burst = 128;
	chip->loopback = 0;
	chip->dco_ctrl_offst = 0x800;
	chip->irq = machine_data->irq;

	if (request_irq(machine_data->irq, mv88fx_pcm_dma_interrupt,
		0, DRIVER_NAME, (void *)chip)) {
		mv88fx_snd_error("");
		goto error;
	}
	if (chip->pdata->dram != NULL)
		if (mv88fx_conf_mbus_windows(chip, chip->pdata->dram)) {
			mv88fx_snd_error("");
			goto error;

		}


	mv88fx_pcm_init_stream(chip, &chip->stream[SNDRV_PCM_STREAM_PLAYBACK],
			       SNDRV_PCM_STREAM_PLAYBACK);
	mv88fx_pcm_init_stream(chip, &chip->stream[SNDRV_PCM_STREAM_CAPTURE],
			       SNDRV_PCM_STREAM_CAPTURE);
	chip->pcm_mode = PCM;

	mv88fx_pcm_reset_spdif_status(chip, 1);

	return chip;
error:
	free_irq(chip->irq, chip);
	kfree(chip);
	mv88fx_pcm_snd_chip = NULL;
	return NULL;
}

static int mv88fx_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
			  struct snd_pcm *pcm)
{
	static u64 mv88fx_pcm_dmamask = DMA_BIT_MASK(32);
	int ret = 0;
	struct platform_device *pdev = to_platform_device(card->dev);
	struct mv88fx_snd_machine_data *machine_data = pdev->dev.platform_data;
	struct mv88fx_snd_chip *chip;

	mv88fx_snd_debug("");

	if (!card->dev->dma_mask)
		card->dev->dma_mask = &mv88fx_pcm_dmamask;
	if (!card->dev->coherent_dma_mask)
		card->dev->coherent_dma_mask = DMA_BIT_MASK(32);

	if (dai->playback.channels_min) {
		ret = mv88fx_pcm_preallocate_dma_buffer(pcm,
					SNDRV_PCM_STREAM_PLAYBACK);
		if (ret) {
			mv88fx_snd_error("");
			goto out;
		}
	}

	if (dai->capture.channels_min) {
		ret = mv88fx_pcm_preallocate_dma_buffer(pcm,
					SNDRV_PCM_STREAM_CAPTURE);
		if (ret) {
			mv88fx_snd_error("");
			goto out;
		}
	}
	chip = mv88fx_pcm_init(pcm, pdev, machine_data);
	if (!chip)
		return -ENOMEM;

	return 0;
out:
	return ret;
}

static void mv88fx_pcm_free(struct snd_pcm *pcm)
{
	struct snd_pcm_substream *substream;
	struct snd_dma_buffer *buf;
	int stream;

	mv88fx_snd_debug("");

	for (stream = 0; stream < ARRAY_SIZE(pcm->streams); stream++) {
		substream = pcm->streams[stream].substream;
		if (!substream)
			continue;

		buf = &substream->dma_buffer;
		if (!buf->area)
			continue;
		dma_free_coherent(pcm->card->dev,
				  buf->bytes, buf->area, buf->addr);
		buf->area = NULL;
		buf->addr = 0;
	}
	free_irq(mv88fx_pcm_snd_chip->irq, mv88fx_pcm_snd_chip);
	kfree(mv88fx_pcm_snd_chip);
	mv88fx_pcm_snd_chip = NULL;
}


static int mv88fx_pcm_suspend(struct snd_soc_dai *cpu_dai)
{
	mv88fx_snd_debug("");


	return 0;
}


static int mv88fx_pcm_resume(struct snd_soc_dai *cpu_dai)
{
	mv88fx_snd_debug("");


	return 0;
}


struct snd_soc_platform mv88fx_soc_platform = {
	.name = DRIVER_NAME,
	.pcm_new = mv88fx_pcm_new,
	.pcm_free = mv88fx_pcm_free,
	.suspend  = mv88fx_pcm_suspend,
	.resume   = mv88fx_pcm_resume,
	.pcm_ops = &mv88fx_pcm_ops,
};
EXPORT_SYMBOL_GPL(mv88fx_soc_platform);


static int __init mv88fx_soc_platform_init(void)
{
	return snd_soc_register_platform(&mv88fx_soc_platform);
}
module_init(mv88fx_soc_platform_init);

static void __exit mv88fx_soc_platform_exit(void)
{
	snd_soc_unregister_platform(&mv88fx_soc_platform);
}
module_exit(mv88fx_soc_platform_exit);


MODULE_AUTHOR("Yuval Elmaliah <eyuval@marvell.com>");
MODULE_DESCRIPTION("mv88fx ASoc Platform driver");
MODULE_LICENSE("GPL");