/* linux/sound/htcleo/alsa-htc-leo.c
*
* Copyright (c) 2011, DFT, Cotulla
* Copyright (c) 2009, Code Aurora Forum. All rights reserved.
*
* All source code in this file is licensed under the following license except
* where indicated.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* See the GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, you can find it at http://www.fsf.org.
*/
/*

Cotulla: 

implemented playback and capture
this file use q6audio_* function primary, some new was added 


*/


#include <linux/init.h>
#include <linux/err.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/time.h>
#include <linux/wait.h>
#include <linux/kthread.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/dma-mapping.h>   

#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/initval.h>
#include <sound/control.h>

#include <asm/dma.h>

#include "alsa-htc-leo.h"



#if 1

#define DBG(fmt, arg...) \
    printk("[ALSA-PCM] %s " fmt "\n", __func__, ## arg)

#else

#define DBG(fmt, arg...) \
    do {} while (0);

#endif



static int qsd_audio_volume_update(struct qsd_audio *prtd);
static int qsd_pcm_mmap(struct snd_pcm_substream *substream, struct vm_area_struct *vma);


//-----------------------------------------------------------------------------------
// Fake DMA code
//------------------------------------------------------------------------
// 
// this thread emulate DMA transfer by QDSP
//

static int snd_qsd_fake_playback_dma_thread(void *data)
{
    int rc = 0;
    int rcopy;
    struct snd_pcm_substream *substream = (struct snd_pcm_substream *)data;
    struct snd_pcm_runtime *runtime = substream->runtime;
    struct qsd_audio *prtd = runtime->private_data;

    struct audio_buffer *ab;
    struct audio_client *ac;
    unsigned char *ptr;

    while (prtd->thread_exit == 0)
    {
        DBG(" start handler");

        // wait until state is changed
        // at this point this thread waits until SNDRV_PCM_TRIGGER_START comes
        // SNDRV_PCM_TRIGGER_STOP
        //
        wait_event_interruptible(prtd->fake_wait, (prtd->start == 1 || prtd->thread_exit == 1));
        DBG("  wake up %d %d", prtd->start, prtd->thread_exit);

        if (prtd->thread_exit) break;

        ac = prtd->ac;
        while (prtd->start == 1)
        {
            //  wait until new buffer appear
            //
            //            DBG("  ac = %X, prtd = %X, substream = %X", ac, prtd, substream);

            ab = ac->buf + ac->cpu_buf;
            if (ab->used)
            {
                DBG("wait a buffer %d", ac->cpu_buf);
                if (!wait_event_timeout(ac->wait, (ab->used == 0), 5 * HZ)) 
                {
                    DBG("timeout. dsp dead?\n");
                    rc = -EFAULT;
                    goto fail;
                }

                // some buffer become free, report about state change now
                //
                snd_pcm_period_elapsed(prtd->substream);
            }

            mutex_lock(&prtd->mlock);
        
            if (prtd->start == 0)
            {           
                DBG("flag is set - exit thread");
                mutex_unlock(&prtd->mlock);
                break;    // EXIT FROM LOOP
            }

            // send buffer to DSP
            //   
            ptr = runtime->dma_area + prtd->buf_curoff;
            rcopy = prtd->buf_chunk;
            if (rcopy > ab->size)
                rcopy = ab->size;

            memcpy(ab->data, ptr, rcopy);
            ab->used = rcopy;
            q6audio_write(ac, ab);
            ac->cpu_buf ^= 1;

            // move fake dma pointer forward
            //
            spin_lock(&prtd->lock);
            prtd->buf_curoff += prtd->buf_chunk;
            if (prtd->buf_curoff >= prtd->buf_maxoff) 
                prtd->buf_curoff = 0;       
            spin_unlock(&prtd->lock);        


            // update stream settings if required
            //
            if (qsd_glb_ctl.update) 
            {
                rc = qsd_audio_volume_update(prtd);
                qsd_glb_ctl.update = 0;
            }

            mutex_unlock(&prtd->mlock);

fail:     
            ; // CotullaTODO: handle this fault somehow.
        }
        DBG(" end handler");
    }
    DBG(" exit");
    return 0;
}


static int snd_qsd_fake_capture_dma_thread(void *data)
{
    int rc = 0;
    int rcopy;
    struct snd_pcm_substream *substream = (struct snd_pcm_substream *)data;
    struct snd_pcm_runtime *runtime = substream->runtime;
    struct qsd_audio *prtd = runtime->private_data;

    struct audio_buffer *ab;
    struct audio_client *ac;
    unsigned char *ptr;

    while (prtd->thread_exit == 0)
    {
        DBG(" start handler");

        // wait until state is changed
        // at this point this thread waits until SNDRV_PCM_TRIGGER_START comes
        // SNDRV_PCM_TRIGGER_STOP
        //
        wait_event_interruptible(prtd->fake_wait, (prtd->start == 1 || prtd->thread_exit == 1));
        DBG("  wake up %d %d", prtd->start, prtd->thread_exit);

        if (prtd->thread_exit) break;

        ac = prtd->ac;
        while (prtd->start == 1)
        {
            //  wait until new buffer appear
            //
            //            DBG("  ac = %X, prtd = %X, substream = %X", ac, prtd, substream);

            ab = ac->buf + ac->cpu_buf;
            if (ab->used)
            {
                DBG("wait a buffer %d", ac->cpu_buf);
                if (!wait_event_timeout(ac->wait, (ab->used == 0), 5 * HZ)) 
                {
                    DBG("timeout. dsp dead?\n");
                    rc = -EFAULT;
                    goto fail;
                }

                // some buffer become free, report about state change now
                //
                snd_pcm_period_elapsed(prtd->substream);
            }

            mutex_lock(&prtd->mlock);
        
            if (prtd->start == 0)
            {           
                DBG("flag is set - exit thread");
                mutex_unlock(&prtd->mlock);
                break;    // EXIT FROM LOOP
            }
    
            // this buffer must contains recorded data  
            // copy it to dma buffer
            //
            ptr = runtime->dma_area + prtd->buf_curoff;
            rcopy = prtd->buf_chunk;
            if (rcopy > ab->size)
                rcopy = ab->size;           
            memcpy(ptr, ab->data, rcopy);


            // send this buffer to DSP queue again
            //
            ab->used = rcopy;
            q6audio_read(ac, ab);
            ac->cpu_buf ^= 1;


            // move fake dma pointer forward
            //
            spin_lock(&prtd->lock);
            prtd->buf_curoff += prtd->buf_chunk;
            if (prtd->buf_curoff >= prtd->buf_maxoff) 
                prtd->buf_curoff = 0;       
            spin_unlock(&prtd->lock);        

            mutex_unlock(&prtd->mlock);

fail:     
            ; // CotullaTODO: handle this fault somehow.
        }
        DBG(" end handler");
    }
    DBG(" exit");
    return 0;
}



//-----------------------------------------------------------------------------------


struct snd_qsd 
{
    struct snd_card *card;
    struct snd_pcm *pcm;
};


struct qsd_ctl qsd_glb_ctl;
EXPORT_SYMBOL(qsd_glb_ctl);


struct audio_locks the_locks;
EXPORT_SYMBOL(the_locks);



static struct snd_pcm_hardware qsd_pcm_playback_hardware = 
{
    .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED,
    .formats = USE_FORMATS,
    .rates = USE_RATE,
    .rate_min = USE_RATE_MIN,
    .rate_max = USE_RATE_MAX,
    .channels_min = USE_CHANNELS_MIN,
    .channels_max = USE_CHANNELS_MAX,
    .buffer_bytes_max = MAX_BUFFER_SIZE,
    .period_bytes_min = MIN_PERIOD_SIZE,
    .period_bytes_max = MAX_PERIOD_SIZE,
    .periods_min = USE_PERIODS_MIN,
    .periods_max = USE_PERIODS_MAX,
    .fifo_size = 0,
};


static struct snd_pcm_hardware qsd_pcm_capture_hardware =
{
    .info = SNDRV_PCM_INFO_INTERLEAVED,
    .formats = USE_FORMATS,
    .rates = USE_RATE,
    .rate_min = USE_RATE_MIN,
    .rate_max = USE_RATE_MAX,
    .channels_min = USE_CHANNELS_MIN,
    .channels_max = USE_CHANNELS_MAX,
    .buffer_bytes_max = MAX_BUFFER_SIZE,
    .period_bytes_min = MIN_PERIOD_SIZE,
    .period_bytes_max = MAX_PERIOD_SIZE,
    .periods_min = USE_PERIODS_MIN,
    .periods_max = USE_PERIODS_MAX,
    .fifo_size = 0,
};



static int qsd_audio_volume_update(struct qsd_audio *prtd)
{
    int rc = 0;

    DBG("updating volume");

    if (!prtd->ac)
    {
        DBG("prtd->ac == NULL");
        return -EINVAL;
    }

    rc = q6audio_set_stream_volume(prtd->ac, qsd_glb_ctl.strm_volume);
    if (rc)                         
    {
        DBG("set stream volume failed\n");
    }
    return rc;
}



static int qsd_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{
    int ret = 0;
    struct snd_pcm_runtime *runtime = substream->runtime;
    struct qsd_audio *prtd = runtime->private_data;

    DBG("%d %X %X", cmd, prtd, prtd->ac);
    switch (cmd) 
    {
    case SNDRV_PCM_TRIGGER_START:
        DBG("TRIGGER_START");
        prtd->start = 1;
        wake_up(&prtd->fake_wait);
        break;
    case SNDRV_PCM_TRIGGER_RESUME:
    case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
        break;
    case SNDRV_PCM_TRIGGER_STOP:
        DBG("TRIGGER_STOP");
        prtd->start = 0;
        wake_up(&prtd->fake_wait);
        break;
    case SNDRV_PCM_TRIGGER_SUSPEND:
    case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
        break;
    default:
        ret = -EINVAL;
    }

    return ret;
}


static int hw_rule_periodsize_by_rate(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
{
    struct snd_interval *ps = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
    struct snd_interval *r = hw_param_interval(params,  SNDRV_PCM_HW_PARAM_RATE);
    struct snd_interval ch;

    if (!ps || !r)
        return 0;

    snd_interval_any(&ch);

    if (r->min > 8000) 
    {
        ch.min = 512;
        pr_debug("Minimum period size is adjusted to 512\n");
        return snd_interval_refine(ps, &ch);
    }
    return 0;
}


static int qsd_pcm_open(struct snd_pcm_substream *substream)
{
    struct snd_pcm_runtime *runtime = substream->runtime;
    struct qsd_audio *prtd;
    int rc = 0;

    DBG("+");

    prtd = kzalloc(sizeof(struct qsd_audio), GFP_KERNEL);
    if (prtd == NULL) 
    {
        rc = -ENOMEM;
        goto fail;
    }
    DBG(" prtd = %X", prtd);

    spin_lock_init(&prtd->lock);
    init_waitqueue_head(&prtd->fake_wait);
    mutex_init(&prtd->mlock);
        
    prtd->enabled = 0;
    prtd->substream = substream;

    if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 
    {
        DBG("Stream = SNDRV_PCM_STREAM_PLAYBACK");
        runtime->hw = qsd_pcm_playback_hardware;
        prtd->dir = SNDRV_PCM_STREAM_PLAYBACK;
    } 
    else 
    {
        DBG("Stream = SNDRV_PCM_STREAM_CAPTURE");
        runtime->hw = qsd_pcm_capture_hardware;
        prtd->dir = SNDRV_PCM_STREAM_CAPTURE;
    }

    /* Ensure that buffer size is a multiple of period size */
    rc = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
    if (rc < 0) 
    {
        kfree(prtd);
        goto fail;
    }

    rc = snd_pcm_hw_rule_add(substream->runtime, 0,
        SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
        hw_rule_periodsize_by_rate, substream,
        SNDRV_PCM_HW_PARAM_RATE, -1);

    if (rc < 0) 
    {
        kfree(prtd);
        goto fail;
    }

    runtime->private_data = prtd;        

fail:
    DBG("-: %d", rc);
    return rc;
}


static snd_pcm_uframes_t qsd_pcm_pointer(struct snd_pcm_substream *substream)
{
    struct snd_pcm_runtime *runtime = substream->runtime;
    struct qsd_audio *prtd = runtime->private_data;
    unsigned int res;

//    DBG("");

    res = prtd->buf_curoff;
    if (res >= prtd->buf_maxoff) DBG("fatal overflow: %d > %d", prtd->buf_curoff, prtd->buf_maxoff);

    DBG("res = %d", res);
    return bytes_to_frames(substream->runtime, res);
}



static int qsd_pcm_close(struct snd_pcm_substream *substream)
{
    struct snd_pcm_runtime *runtime = substream->runtime;
    struct qsd_audio *prtd = runtime->private_data;
    int ret = 0;

    DBG("+");
    if (prtd->enabled) 
    {
        if (prtd->ac)
        {
            q6audio_close(prtd->ac);
        }
    }

    prtd->enabled = 0;
    kfree(prtd);

    DBG("-");
    return ret;
}



//-----------------------------------------------------------------------------------
// Playback
//-----------------------------------------------------------------------------------



static int qsd_pcm_playback_prepare(struct snd_pcm_substream *substream)
{
    int rc = 0;
    struct snd_pcm_runtime *runtime = substream->runtime;
    struct qsd_audio *prtd = runtime->private_data;
    unsigned long acdb_id = 0;

    DBG ("+");

    if (prtd->enabled)
    {
        DBG("already enabled");
        goto fail;
    }

    prtd->buf_maxoff = snd_pcm_lib_buffer_bytes(substream);
    prtd->buf_chunk  = snd_pcm_lib_period_bytes(substream);
    prtd->start = 0;

    DBG("INFO:");
    DBG("\tMaxSize = %d, MaxPeriod = %d", prtd->buf_maxoff, prtd->buf_chunk);
    DBG("\tRate = %d, Channels = %d", runtime->rate, runtime->channels);

    acdb_id = qsd_glb_ctl.acdb_tx_id;
    prtd->ac = q6audio_open_pcm(prtd->buf_chunk, runtime->rate, runtime->channels, AUDIO_FLAG_WRITE, acdb_id);
    if (prtd->ac == NULL)
    {
        DBG("q6audio_open_pcm() failed");
        rc = -ENOMEM;
        goto fail;
    }

    q6audio_set_stream_volume(prtd->ac, qsd_glb_ctl.strm_volume);

    prtd->enabled = 1;

fail:
    DBG ("-: %d", rc);
    return rc;
}


//-----------------------------------------------------------------------------------
// Capture
//-----------------------------------------------------------------------------------


static int qsd_pcm_capture_prepare(struct snd_pcm_substream *substream)
{
    struct snd_pcm_runtime *runtime = substream->runtime;
    struct qsd_audio *prtd = runtime->private_data;
    int rc = 0;
    uint32_t acdb_id = 0;

    if (prtd->enabled)
    {
        DBG("already enabled");
        goto fail;
    }

    prtd->buf_maxoff = snd_pcm_lib_buffer_bytes(substream);
    prtd->buf_chunk  = snd_pcm_lib_period_bytes(substream);
    prtd->start = 0;

    DBG("INFO:");
    DBG("\tMaxSize = %d, MaxPeriod = %d", prtd->buf_maxoff, prtd->buf_chunk);
    DBG("\tRate = %d, Channels = %d", runtime->rate, runtime->channels);

    acdb_id = qsd_glb_ctl.acdb_rx_id;
    prtd->ac = q6audio_open_pcm(prtd->buf_chunk, runtime->rate, runtime->channels, AUDIO_FLAG_READ, acdb_id);
    if (!prtd->ac)
    {
        DBG("q6audio_open_pcm fails");
        rc = -ENOMEM;
        goto fail;
    }

    prtd->enabled = 1;

fail:
    DBG ("-: %d", rc);
    return rc;
}


//-----------------------------------------------------------------------------------
// ALSA thunks
//-----------------------------------------------------------------------------------


static int qsd_pcm_prepare(struct snd_pcm_substream *substream)
{
    int ret = 0;

    if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
        ret = qsd_pcm_playback_prepare(substream);
    else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
        ret = qsd_pcm_capture_prepare(substream);
    return ret;
}


int qsd_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params)
{
    int rc = 0;
    struct snd_pcm_runtime *runtime = substream->runtime;
    struct qsd_audio *prtd = runtime->private_data;
    unsigned long totbytes = params_buffer_bytes(params);

    DBG("+: totbytes=%d", totbytes);

    snd_pcm_lib_malloc_pages(substream, totbytes);


    if (prtd->fake_dma_started == 0)
    {
        prtd->fake_dma_started = 1;
        DBG("create thread");

        prtd->thread_exit = 0;
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
        {
            prtd->fake_dma_thread = kthread_run(snd_qsd_fake_playback_dma_thread, (void*)substream, "leo_alsa_fake_playback_dma");
        }
        else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
        {
            prtd->fake_dma_thread = kthread_run(snd_qsd_fake_capture_dma_thread, (void*)substream, "leo_alsa_fake_capture_dma");
        }
        else
        {
            DBG("Wrong direction?");
            prtd->fake_dma_started = 0;
            rc = -ENOMEM;
            goto fail;
        }

        if (IS_ERR(prtd->fake_dma_thread)) 
        {
            rc = PTR_ERR(prtd->fake_dma_thread);
            goto fail;
        }
    }
    runtime->dma_bytes = totbytes;

fail:
    DBG("-: %d", rc);
    return 0;
}


static int qsd_pcm_hw_free(struct snd_pcm_substream *substream)
{
    struct snd_pcm_runtime *runtime = substream->runtime;
    struct qsd_audio *prtd = runtime->private_data;

    DBG("+");

    // Cotulla: this prevents freeing memory during execution code 
    // inside capture thread. 
    // if copy data / put buffer code executed inside thread
    // this will wait util it finishes. then start = 0 will cancel the next loop.
    //
    mutex_lock(&prtd->mlock);
    mutex_unlock(&prtd->mlock);

    snd_pcm_lib_free_pages(substream);

    if (prtd->fake_dma_started == 1)
    {
        prtd->fake_dma_started = 0;

        prtd->thread_exit = 1;
        wake_up(&prtd->fake_wait);

        // Cotulla: POSSIBLE DEADLOCK IF THREAD DOES NOT EXIT
        //
        kthread_stop(prtd->fake_dma_thread);    
    }
    
    DBG("-"); 
    return 0;
}



struct snd_pcm_ops qsd_pcm_ops = 
{
    .open   = qsd_pcm_open,
    .close  = qsd_pcm_close,
    .hw_params = qsd_pcm_hw_params,
    .hw_free   = qsd_pcm_hw_free,
    .ioctl   = snd_pcm_lib_ioctl,
    .prepare = qsd_pcm_prepare,
    .trigger = qsd_pcm_trigger,
    .pointer = qsd_pcm_pointer,
};
EXPORT_SYMBOL_GPL(qsd_pcm_ops);



/*
static int qsd_pcm_remove(struct platform_device *devptr)
{
    struct snd_soc_device *socdev = platform_get_drvdata(devptr);

    DBG("");
    platform_set_drvdata(devptr, NULL);
    return 0;
}
*/


//==================================================================================
// Init
//==================================================================================


int htcleo_alsa_init_pcm(struct snd_card *card)
{
    struct snd_pcm *pcm;
    int rc;

    DBG("+");

    rc = snd_pcm_new(card,
                   /* ID */             "htcleo_snd",
                   /* device */         0,
                   /* playback count */ 1,
                   /* capture count */  1, &pcm);
    if (rc < 0)
    {
        DBG("snd_pcm_new() failed %d", rc);
        goto fail;
    }

    snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &qsd_pcm_ops);
    snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &qsd_pcm_ops);

    pcm->private_data = 0; 
    pcm->info_flags = 0;
    strcpy(pcm->name, card->shortname);

    rc = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
                        snd_dma_continuous_data(GFP_KERNEL), 64*1024, 64*1024);
    if (rc < 0)
    {
        DBG("snd_pcm_lib_preallocate_pages_for_all() failed %d", rc);
        goto fail;
    }

fail:
    DBG("-:%d", rc);
    return rc;
}
EXPORT_SYMBOL_GPL(htcleo_alsa_init_pcm);

MODULE_AUTHOR("DFT-Cotulla");
MODULE_DESCRIPTION("HTC LEO ALSA PCM driver");
MODULE_LICENSE("GPL v2");