em8xxx_oss.c

Sigma SMP8634 Mrua v. 2.8.2.0

				err=EMhwlibReceiveBuffer(pE->pemhwlib, param.moduleId, &(param.bus_addr), &(param.dataSize), info, &(param.infoSize), &context);
				kc_spin_unlock_bh(pE->lock);	      
				if((err != RM_OK) && (err != RM_INSUFFICIENT_SIZE)){
					printk("fatal arror while receiving buffer. abort, err = %d \n",err);
					return -EINVAL;
				}
				
				if(err == RM_INSUFFICIENT_SIZE){
					rc=kc_interruptible_sleep_on_timeout(pS->sq,US_TO_JIFFIES(RECEIVEDATA_TIMEOUT_US));
					if (kc_signal_pending_current()){
						return -EINVAL;
					}
				}
			}
			
			pS->capture_buffer_bus_addr = param.bus_addr;
			pS->capture_pBuf=kdmapool_get_virt_address(pE->pllad,pS->capture_dmapool_id,pS->capture_buffer_bus_addr, 0);
			pS->capture_buffer_size = param.dataSize;
			pS->capture_readable = param.dataSize;
			pS->capture_read=0;
			pS->i_start = 0;
		}
		
		else {
			pS->i_start = pS->last_i;
		}
		
		pS->j_start = pS->last_j;
		
		i=pS->i_start;
		j=pS->j_start;
		printk("i = %ld , j = %ld \n, nb_bits_per_sample = %d, channel_count = %d \n",i,j,pS->nb_bits_per_sample,pS->channel_count);
		while (j<count){
			
			if(i>=pS->capture_buffer_size){
				break;
			}
			
			switch(pS->state){
			case 0:
				if(pS->nb_bits_per_sample==8)
					buffer[j]=pS->capture_pBuf[i]+128;
				else
					buffer[j]=pS->capture_pBuf[i];
				j++;
				break;
		
			case 1:
				if(pS->nb_bits_per_sample==16){
					buffer[j]=pS->capture_pBuf[i];
					j++;
				}
				break;
			default:
				break;
			}
			
			i++;	
			pS->state ++;
			
			if(pS->channel_count==1)
				pS->state %= 6;
			else
				pS->state %= 3;
		}
		
		
		pS->last_i = i;
		pS->last_j = j;
		
		if (i >= pS->capture_buffer_size){
			
		 	/* Release buffer */
			printk("release buffer \n");
			if(pS->capture_pBuf != NULL){
				kdmapool_release(pE->pllad,pS->capture_dmapool_id,pS->capture_buffer_bus_addr);
				pS->capture_pBuf = NULL;
				prepare_data(pS);
			}
		}

		if (j == count){
			pS->last_j = 0;
			break;
		}
		
	}
 	if(pS->nb_bits_per_sample==16){
 		// byte-swap
 		RMuint32 l;
 		RMint8 temp;
 		for (l=0;l<count;l+=2){
 			temp = buffer[l];
 			buffer[l] = buffer[l+1];
 			buffer[l+1] = temp;
 		}
	}
	return count;
}

