em8xxx_voip_new.c

Sigma SMP8634 Mrua v. 2.8.2.0

		}
		else {
			RMDBGLOG((ENABLE,"Memory manager not existent\n"));
			return err;
		}
	}
	ucode.MicrocodeVersion = size_in.MicrocodeVersion;
	EM8XXXVOIPSP(pE,EMHWLIB_MODULE(AudioEngine,1),RMAudioEnginePropertyID_Microcode,&ucode,sizeof(ucode));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE,"Error while loading audio microcode!\n"));
		return err;
	}

 	run = CPU_RUNNING;

	EM8XXXVOIPSP(pE, EMHWLIB_MODULE(AudioEngine,1), RMAudioEnginePropertyID_State, &run, sizeof(run));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE,"Error while starting Audio RISC\n"));
		return err;
	}
#endif // WITH_XLOADED_UCODE


	spdif_out = AudioEngine_SpdifOut_Disabled;
	EM8XXXVOIPSP(pE,EMHWLIB_MODULE(AudioEngine,1),RMAudioEnginePropertyID_SpdifOut, &spdif_out, sizeof(spdif_out));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE,"Error while setting spdif_out property \n"));
		return err;
	}
	
	i2s.DataAlignment = 1;
	i2s.SClkInvert = TRUE;
	i2s.FrameInvert = TRUE;
	i2s.MSBFirst = TRUE;
	i2s.SampleSize16Bit = FALSE;
	EM8XXXVOIPSP(pE,EMHWLIB_MODULE(AudioEngine,1),RMAudioEnginePropertyID_I2SConfig, &i2s,sizeof(i2s));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE,"Error setting i2s property !\n"));
		return err;
	}
	
	serialOutStatus = AudioEngine_SerialOut_SO_ENABLE;
	EM8XXXVOIPSP(pE,EMHWLIB_MODULE(AudioEngine,1),RMAudioEnginePropertyID_SerialOut, &serialOutStatus, sizeof(serialOutStatus));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE,"Error while setting serialOut property!\n"));
		return err;
	}

	dram_in.BTSInFIFOSize = BTS_IN_FIFO_SIZE;
	dram_in.BTSOutFIFOSize = BTS_OUT_FIFO_SIZE;
	dram_in.DTMFCharFIFOSize = DTMF_FIFO_SIZE;
	EM8XXXVOIPEXP(pE,VoipCodec,RMVoipCodecPropertyID_DRAMSize,&dram_in,sizeof(dram_in),&dram_out,sizeof(dram_out));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE,"Can't get DRAM size to allocate for VoipCodec Profile\n"));
		return err;
	}

	profile.BTSInFIFOSize = dram_in.BTSInFIFOSize;
	profile.BTSOutFIFOSize = dram_in.BTSOutFIFOSize;
	profile.DTMFCharFIFOSize = dram_in.DTMFCharFIFOSize;
	profile.CachedSize = dram_out.CachedSize;
	if (profile.CachedSize > 0) {
		in.dramtype=RUA_DRAM_CACHED;
		in.Size = profile.CachedSize;
		EM8XXXVOIPEXP(pE,EMHWLIB_MODULE(MM,0),RMMMPropertyID_Malloc,&in,sizeof(in),&out,sizeof(out));
		if (err == RM_OK) {
			profile.CachedAddress = (RMuint32) out.Address;
			RMDBGLOG((LOCALDBG,"Voip cached address : 0x%08lx, size 0x%08lx, end 0x%08lx\n",profile.CachedAddress,profile.CachedSize,profile.CachedAddress + profile.CachedSize));
		}
		else {
			RMDBGLOG((ENABLE,"memory manager not existent\n"));
			return err;
		}
	}
	else {
		profile.CachedAddress = 0;
	}
	pV->VoipProfileCachedAddr = profile.CachedAddress;

	profile.UncachedSize = dram_out.UncachedSize;
	if (profile.UncachedSize > 0) {
		in.dramtype=RUA_DRAM_UNCACHED;
		in.Size = profile.UncachedSize;

		EM8XXXVOIPEXP(pE,EMHWLIB_MODULE(MM,0),RMMMPropertyID_Malloc,&in,sizeof(in),&out,sizeof(out));
		if (err == RM_OK) {
			profile.UncachedAddress = (RMuint32) out.Address;
			RMDBGLOG((LOCALDBG,"Voip uncached address : 0x%08lx, size 0x%08lx, end 0x%08lx\n",profile.UncachedAddress,profile.UncachedSize,profile.UncachedAddress+profile.UncachedSize));
		}
		else {
			RMDBGLOG((ENABLE,"memory manager not existent \n"));
			return err;
		}
	}
	else {
		profile.UncachedAddress = 0;
	}
	pV->VoipProfileUncachedAddr = profile.UncachedAddress;
	EM8XXXVOIPSP(pE,VoipCodec,RMVoipCodecPropertyID_Open,&profile,sizeof(profile));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE,"Error while creating voip profile!\n"));
		return err;
	}
	
	volume = 0x100;
	EM8XXXVOIPSP(pE,VoipCodec,RMVoipCodecPropertyID_Recording_volume,&volume,sizeof(volume));
	volume = 0x20;
	EM8XXXVOIPSP(pE,VoipCodec,RMVoipCodecPropertyID_Playback_volume,&volume,sizeof(volume));

	command = VoipCodec_Command_Capture_Start;
	EM8XXXVOIPSP(pE,VoipCodec,RMVoipCodecPropertyID_Command,&command,sizeof(command));
	rc = kc_interruptible_sleep_on_timeout(pV->command_q,US_TO_JIFFIES(VOIP_EVENT_TIMEOUT_US));
	if (rc == 0) {
		RMDBGLOG((LOCALDBG,"Timeout while waiting for Capture Start Command Completion\n"));
		return RM_PENDING;
	}
	else if (kc_signal_pending_current()) {
		RMDBGLOG((LOCALDBG,"Interrupted while waiting for Capture Start Command Completion\n"));
		return RM_PENDING;
	}
	else {
		RMDBGLOG((LOCALDBG,"Capture Start Command acknoledged rc = %d\n",rc));
	}

	command = VoipCodec_Command_Playback_Start;
	EM8XXXVOIPSP(pE,VoipCodec,RMVoipCodecPropertyID_Command,&command,sizeof(command));
	rc = kc_interruptible_sleep_on_timeout(pV->command_q,US_TO_JIFFIES(VOIP_EVENT_TIMEOUT_US));
	if (rc == 0) {
		RMDBGLOG((LOCALDBG,"Timeout while waiting for Playback Start Command Completion\n"));
		return RM_PENDING;
	}
	else if (kc_signal_pending_current()) {
		RMDBGLOG((LOCALDBG,"Interrupted while waiting for Playback Start Command Completion\n"));
		return RM_PENDING;
	}
	else {
		RMDBGLOG((LOCALDBG,"Playback Start Command acknoledged rc = %d\n",rc));
	}

	return RM_OK;
}

