Example #1
0
/* rockchip_pcm_enqueue
 *
 * place a dma buffer onto the queue for the dma system
 * to handle.
*/
static void rockchip_pcm_enqueue(struct snd_pcm_substream *substream)
{
	struct rockchip_runtime_data *prtd = substream->runtime->private_data;	
	dma_addr_t pos = prtd->dma_pos;
	int ret;

//	DBG("Enter::%s----%d\n",__FUNCTION__,__LINE__);
        
	while (prtd->dma_loaded < prtd->dma_limit) {
		unsigned long len = prtd->dma_period;
//	DBG("dma_loaded: %d\n", prtd->dma_loaded);
		if ((pos + len) > prtd->dma_end) {
			len  = prtd->dma_end - pos;
		}

		if((len%(prtd->params->dma_size*16) == 0) && (prtd->params->flag == 1))                 
		{                                               
			ret = rk29_dma_config(prtd->params->channel,                                    
				prtd->params->dma_size, 16);                                            
			prtd->params->flag = 0;                                         
			DBG("size = 16, channel = %d, flag = %d\n",prtd->params->channel,prtd->params->flag);        
		}                               
		else if((len%(prtd->params->dma_size*16) != 0) && (prtd->params->flag == 0))            
		{                                               
			ret = rk29_dma_config(prtd->params->channel,                    
				prtd->params->dma_size, 1);                                             
			prtd->params->flag = 1;                                         
			DBG("size = 1, channel = %d, flag = %d\n",prtd->params->channel,prtd->params->flag);         
		}


		ret = rk29_dma_enqueue(prtd->params->channel,substream, pos, len);
//		if(prtd->params->channel == 2)
			DBG("Enter::%s, %d, ret=%d, Channel=%d, Addr=0x%X, Len=%lu\n",
                   __FUNCTION__,__LINE__, ret, prtd->params->channel, pos, len);		        
		if (ret == 0) {
			prtd->dma_loaded++;
			pos += prtd->dma_period;
			if (pos >= prtd->dma_end)
				pos = prtd->dma_start;
		} else 
			break;
	}

	prtd->dma_pos = pos;
}
Example #2
0
static int dma_init(struct rk_mmc *host)
{
	int res;

	res = rk29_dma_request(MMC_DMA_CHN, &mmc_client, NULL);
	if(res < 0)
		return res;

	res = rk29_dma_config(MMC_DMA_CHN, 4, 16);
	if(res < 0)
		return res;

	res = rk29_dma_set_buffdone_fn(MMC_DMA_CHN, dma_callback_func);

	return res;
}
static int __init dma_memcpy_probe(struct platform_device *pdev)
{
    int ret;
      
    ret = device_create_file(&pdev->dev, &driver_attr_dmamemcpy);
    rk29_dma_request(DMACH_DMAC0_MEMTOMEM, &rk29_dma_memcpy_client, NULL); 
    rk29_dma_config(DMACH_DMAC0_MEMTOMEM, 8);
    rk29_dma_set_buffdone_fn(DMACH_DMAC0_MEMTOMEM, rk29_dma_memcpy_callback);
    if(ret)
    {
        printk(">> fb1 dsp win0 info device_create_file err\n");
        ret = -EINVAL;
    }
   // printk(">>>>>>>>>>>>>>>>>>>>> dam_test_probe ok>>>>>>>>>>>>>>>>>>>>>>>>");        
    return 0;
}
static int rockchip_pcm_prepare(struct snd_pcm_substream *substream)
{
	struct rockchip_runtime_data *prtd = substream->runtime->private_data;
	int ret = 0;

	DBG("Enter::%s----%d\n",__FUNCTION__,__LINE__);

	/* return if this is a bufferless transfer e.g.
	 * codec <--> BT codec or GSM modem -- lg FIXME */
	if (!prtd->params)
		return 0;

        if(substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
                ret = rk29_dma_devconfig(prtd->params->channel, 
                               RK29_DMASRC_MEM, 
                               prtd->params->dma_addr);
        }else{
                ret = rk29_dma_devconfig(prtd->params->channel, 
                               RK29_DMASRC_HW, 
                               prtd->params->dma_addr);
        }
        DBG("Enter::%s, %d, ret=%d, Channel=%d, Addr=0x%X\n", __FUNCTION__, __LINE__, ret, prtd->params->channel, prtd->params->dma_addr);
        ret = rk29_dma_config(prtd->params->channel, 
                prtd->params->dma_size, 1);
		prtd->params->flag = 1;  

        DBG("Enter:%s, %d, ret = %d, Channel=%d, Size=%d\n", 
                __FUNCTION__, __LINE__, ret, prtd->params->channel, 
                prtd->params->dma_size);
                
        ret= rk29_dma_ctrl(prtd->params->channel, RK29_DMAOP_FLUSH);
        DBG("Enter:%s, %d, ret = %d, Channel=%d\n", 
                __FUNCTION__, __LINE__, ret, prtd->params->channel);
        
	prtd->dma_loaded = 0;
	prtd->dma_pos = prtd->dma_start;

	/* enqueue dma buffers */
	rockchip_pcm_enqueue(substream);
	return ret;
}
/* rockchip_pcm_enqueue
 *
 * place a dma buffer onto the queue for the dma system
 * to handle.
*/
static void rockchip_pcm_enqueue(struct snd_pcm_substream *substream)
{
	struct rockchip_runtime_data *prtd = substream->runtime->private_data;	
	dma_addr_t pos = prtd->dma_pos;
	unsigned int limit;
	int ret;

	DBG("Enter::%s----%d prtd->dma_period = %d prtd->dma_limit = %d\n",__FUNCTION__,__LINE__,prtd->dma_period,prtd->dma_limit);

	if (rk29_dma_has_circular())
		limit = (prtd->dma_end - prtd->dma_start) / prtd->dma_period;
	else
		limit = prtd->dma_limit;

	if (DMA_INFIN_LOOP()) {
		if(prtd->dma_period % (prtd->params->dma_size*16)){
			printk("dma_period(%d) is not an integer multiple of dma_size(%d)",prtd->dma_period,prtd->params->dma_size*16);
			rk29_dma_config(prtd->params->channel,
								prtd->params->dma_size, 1);
		}							
		else
			rk29_dma_config(prtd->params->channel,
							prtd->params->dma_size, 16);	
		ret = rk29_dma_enqueue_ring(prtd->params->channel,
				substream, pos, prtd->dma_period, limit ,true);
		if (ret == 0) 
			pos = prtd->dma_start;
	} else {
		while (prtd->dma_loaded < prtd->dma_limit) {
			unsigned long len = prtd->dma_period;
	//	DBG("dma_loaded: %d\n", prtd->dma_loaded);
			if ((pos + len) > prtd->dma_end) {
				len  = prtd->dma_end - pos;
			}

			if((len%(prtd->params->dma_size*16) == 0) && (prtd->params->flag == 1))
			{
				ret = rk29_dma_config(prtd->params->channel,
					prtd->params->dma_size, 16);
				prtd->params->flag = 0;
				DBG("size = 16, channel = %d, flag = %d\n",prtd->params->channel,prtd->params->flag);
			}
			else if((len%(prtd->params->dma_size*16) != 0) && (prtd->params->flag == 0))
			{
				ret = rk29_dma_config(prtd->params->channel,
					prtd->params->dma_size, 1);
				prtd->params->flag = 1;
				DBG("size = 1, channel = %d, flag = %d\n",prtd->params->channel,prtd->params->flag);
			}

			ret = rk29_dma_enqueue(prtd->params->channel,substream, pos, len);
	//		if(prtd->params->channel == 2)
				DBG("Enter::%s, %d, ret=%d, Channel=%d, Addr=0x%X, Len=%lu\n",
					   __FUNCTION__,__LINE__, ret, prtd->params->channel, pos, len);
			if (ret == 0) {
				prtd->dma_loaded++;
				pos += prtd->dma_period;
				if (pos >= prtd->dma_end)
					pos = prtd->dma_start;
			} else
				break;
		}
	}
	prtd->dma_pos = pos;
}