static ssize_t rm_write_dsp(struct file *file, const char *buffer, size_t count, loff_t *ppos){
	
	struct emhwlib_info Info;
	struct emhwlib_info *pInfo = &Info;
	struct em8xxx_data param;
	int rc;
	RMuint32 Info_size;
	RMuint32 time_resolution;
	RMuint64 time;
	struct sndprivate *pS=(struct sndprivate *)file->private_data;
	struct em8xxxprivate *pE;
	RMstatus err;
	void * context;
	long timeout;
	RMuint32 it=0,timeout_buffer = 0;
	size_t length = count;
	size_t played_size=0;

	pE=Etable+(pS-Stable);

	if(!pS->playback_enable){
		rc=start_playback(pE);

		if(RMFAILED(rc)){
			printk("error while starting playback \n");
			return -EINVAL;
		}
	}

	while (length > 0) {
		size_t chunk_size;

		if (pS->pBuf==NULL){
			timeout=0;
			while (timeout < 1000000) {

				pS->pBuf=kdmapool_getbuffer(pE->pllad,pS->dmapool_id,&timeout_buffer);

				if (pS->pBuf)
					break;
				timeout += kc_interruptible_sleep_on_timeout(pE->wq,US_TO_JIFFIES(10000));
				if (signal_pending(current)) {
					rc=-ERESTARTSYS;
					break;
				}
			}
		}

		if (length > (1 << AUDIO_DMA_BUFFER_SIZE_LOG2))
			chunk_size = (1 << AUDIO_DMA_BUFFER_SIZE_LOG2);
		else
			chunk_size = length;

		kc_logging_copy_from_user(pS->pBuf,buffer+played_size,chunk_size);

		if (pS->firstPTS) {
			pS->firstPTS = FALSE;
			Info.ValidFields = TIME_STAMP_INFO;
			EM8XXXSNDGP(pE,EMHWLIB_MODULE(STC,audio_decoder_index),RMSTCPropertyID_AudioTimeResolution,&time_resolution,sizeof(time_resolution));
			EM8XXXSNDEXP(pE, EMHWLIB_MODULE(STC,audio_decoder_index),RMSTCPropertyID_TimeInfo,&time_resolution,sizeof(time_resolution),&time,sizeof(time));
			
			Info.TimeStamp = time;
			pInfo = &Info;
			Info_size = sizeof(Info);
		}
		else {
			pInfo = NULL;
			Info_size = 0;
		}

		param.moduleId = EMHWLIB_MODULE(AudioDecoder,audio_decoder_index);
		param.poolId = pS->dmapool_id;
		param.dataSize = chunk_size;
		param.bus_addr = kdmapool_get_bus_address(pE->pllad,pS->dmapool_id,pS->pBuf,chunk_size);
		kc_flush_cache((void *)param.bus_addr,chunk_size);

		context =(void *) (((pE-Etable) << 16) + param.poolId + 1);

		err=RM_INSUFFICIENT_SIZE;
		while(err==RM_INSUFFICIENT_SIZE){
			it ++;
			if(it >= 1000){
				printk("forced to quit loop \n");
				return -EINVAL;
			}
		
			kc_spin_lock_bh(pE->lock);
			err = EMhwlibSendBuffer(pE->pemhwlib, param.moduleId, param.bus_addr, param.dataSize, pInfo, Info_size, context);
			kc_spin_unlock_bh(pE->lock);

			if((err != RM_OK) && (err != RM_INSUFFICIENT_SIZE)){
				printk("fatal error while receiving buffer. abort, err = %d \n",err);
				return -EINVAL;
			}
			
		}
		
		timeout=0;
		while (timeout < 1000000) {
			pS->pBuf=kdmapool_getbuffer(pE->pllad,pS->dmapool_id,&timeout_buffer);

			if (pS->pBuf)
				break;
			timeout += kc_interruptible_sleep_on_timeout(pE->wq,US_TO_JIFFIES(10000));
			if (signal_pending(current)) {
				rc=-ERESTARTSYS;
				break;
			}
		}

		length -= chunk_size;
		played_size += chunk_size;

	}

	return count;
}

static unsigned int rm_poll_dsp(struct file *file, struct poll_table_struct *wait){return 0;}
static int rm_mmap_dsp(struct file *file, struct vm_area_struct *vma){return 0;}

static int rm_ioctl_dsp(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	struct sndprivate *pS=(struct sndprivate *)file->private_data;
	int rc;
	
	rc = process_ioctl_dsp(pS, cmd, arg);

	return rc;
	
}
static RMstatus start_capture(struct em8xxxprivate *pE)
{
	enum AudioCapture_Capture_type cmd;
	struct sndprivate *pS = Stable + (pE-Etable);
	RMstatus err;
	RMuint32 audio_capture = EMHWLIB_MODULE(AudioCapture,audio_capture_index);

	printk("start capture \n");
	
	//  Enabling audio capture
	cmd = AudioCapture_Capture_On;
	EM8XXXSNDSP(pE, audio_capture,RMAudioCapturePropertyID_Capture, &cmd, sizeof(cmd));

	pS->capture_enable = TRUE;

	return err;
}

static RMstatus start_playback(struct em8xxxprivate *pE)
{
	struct sndprivate *pS = Stable + (pE-Etable);
	enum AudioDecoder_Command_type command;
	RMuint32 audio_decoder = EMHWLIB_MODULE(AudioDecoder,audio_decoder_index);
	RMstatus err=RM_OK;
	enum AudioDecoder_State_type state;
	int rc;
  	long timeout;
	long timeout_jiffies = (unsigned long long) 100000*(unsigned long long)HZ/1000000ULL; //10^-1 sec
/* 	RMuint32 pts_delay = PTS_FIRST_DELAY; */
	RMuint32 AudioBtsThreshold=AUDIO_BTS_THRESHOLD;

	EM8XXXSNDSP(pE,audio_decoder, RMAudioDecoderPropertyID_AudioBtsThreshold, &AudioBtsThreshold,sizeof(RMuint32));

	// Change the decoder status to Play Mode
	
	command = AudioDecoder_Command_Play;

	EM8XXXSNDSP(pE, audio_decoder, RMAudioDecoderPropertyID_Command, &command, sizeof(command));

	if (RMFAILED(err)){
		RMDBGLOG((ENABLE, "Error while sending Play command to Audio Decoder! \n"));
		return err;
	}
	else printk("play command sended to the audio decoder \n");
	timeout=0;
	while (timeout < 100000) {
		EM8XXXSNDGP(pE, audio_decoder,RMAudioDecoderPropertyID_State, &state, sizeof(state));
		if (state == AudioDecoder_State_Playing)
			break;
		timeout += kc_interruptible_sleep_on_timeout(pE->wq,timeout_jiffies);
		if (signal_pending(current)) {
			rc=-ERESTARTSYS;
			break;
		}
	}
	
	pS->playback_enable = TRUE;
	return err;
}