static RMstatus cleanup_voip(struct voipprivate *pV)
{
	RMuint32 profile = 0;
	struct em8xxxprivate *pE = Etable +(pV-VOIPtable);
	enum VoipCodec_Command_type command;
	RMstatus err;
	int rc;

	command = VoipCodec_Command_Capture_Stop;
	EM8XXXVOIPSP(pE,VoipCodec,RMVoipCodecPropertyID_Command,&command,sizeof(command));
	rc = kc_interruptible_sleep_on_timeout(pV->command_q,US_TO_JIFFIES(VOIP_EVENT_TIMEOUT_US));
	if (rc == 0) {
		RMDBGLOG((LOCALDBG,"Timeout while waiting for Capture Stop Command Completion\n"));
		return RM_PENDING;
	}
	else if (kc_signal_pending_current()) {
		RMDBGLOG((LOCALDBG,"Interrupted while waiting for Capture Stop Command Completion\n"));
		return RM_PENDING;
	}
	else {
		RMDBGLOG((LOCALDBG,"Capture stop Command acknoledged rc = %d\n",rc));
	}

	command = VoipCodec_Command_Playback_Stop;
	EM8XXXVOIPSP(pE,VoipCodec,RMVoipCodecPropertyID_Command,&command,sizeof(command));
	rc = kc_interruptible_sleep_on_timeout(pV->command_q,US_TO_JIFFIES(VOIP_EVENT_TIMEOUT_US));
	if (rc == 0) {
		RMDBGLOG((LOCALDBG,"Timeout while waiting for Playback Stop Command Completion\n"));
		return RM_PENDING;
	}
	else if (kc_signal_pending_current()) {
		RMDBGLOG((LOCALDBG,"Interrupted while waiting for Playback Stop Command Completion\n"));
		return RM_PENDING;
	}
	else {
		RMDBGLOG((LOCALDBG,"Playback Stop Command acknoledged rc = %d\n",rc));
	}

	EM8XXXVOIPSP(pE,VoipCodec,RMVoipCodecPropertyID_Close,&profile,sizeof(profile));

	if (pV->VoipUCodeAddr)
		rm_free_ptr(pE,pV->VoipUCodeAddr);
	if (pV->VoipProfileCachedAddr)
		rm_free_ptr(pE,pV->VoipProfileCachedAddr);
	if (pV->VoipProfileUncachedAddr)
		rm_free_ptr(pE,pV->VoipProfileUncachedAddr);
	
	return RM_OK;
}

static int em8xxx_voip_open(struct phone_device *p, struct file *file_p)
{
	struct voipprivate *pV = VOIPtable + p->board;
	struct em8xxxprivate *pE = Etable + (pV-VOIPtable);
	enum VoipCodec_Command_type command;
	RMstatus err;
	int rc;

	file_p->private_data = pV;
	
	pV->voip_open_count++;

	if(pV->voip_open_count==1)
		em8xxx_voip_add_timer(pV);

	command = VoipCodec_Command_DTMF_Init;
	EM8XXXVOIPSP(pE,VoipCodec,RMVoipCodecPropertyID_Command,&command,sizeof(command));
	rc = kc_interruptible_sleep_on_timeout(pV->command_q,US_TO_JIFFIES(VOIP_EVENT_TIMEOUT_US));
	if (rc == 0) {
		RMDBGLOG((LOCALDBG,"Timeout while waiting for DTMF Init Command Completion\n"));
		return RM_PENDING;
	}
	else if (kc_signal_pending_current()) {
		RMDBGLOG((LOCALDBG,"Interrupted while waiting for DTMF Init Command Completion\n"));
		return RM_PENDING;
	}
	else {
		RMDBGLOG((LOCALDBG,"DTMF Init Command acknoledged rc = %d\n",rc));
	}

	command = VoipCodec_Command_DTMF_Start;
	EM8XXXVOIPSP(pE,VoipCodec,RMVoipCodecPropertyID_Command,&command,sizeof(command));
	rc = kc_interruptible_sleep_on_timeout(pV->command_q,US_TO_JIFFIES(VOIP_EVENT_TIMEOUT_US));
	if (rc == 0) {
		RMDBGLOG((LOCALDBG,"Timeout while waiting for DTMF Start Command Completion\n"));
		return RM_PENDING;
	}
	else if (kc_signal_pending_current()) {
		RMDBGLOG((LOCALDBG,"Interrupted while waiting for DTMF Start Command Completion\n"));
		return RM_PENDING;
	}
	else {
		RMDBGLOG((LOCALDBG,"DTMF Start Command acknoledged rc = %d\n",rc));
	}

	command = VoipCodec_Command_Aec_Init;
	EM8XXXVOIPSP(pE,VoipCodec,RMVoipCodecPropertyID_Command,&command,sizeof(command));
	rc = kc_interruptible_sleep_on_timeout(pV->command_q,US_TO_JIFFIES(VOIP_EVENT_TIMEOUT_US));
	if (rc == 0) {
		RMDBGLOG((LOCALDBG,"Timeout while waiting for AEC Init Command Completion\n"));
		return RM_PENDING;
	}
	else if (kc_signal_pending_current()) {
		RMDBGLOG((LOCALDBG,"Interrupted while waiting for AEC Init Command Completion\n"));
		return RM_PENDING;
	}
	else {
		RMDBGLOG((LOCALDBG,"AEC Init Command acknoledged rc = %d\n",rc));
	}

	RMDBGLOG((LOCALDBG,"Em8xxx VOIP Opening board %d\n", p->board));
	
	return 0;
}

static ssize_t em8xxx_voip_read(struct file *file_p, char *buf,size_t length,loff_t *ppos)
{
	struct voipprivate *pV=(struct voipprivate *) file_p->private_data;
	struct em8xxxprivate *pE= Etable + (pV-VOIPtable);
	struct VoipCodec_ReadChunk_in_type in;
	struct VoipCodec_ReadChunk_out_type out;
	RMstatus err = RM_PENDING;
	int rc;
	RMuint32 count = 0;

	if (!pV->voip_open_count) {
		return -EINVAL;
	}
	
	while (length > 0) {
		if (length >= sizeof(out.Chunk.data)) {
			in.Size = sizeof(out.Chunk.data);
			length -= sizeof(out.Chunk.data);
		}
		else {
			in.Size = length;
			length = 0;
		}

		while (err == RM_PENDING) {
			EM8XXXVOIPEXP(pE,VoipCodec,RMVoipCodecPropertyID_ReadChunk,&in,sizeof(in),&out,sizeof(out));	
			if (err == RM_PENDING) {
				rc = kc_interruptible_sleep_on_timeout(pV->read_q,US_TO_JIFFIES(VOIP_EVENT_TIMEOUT_US));
				if (rc == 0) {
					RMDBGLOG((LOCALDBG,"Timeout in read chunk\n"));
					return -EAGAIN;
				}
				else if (kc_signal_pending_current()) {
					RMDBGLOG((LOCALDBG,"Interrupted while waiting for reading chunk\n"));
					return -EINTR;
				}
			}
		}

		kc_logging_copy_to_user(buf+count,out.Chunk.data,out.Chunk.size);
		count += out.Chunk.size;
	}

	return count;
}