#if 0
static RMstatus set_audio_parameters(struct em8xxxprivate *pE, int format, int sampleRate, int channelCount)
{
	int rc;
       	long timeout;
	long timeout_jiffies = (unsigned long long) 100000*(unsigned long long)HZ/1000000ULL; //10^-1 sec
	enum AudioDecoder_Command_type command;
	enum AudioDecoder_State_type state;
	enum AudioDecoder_Codec_type codec;
	RMuint32 audio_decoder = EMHWLIB_MODULE(AudioDecoder,audio_decoder_index);
	RMuint32 audio_engine = EMHWLIB_MODULE(AudioEngine,audio_engine_index);
	struct sndprivate *pS=Stable+(pE-Etable);
	enum AudioEngine_SerialOut_type serialOutStatus;
	struct AudioEngine_SampleFrequencyFromSource_type sf;
	struct AudioEngine_I2SConfig_type i2s;
	enum AudioEngine_SpdifOut_type spdif_out;
	RMstatus err;
	struct AudioDecoder_PcmCdaParameters_type pcm_parameters;
	struct AudioEngine_Volume_type volume;
	int i,closed;
	struct AudioDecoder_AudioPlayTime_type play_time;
	struct AudioDecoder_MixerWeight_type cmdblock;

	if ((!format) || (!sampleRate) || (!channelCount))
		return 0;
	
	pS->capture_enable = FALSE;
	
	// Volume Initialization
	for (i = 0; i <= 9; i++){
		volume.Channel = i;
		volume.Volume = 0x10000000;
	
		EM8XXXSNDSP(pE, audio_engine, RMAudioEnginePropertyID_Volume, &volume, sizeof(volume));
	
		if (RMFAILED(err)){
			RMDBGLOG((ENABLE, "Error while setting audio volume! \n"));
			return err;
		}
	}
	
	pS->volume = 70 + (70<<8);
	// Mixer weight initialization

	cmdblock.MixerValue_ch0=0x10000000;
	cmdblock.MixerValue_ch1=0x10000000;
	cmdblock.MixerValue_ch2=0x10000000;
	cmdblock.MixerValue_ch3=0x10000000;
	cmdblock.MixerValue_ch4=0x10000000;
	cmdblock.MixerValue_ch5=0x10000000;
	cmdblock.MixerValue_ch6=0x10000000;
	cmdblock.MixerValue_ch7=0x10000000;
	
	EM8XXXSNDSP( pE, audio_decoder,RMAudioDecoderPropertyID_MixerWeight,&cmdblock,sizeof(cmdblock));
	
	
	pS->weight = 70 + (70<<8);

	// We have to know if the other decoder is working

	closed=1;

#ifdef RMFEATURE_HAS_AUDIO_ENGINE_1
	switch(audio_engine_index){
	case 0:
		state = 0;
		EM8XXXSNDGP(pE,EMHWLIB_MODULE(AudioDecoder,1-audio_decoder_index),RMAudioDecoderPropertyID_State,&state,sizeof(state));
		if (state != AudioDecoder_State_Closed) closed=0;
		break;
	case 1:
		if (audio_decoder_index==2){
			EM8XXXSNDGP(pE,EMHWLIB_MODULE(AudioDecoder,3),RMAudioDecoderPropertyID_State,&state,sizeof(state));
		}
		else
			EM8XXXSNDGP(pE,EMHWLIB_MODULE(AudioDecoder,2),RMAudioDecoderPropertyID_State,&state,sizeof(state));
		if (state != AudioDecoder_State_Closed) closed=0;
		break;
	}
	
#else
	EM8XXXSNDGP(pE,EMHWLIB_MODULE(AudioDecoder,1-audio_decoder_index),RMAudioDecoderPropertyID_State,&state,sizeof(state));
	if (state != AudioDecoder_State_Closed) closed=0;
	
#endif // RMFEATURE_HAS_AUDIO_ENGINE_1		
	
	if(closed==1){
		// Setting the sample freqency
		EM8XXXSNDSP(pE, audio_engine, RMAudioEnginePropertyID_SampleFrequency, &sampleRate, sizeof(sampleRate));

		if (RMFAILED(err)){
			printk("Error while setting the sample frequency\n");
			return err;
		}

		// Applying AudioEngine Module Options
		spdif_out = AudioEngine_SpdifOut_Active;
		
		EM8XXXSNDSP(pE, audio_engine, RMAudioEnginePropertyID_SpdifOut, &spdif_out, sizeof(spdif_out));
		
		if (RMFAILED (err)) {
			RMDBGLOG((ENABLE, "Error setting spdif_out property! \n"));
			return err;
		}
		
		
		sf.GeneratorNumber = 3;
		sf.SampleFrequency = sampleRate;
		sf.Source = 1;
		sf.SourceFrequency = 27000000;
		sf.IntermediateFrequency = 148500000;
		
		EM8XXXSNDSP(pE, audio_engine, RMAudioEnginePropertyID_SampleFrequencyFromSource, &sf, sizeof(sf));
		
		if (RMFAILED (err)) {
			RMDBGLOG((ENABLE, "Error setting sf property! \n"));
			return err;
		}
		
		i2s.DataAlignment = 1;
		i2s.SClkInvert = TRUE;
		i2s.FrameInvert = TRUE;
		i2s.MSBFirst = TRUE;
		i2s.SampleSize16Bit = FALSE;
		
		EM8XXXSNDSP(pE, audio_engine, RMAudioEnginePropertyID_I2SConfig, &i2s, sizeof(i2s));
		
		if (RMFAILED (err)) {
			RMDBGLOG((ENABLE, "Error setting i2s property! \n"));
			return err;
		}
		
		
		serialOutStatus = AudioEngine_SerialOut_SO_ENABLE;
		
		EM8XXXSNDSP(pE, audio_engine, RMAudioEnginePropertyID_SerialOut, &serialOutStatus, sizeof(serialOutStatus));
		
		if (RMFAILED (err)) {
			RMDBGLOG((ENABLE, "Error setting serialOut property! \n"));
			return err;
		}
	}	
	codec = pS->format;

	//   Uninit
	timeout = 0;
	command = AudioDecoder_Command_Uninit;

	EM8XXXSNDSP(pE,audio_decoder,RMAudioDecoderPropertyID_Command,&command,sizeof(command));

	if (RMFAILED(err)){
		RMDBGLOG((ENABLE, "Unable to Uninit \n"));
		return err;
	}
	while (timeout < 1000000) {
		
		EM8XXXSNDGP(pE, audio_decoder,RMAudioDecoderPropertyID_State, &state, sizeof(state));
		
		if (state == AudioDecoder_State_Uninitialized)
			break;
		timeout += kc_interruptible_sleep_on_timeout(pE->wq,timeout_jiffies);
		if (signal_pending(current)) {
			rc=-ERESTARTSYS;
			break;
		}
	}
	if (timeout >= 1000000) {
		RMDBGLOG((ENABLE, "Error setting uninit state! \n"));
		return -EINVAL;
	}

	//  Format

	EM8XXXSNDSP(pE, audio_decoder, RMAudioDecoderPropertyID_Codec, &codec, sizeof(codec));

	if (RMFAILED(err)){
		RMDBGLOG((ENABLE, "Error setting codec property! \n"));
		return err;
	}

	// PCM Parameters
	
	switch(channelCount) {
	case 1:
		pcm_parameters.ChannelAssign = PcmCda1_C;
		break;
	case 2:
		pcm_parameters.ChannelAssign = PcmCda2_LR;
		break;
	default:
		pcm_parameters.ChannelAssign = PcmCda2_LR;
		break;
	}
	pcm_parameters.BitsPerSample = pS->nb_bits_per_sample;
	pcm_parameters.SamplingFrequency = sampleRate;
	pcm_parameters.MsbFirst = pS->MSBFirst;
	pcm_parameters.OutputDualMode = DualMode_Stereo;
	pcm_parameters.OutputSpdif = OutputSpdif_Uncompressed;
	pcm_parameters.OutputChannels = Audio_Out_Ch_LR;
	pcm_parameters.OutputLfe = FALSE;
	pcm_parameters.SignedPCM = (pS->nb_bits_per_sample==16) ? TRUE : FALSE;
	pcm_parameters.BassMode = 0;


	EM8XXXSNDSP(pE, audio_decoder, RMAudioDecoderPropertyID_PcmCdaParameters, &pcm_parameters, sizeof(pcm_parameters));

	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error setting pcm parameters! \n"));
	}
	
	play_time.PlayMode = 0;
	play_time.PlayStartPTS = 0;
	play_time.PlayEndPTS = 0;
	EM8XXXSNDSP(pE, audio_decoder, RMAudioDecoderPropertyID_AudioPlayTime, &play_time, sizeof(play_time));