static ssize_t em8xxx_voip_write(struct file * file_p,const char *buf, size_t count,loff_t * ppos)
{
	struct voipprivate *pV = (struct voipprivate *)file_p->private_data;
	struct em8xxxprivate *pE = Etable + (pV-VOIPtable);
	struct VoipCodec_WriteChunk_in_type in;
	struct VoipCodec_WriteChunk_out_type out;
	RMuint32 written=0;
	RMstatus err = RM_PENDING;
	int rc;

	if (!pV->voip_open_count) {
		return -EINVAL;
	}

	while (count > 0) {
		if (count >= sizeof(in.Chunk.data)) {
			in.Chunk.size = sizeof(in.Chunk.data);
			count -= sizeof(in.Chunk.data);
		}
		else {
			in.Chunk.size = count;
			count = 0;
		}
	
		kc_logging_copy_from_user(in.Chunk.data,buf+written,in.Chunk.size);

		while (err == RM_PENDING) {
			EM8XXXVOIPEXP(pE,VoipCodec,RMVoipCodecPropertyID_WriteChunk,&in,sizeof(in),&out,sizeof(out));
			if (err == RM_PENDING) {
				rc = kc_interruptible_sleep_on_timeout(pV->write_q,US_TO_JIFFIES(VOIP_EVENT_TIMEOUT_US));
				if (rc == 0) {
					RMDBGLOG((LOCALDBG,"Timeout in write chunk\n"));
					return -EAGAIN;
				}
				else if (kc_signal_pending_current()) {
					RMDBGLOG((LOCALDBG,"Interrupted while waiting for writing chunk\n"));
					return -EINTR;
				}
			}
		}
		

		written += out.WrittenSize;
	}

	return written;
}

static unsigned int em8xxx_voip_poll(struct file *file_p, poll_table * wait)
{
	unsigned int mask = 0;
	struct voipprivate *pV = VOIPtable + MINOR(file_p->f_dentry->d_inode->i_rdev);
	struct em8xxxprivate *pE = Etable + (pV-VOIPtable);
	struct DataFIFOInfo fifo_info;
	RMstatus err;

	kc_poll_wait(file_p,pV->poll_q, wait);

	if (pV->exc.bytes) {
		mask |= POLLPRI;
	}

	EM8XXXVOIPGP(pE,EMHWLIB_TARGET_MODULE(VoipCodec,0,1),RMGenericPropertyID_DataFIFOInfo,&fifo_info,sizeof(fifo_info));
	if (fifo_info.Writable > 0) {
		mask |= POLLOUT | POLLWRNORM;
	}

	EM8XXXVOIPGP(pE,EMHWLIB_TARGET_MODULE(VoipCodec,0,0),RMGenericPropertyID_DataFIFOInfo,&fifo_info,sizeof(fifo_info));
	if (fifo_info.Readable > 0) {
		mask |= POLLIN | POLLRDNORM;
	}

	return mask;
}

static int em8xxx_voip_ioctl(struct inode *inode, struct file *file_p, unsigned int cmd, unsigned long arg)
{
	struct voipprivate *pV = file_p->private_data;
	struct em8xxxprivate *pE = Etable + (pV - VOIPtable);
	int retval = 0;
	RMstatus err;
	RMint8 dtmf_ascii;
	enum VoipCodec_Encoder_Codec_type enc_codec;
	enum VoipCodec_Decoder_Codec_type dec_codec;
	enum VoipCodec_Command_type command;
	struct VoipCodec_Tone tg;
	struct VoipCodec_Cid cid;
//	PHONE_CID pcid;
	int rc;

	switch(cmd) {
	case PHONE_DTMF_READY:
		RMDBGLOG((LOCALDBG,"PHONE_DTMF_READY \n"));
		retval = pV->exc.bits.dtmf_ready;
		break;
	case PHONE_RING_CADENCE:
		RMDBGLOG((LOCALDBG,"PHONE_RING_CADENCE \n"));
		break;
	case OLD_PHONE_RING_START:
		RMDBGLOG((LOCALDBG,"OLD_PHONE_RING_START \n"));
		break;
	case PHONE_RING_START:
		RMDBGLOG((LOCALDBG,"PHONE_RING_START \n"));
//		kc_logging_copy_from_user(&pcid,(PHONE_CID *) arg,sizeof(PHONE_CID));
	//	snprintf(cid.month,sizeof(cid.month),pcid.month);
	//	snprintf(cid.day,sizeof(cid.day),pcid.day);
	//	snprintf(cid.hour,sizeof(cid.hour),pcid.hour);
	//	snprintf(cid.min,sizeof(cid.min),pcid.min);
	//	cid.numlen = pcid.numlen;
	//	snprintf(cid.number,sizeof(cid.number),pcid.number);
	//	cid.namelen = pcid.namelen;
	//	snprintf(cid.name,sizeof(cid.name),pcid.name);
		snprintf(cid.month,sizeof(cid.month),"11");
		snprintf(cid.day,sizeof(cid.day),"17");