visus
/
teensy-audio
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
861 Commits
2 Branches
Tree: 832bef49b7
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '832bef49b7'
${ noResults }
teensy-audio/async_input_spdif3.cpp

476 lines
17KB
Raw Blame History 

  1. /* Audio Library for Teensy 3.X

  2.  * Copyright (c) 2019, Paul Stoffregen, paul@pjrc.com

  3.  *

  4.  * Development of this audio library was funded by PJRC.COM, LLC by sales of

  5.  * Teensy and Audio Adaptor boards.  Please support PJRC's efforts to develop

  6.  * open source software by purchasing Teensy or other PJRC products.

  7.  *

  8.  * Permission is hereby granted, free of charge, to any person obtaining a copy

  9.  * of this software and associated documentation files (the "Software"), to deal

  10.  * in the Software without restriction, including without limitation the rights

  11.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  12.  * copies of the Software, and to permit persons to whom the Software is

  13.  * furnished to do so, subject to the following conditions:

  14.  *

  15.  * The above copyright notice, development funding notice, and this permission

  16.  * notice shall be included in all copies or substantial portions of the Software.

  17.  *

  18.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  19.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  20.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  21.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  22.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  23.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  24.  * THE SOFTWARE.

  25.  */

  26. /*

  27.  by Alexander Walch

  28.  */

  29. #if defined(__IMXRT1052__) || defined(__IMXRT1062__)

  30. 

  31. #include "async_input_spdif3.h"

  32. #include "biquad.h"

  33. #include <utility/imxrt_hw.h>

  34. //Parameters

  35. namespace {

  36. 	#define SPDIF_RX_BUFFER_LENGTH AUDIO_BLOCK_SAMPLES

  37. 	const int32_t bufferLength=8*AUDIO_BLOCK_SAMPLES;

  38. 	const uint16_t noSamplerPerIsr=SPDIF_RX_BUFFER_LENGTH/4;

  39. 	const float toFloatAudio= 1.f/pow(2., 23.);

  40. }

  41. volatile bool AsyncAudioInputSPDIF3::resetResampler=true;

  42. 

  43. #ifdef DEBUG_SPDIF_IN

  44. volatile bool AsyncAudioInputSPDIF3::bufferOverflow=false;

  45. #endif

  46. 

  47. volatile uint32_t AsyncAudioInputSPDIF3::microsLast;

  48. 

  49. DMAMEM __attribute__((aligned(32)))

  50. static int32_t spdif_rx_buffer[SPDIF_RX_BUFFER_LENGTH];

  51. static float bufferR[bufferLength];

  52. static float bufferL[bufferLength];

  53. 

  54. volatile int32_t AsyncAudioInputSPDIF3::buffer_offset = 0;	// read by resample/ written in spdif input isr -> copied at the beginning of 'resmaple' protected by __disable_irq() in resample

  55. int32_t AsyncAudioInputSPDIF3::resample_offset = 0; // read/written by resample/ read in spdif input isr -> no protection needed?

  56. 

  57. volatile bool AsyncAudioInputSPDIF3::lockChanged=false;

  58. volatile bool AsyncAudioInputSPDIF3::locked=false;

  59. DMAChannel AsyncAudioInputSPDIF3::dma(false);

  60. 

  61. AsyncAudioInputSPDIF3::~AsyncAudioInputSPDIF3(){

  62. 	delete [] _bufferLPFilter.pCoeffs;

  63. 	delete [] _bufferLPFilter.pState;

  64. 	delete quantizer[0];

  65. 	delete quantizer[1];

  66. }

  67. 

  68. PROGMEM

  69. AsyncAudioInputSPDIF3::AsyncAudioInputSPDIF3(bool dither, bool noiseshaping,float attenuation, int32_t minHalfFilterLength) : AudioStream(0, NULL) {

  70. 	_attenuation=attenuation;

  71. 	_minHalfFilterLength=minHalfFilterLength;

  72. 	const float factor = powf(2, 15)-1.f; // to 16 bit audio

  73. 	quantizer[0]=new Quantizer(AUDIO_SAMPLE_RATE_EXACT);

  74. 	quantizer[0]->configure(noiseshaping, dither, factor);

  75. 	quantizer[1]=new Quantizer(AUDIO_SAMPLE_RATE_EXACT);

  76. 	quantizer[1]->configure(noiseshaping, dither, factor);

  77. 	begin();

  78. 	}

  79. PROGMEM

  80. void AsyncAudioInputSPDIF3::begin()

  81. {

  82. 	dma.begin(true); // Allocate the DMA channel first

  83. 	const uint32_t noByteMinorLoop=2*4;

  84. 	dma.TCD->SOFF = 4;

  85. 	dma.TCD->ATTR = DMA_TCD_ATTR_SSIZE(2) | DMA_TCD_ATTR_DSIZE(2);

  86. 	dma.TCD->NBYTES_MLNO = DMA_TCD_NBYTES_MLOFFYES_NBYTES(noByteMinorLoop) | DMA_TCD_NBYTES_SMLOE | 

  87. 						DMA_TCD_NBYTES_MLOFFYES_MLOFF(-8);

  88. 	dma.TCD->SLAST = -8;

  89. 	dma.TCD->DOFF = 4;

  90. 	dma.TCD->CITER_ELINKNO = sizeof(spdif_rx_buffer) / noByteMinorLoop;

  91. 	dma.TCD->DLASTSGA = -sizeof(spdif_rx_buffer);

  92. 	dma.TCD->BITER_ELINKNO = sizeof(spdif_rx_buffer) / noByteMinorLoop;

  93. 	dma.TCD->CSR = DMA_TCD_CSR_INTHALF | DMA_TCD_CSR_INTMAJOR;	

  94. 	dma.TCD->SADDR = (void *)((uint32_t)&SPDIF_SRL);

  95. 	dma.TCD->DADDR = spdif_rx_buffer;

  96. 	dma.triggerAtHardwareEvent(DMAMUX_SOURCE_SPDIF_RX);

  97. 

  98. 	SPDIF_SCR |=SPDIF_SCR_DMA_RX_EN;		//DMA Receive Request Enable

  99. 	dma.enable();

  100. 	dma.attachInterrupt(isr);

  101. 	config_spdifIn();

  102. #ifdef DEBUG_SPDIF_IN

  103. 	while (!Serial);

  104. #endif

  105. 	_bufferLPFilter.pCoeffs=new float[5];

  106. 	_bufferLPFilter.numStages=1;

  107. 	_bufferLPFilter.pState=new float[2];

  108. 	getCoefficients(_bufferLPFilter.pCoeffs, BiquadType::LOW_PASS, 0., 5., AUDIO_SAMPLE_RATE_EXACT/AUDIO_BLOCK_SAMPLES, 0.5);

  109. }

  110. bool AsyncAudioInputSPDIF3::isLocked() const {

  111. 	__disable_irq();

  112. 	bool l=locked;

  113. 	__enable_irq();

  114. 	return l;

  115. }

  116. void AsyncAudioInputSPDIF3::spdif_interrupt(){

  117. 	if(SPDIF_SIS & SPDIF_SIS_LOCK){

  118. 		if (!locked){

  119. 			locked=true;

  120. 			lockChanged=true;

  121. 		}

  122. 	}

  123. 	else if(SPDIF_SIS & SPDIF_SIS_LOCKLOSS){

  124. 		if (locked){

  125. 			locked=false;

  126. 			lockChanged=true;

  127. 			resetResampler=true;

  128. 		}

  129. 	}

  130. 	SPDIF_SIC |= SPDIF_SIC_LOCKLOSS;//clear SPDIF_SIC_LOCKLOSS interrupt

  131. 	SPDIF_SIC |= SPDIF_SIC_LOCK;	//clear SPDIF_SIC_LOCK interrupt

  132. }

  133. 

  134. void AsyncAudioInputSPDIF3::resample(int16_t* data_left, int16_t* data_right, int32_t& block_offset){

  135. 	block_offset=0;

  136. 	if(!_resampler.initialized()){

  137. 		return;

  138. 	}

  139. 	__disable_irq();

  140. 	if(!locked){

  141. 		__enable_irq();

  142. 		return;

  143. 	}

  144. 	int32_t bOffset=buffer_offset;

  145. 	int32_t resOffset=resample_offset;

  146. 	__enable_irq();

  147. 		

  148. 	uint16_t inputBufferStop = bOffset >= resOffset ? bOffset-resOffset : bufferLength-resOffset;

  149. 	if (inputBufferStop==0){

  150. 		return;

  151. 	}

  152. 	uint16_t processedLength;

  153. 	uint16_t outputCount=0;

  154. 	uint16_t outputLength=AUDIO_BLOCK_SAMPLES;

  155. 

  156. 	float resampledBufferL[AUDIO_BLOCK_SAMPLES];

  157. 	float resampledBufferR[AUDIO_BLOCK_SAMPLES];

  158. 	_resampler.resample(&bufferL[resOffset],&bufferR[resOffset], inputBufferStop, processedLength, resampledBufferL, resampledBufferR, outputLength, outputCount);

  159. 		

  160. 	resOffset=(resOffset+processedLength)%bufferLength;

  161. 	block_offset=outputCount;	

  162. 

  163. 	if (bOffset > resOffset && block_offset< AUDIO_BLOCK_SAMPLES){

  164. 		inputBufferStop= bOffset-resOffset;

  165. 		outputLength=AUDIO_BLOCK_SAMPLES-block_offset;

  166. 		_resampler.resample(&bufferL[resOffset],&bufferR[resOffset], inputBufferStop, processedLength, resampledBufferL+block_offset, resampledBufferR+block_offset, outputLength, outputCount);

  167. 		resOffset=(resOffset+processedLength)%bufferLength;

  168. 		block_offset+=outputCount;

  169. 	}

  170. 	quantizer[0]->quantize(resampledBufferL, data_left, block_offset);

  171. 	quantizer[1]->quantize(resampledBufferR, data_right, block_offset);

  172. 	__disable_irq();

  173. 	resample_offset=resOffset;

  174. 	__enable_irq();		

  175. }

  176. 

  177. void AsyncAudioInputSPDIF3::isr(void)

  178. {

  179. 	dma.clearInterrupt();

  180. 	microsLast=micros();

  181. 	const int32_t *src, *end;

  182. 	uint32_t daddr = (uint32_t)(dma.TCD->DADDR);

  183. 

  184. 	if (daddr < (uint32_t)spdif_rx_buffer + sizeof(spdif_rx_buffer) / 2) {

  185. 		// DMA is receiving to the first half of the buffer

  186. 		// need to remove data from the second half

  187. 		src = (int32_t *)&spdif_rx_buffer[SPDIF_RX_BUFFER_LENGTH/2];

  188. 		end = (int32_t *)&spdif_rx_buffer[SPDIF_RX_BUFFER_LENGTH];

  189. 		//if (AsyncAudioInputSPDIF3::update_responsibility) AudioStream::update_all();

  190. 	} else {

  191. 		// DMA is receiving to the second half of the buffer

  192. 		// need to remove data from the first half

  193. 		src = (int32_t *)&spdif_rx_buffer[0];

  194. 		end = (int32_t *)&spdif_rx_buffer[SPDIF_RX_BUFFER_LENGTH/2];

  195. 	}

  196. 	if (buffer_offset >=resample_offset ||

  197. 		(buffer_offset + SPDIF_RX_BUFFER_LENGTH/4) < resample_offset) {

  198. 		#if IMXRT_CACHE_ENABLED >=1

  199. 		arm_dcache_delete((void*)src, sizeof(spdif_rx_buffer) / 2);

  200. 		#endif

  201. 		float *destR = &(bufferR[buffer_offset]);

  202. 		float *destL = &(bufferL[buffer_offset]);

  203. 		do {			

  204. 			int32_t n=(*src) & 0x800000 ? (*src)|0xFF800000  : (*src) & 0xFFFFFF;

  205. 			*destL++ = (float)(n)*toFloatAudio;

  206. 			++src;

  207. 

  208. 			n=(*src) & 0x800000 ? (*src)|0xFF800000  : (*src) & 0xFFFFFF;

  209. 			*destR++ = (float)(n)*toFloatAudio;

  210. 			++src;

  211. 		} while (src < end);

  212. 		buffer_offset=(buffer_offset+SPDIF_RX_BUFFER_LENGTH/4)%bufferLength;

  213. 	}

  214. #ifdef DEBUG_SPDIF_IN

  215. 	else {

  216. 		bufferOverflow=true;

  217. 	}

  218. #endif

  219. }

  220. double AsyncAudioInputSPDIF3::getNewValidInputFrequ(){

  221. 	//page 2129: FrequMeas[23:0]=FreqMeas_CLK / BUS_CLK * 2^10 * GAIN

  222. 	if (SPDIF_SRPC & SPDIF_SRPC_LOCK){

  223. 		const double f=(float)F_BUS_ACTUAL/(1024.*1024.*24.*128.);// bit clock = 128 * sampling frequency

  224. 		const double freqMeas=(SPDIF_SRFM & 0xFFFFFF)*f;

  225. 		if (_lastValidInputFrequ != freqMeas){//frequency not stable yet;

  226. 			_lastValidInputFrequ=freqMeas;

  227. 			return -1.;	

  228. 		}

  229. 		return _lastValidInputFrequ;

  230. 	}

  231. 	return -1.;

  232. }

  233. 

  234. double AsyncAudioInputSPDIF3::getBufferedTime() const{

  235. 	__disable_irq();

  236. 	double n=_bufferedTime;

  237. 	__enable_irq();

  238. 	return n;

  239. }

  240. 

  241. void AsyncAudioInputSPDIF3::configure(){

  242. 	__disable_irq();

  243. 	if(resetResampler){

  244. 		_resampler.reset();

  245. 		resetResampler=false;

  246. 	}

  247. 	if(!locked){

  248. 		__enable_irq();

  249. #ifdef DEBUG_SPDIF_IN

  250. 		Serial.println("lock lost");

  251. #endif

  252. 		return;

  253. 	}	

  254. #ifdef DEBUG_SPDIF_IN

  255. 	const bool bOverf=bufferOverflow;

  256. 	bufferOverflow=false;

  257. #endif

  258. 	const bool lc=lockChanged;

  259. 	__enable_irq();

  260. 

  261. #ifdef DEBUG_SPDIF_IN

  262. 	if (bOverf){

  263. 		Serial.print("buffer overflow, buffer offset: ");

  264. 		Serial.print(buffer_offset);

  265. 		Serial.print(", resample_offset: ");

  266. 		Serial.println(resample_offset);

  267. 		if (!_resampler.initialized()){

  268. 			Serial.println("_resampler not initialized. ");

  269. 		}

  270. 	}

  271. #endif

  272. 	if (lc || !_resampler.initialized()){

  273. 		const double inputF=getNewValidInputFrequ();	//returns: -1 ... invalid frequency

  274. 		if (inputF > 0.){

  275. 			__disable_irq();

  276. 			lockChanged=false;	//only reset lockChanged if a valid frequency was received (inputFrequ > 0.)

  277. 			__enable_irq();

  278. 			//we got a valid sample frequency

  279. 			const double frequDiff=inputF/_inputFrequency-1.;

  280. 			if (abs(frequDiff) > 0.01 || !_resampler.initialized()){

  281. 				//the new sample frequency differs from the last one -> configure the _resampler again

  282. 				_inputFrequency=inputF;		

  283. 				_targetLatencyS=max(0.001,(noSamplerPerIsr*3./2./_inputFrequency));

  284. 				_maxLatency=max(2.*_blockDuration, 2*noSamplerPerIsr/_inputFrequency);

  285. 				const int32_t targetLatency=round(_targetLatencyS*inputF);

  286. 				__disable_irq();

  287. 				resample_offset =  targetLatency <= buffer_offset ? buffer_offset - targetLatency : bufferLength -(targetLatency-buffer_offset);

  288. 				__enable_irq();

  289. 				_resampler.configure(inputF, AUDIO_SAMPLE_RATE_EXACT, _attenuation, _minHalfFilterLength);

  290. 		#ifdef DEBUG_SPDIF_IN

  291. 				Serial.print("_maxLatency: ");

  292. 				Serial.println(_maxLatency);

  293. 				Serial.print("targetLatency: ");

  294. 				Serial.println(targetLatency);

  295. 				Serial.print("relative frequ diff: ");

  296. 				Serial.println(frequDiff, 8);

  297. 				Serial.print("configure _resampler with frequency ");

  298. 				Serial.println(inputF,8);			

  299. 		#endif			

  300. 			}

  301. 		}

  302. 	}

  303. }

  304. 

  305. void AsyncAudioInputSPDIF3::monitorResampleBuffer(){

  306. 	if(!_resampler.initialized()){

  307. 		return;

  308. 	}

  309. 	__disable_irq();

  310. 	const double dmaOffset=(micros()-microsLast)*1e-6;	//[seconds]

  311. 	double bTime = resample_offset <= buffer_offset ? (buffer_offset-resample_offset-_resampler.getXPos())/_lastValidInputFrequ+dmaOffset : (bufferLength-resample_offset +buffer_offset-_resampler.getXPos())/_lastValidInputFrequ+dmaOffset;	//[seconds]

  312. 	

  313. 	double diff = bTime- (_blockDuration+ _targetLatencyS);	//seconds

  314. 

  315. 	biquad_cascade_df2T<double, arm_biquad_cascade_df2T_instance_f32, float>(&_bufferLPFilter, &diff, &diff, 1);

  316. 	

  317. 	bool settled=_resampler.addToSampleDiff(diff);

  318. 	

  319. 	if (bTime > _maxLatency || bTime-dmaOffset<= _blockDuration || settled) {	

  320. 		double distance=(_blockDuration+_targetLatencyS-dmaOffset)*_lastValidInputFrequ+_resampler.getXPos();

  321. 		diff=0.;

  322. 		if (distance > bufferLength-noSamplerPerIsr){

  323. 			diff=bufferLength-noSamplerPerIsr-distance;

  324. 			distance=bufferLength-noSamplerPerIsr;

  325. 		}

  326. 		if (distance < 0.){

  327. 			distance=0.;

  328. 			diff=- (_blockDuration+ _targetLatencyS);

  329. 		}

  330. 		double resample_offsetF=buffer_offset-distance;

  331. 		resample_offset=(int32_t)floor(resample_offsetF);

  332. 		_resampler.addToPos(resample_offsetF-resample_offset);

  333. 		while (resample_offset<0){

  334. 			resample_offset+=bufferLength;

  335. 		}	

  336. 		//int32_t b_offset=buffer_offset;

  337. #ifdef DEBUG_SPDIF_IN

  338. 		double bTimeFixed = resample_offset <= buffer_offset ? (buffer_offset-resample_offset-_resampler.getXPos())/_lastValidInputFrequ+dmaOffset : (bufferLength-resample_offset +buffer_offset-_resampler.getXPos())/_lastValidInputFrequ+dmaOffset;	//[seconds]

  339. #endif

  340. 		__enable_irq();

  341. #ifdef DEBUG_SPDIF_IN

  342. 		// Serial.print("settled: ");

  343. 		// Serial.println(settled);

  344. 		Serial.print("bTime: ");

  345. 		Serial.print(bTime*1e6,3);

  346. 		Serial.print("_maxLatency: ");

  347. 		Serial.println(_maxLatency*1e6,3);

  348. 		Serial.print("bTime-dmaOffset: ");

  349. 		Serial.print((bTime-dmaOffset)*1e6,3);

  350. 		Serial.print(", _blockDuration: ");

  351. 		Serial.print(_blockDuration*1e6,3);

  352. 		Serial.print("bTimeFixed: ");

  353. 		Serial.print(bTimeFixed*1e6,3);

  354. 

  355. #endif

  356. 		preload(&_bufferLPFilter, diff);

  357. 		_resampler.fixStep();		

  358. 	}

  359. 	else {		

  360. 		__enable_irq();

  361. 	}

  362. 	_bufferedTime=_targetLatencyS+diff;

  363. }

  364. 

  365. void AsyncAudioInputSPDIF3::update(void)

  366. {

  367. 	configure();

  368. 	monitorResampleBuffer();	//important first call 'monitorResampleBuffer' then 'resample'

  369. 	audio_block_t *block_left =allocate();

  370. 	audio_block_t *block_right =nullptr;

  371. 	if (block_left!= nullptr) {

  372. 		block_right = allocate();

  373. 		if (block_right == nullptr) {

  374. 			release(block_left);

  375. 			block_left = nullptr;

  376. 		}

  377. 	}

  378. 	if (block_left && block_right) {

  379. 		int32_t block_offset;

  380. 		resample(block_left->data, block_right->data,block_offset);

  381. 		if(block_offset < AUDIO_BLOCK_SAMPLES){

  382. 			memset(block_left->data+block_offset, 0, (AUDIO_BLOCK_SAMPLES-block_offset)*sizeof(int16_t)); 

  383. 			memset(block_right->data+block_offset, 0, (AUDIO_BLOCK_SAMPLES-block_offset)*sizeof(int16_t)); 

  384. #ifdef DEBUG_SPDIF_IN	

  385. 			Serial.print("filled only ");

  386. 			Serial.print(block_offset);

  387. 			Serial.println(" samples.");

  388. #endif

  389. 		}

  390. 		transmit(block_left, 0);

  391. 		release(block_left);

  392. 		block_left=nullptr;

  393. 		transmit(block_right, 1);

  394. 		release(block_right);

  395. 		block_right=nullptr;	

  396. 	}

  397. #ifdef DEBUG_SPDIF_IN

  398. 	else {		

  399. 		Serial.println("Not enough blocks available. Too few audio memory?");

  400. 	}

  401. #endif

  402. }

  403. double AsyncAudioInputSPDIF3::getInputFrequency() const{

  404. 	__disable_irq();

  405. 	double f=_lastValidInputFrequ;

  406. 	bool l=locked;

  407. 	__enable_irq();

  408. 	return l ? f : 0.;

  409. }

  410. double AsyncAudioInputSPDIF3::getTargetLantency() const {

  411. 	__disable_irq();

  412. 	double l=_targetLatencyS;

  413. 	__enable_irq();

  414. 	return l ;

  415. }

  416. double AsyncAudioInputSPDIF3::getAttenuation() const{

  417. 	return _resampler.getAttenuation();

  418. }

  419. int32_t AsyncAudioInputSPDIF3::getHalfFilterLength() const{

  420. 	return _resampler.getHalfFilterLength();

  421. }

  422. void AsyncAudioInputSPDIF3::config_spdifIn(){

  423. 	//CCM Clock Gating Register 5, imxrt1060_rev1.pdf page 1145

  424. 	CCM_CCGR5 |=CCM_CCGR5_SPDIF(CCM_CCGR_ON); //turn spdif clock on - necessary for receiver!

  425. 	

  426. 	SPDIF_SCR |=SPDIF_SCR_RXFIFO_OFF_ON;	//turn receive fifo off 1->off, 0->on

  427. 

  428. 	SPDIF_SCR&=~(SPDIF_SCR_RXFIFO_CTR);		//reset rx fifo control: normal opertation

  429. 

  430. 	SPDIF_SCR&=~(SPDIF_SCR_RXFIFOFULL_SEL(3));	//reset rx full select

  431. 	SPDIF_SCR|=SPDIF_SCR_RXFIFOFULL_SEL(2);	//full interrupt if at least 8 sample in Rx left and right FIFOs

  432. 

  433. 	SPDIF_SCR|=SPDIF_SCR_RXAUTOSYNC; //Rx FIFO auto sync on

  434. 

  435. 	SPDIF_SCR&=(~SPDIF_SCR_USRC_SEL(3));	//No embedded U channel

  436. 

  437.     CORE_PIN15_CONFIG  = 3;  //pin 15 set to alt3 -> spdif input

  438. 

  439. 	/// from eval board sample code

  440. 	//   IOMUXC_SetPinConfig(

  441. 	//       IOMUXC_GPIO_AD_B1_03_SPDIF_IN,        /* GPIO_AD_B1_03 PAD functional properties : */

  442. 	//       0x10B0u);                               /* Slew Rate Field: Slow Slew Rate

  443. 	//                                                  Drive Strength Field: R0/6

  444. 	//                                                  Speed Field: medium(100MHz)

  445. 	//                                                  Open Drain Enable Field: Open Drain Disabled

  446. 	//                                                  Pull / Keep Enable Field: Pull/Keeper Enabled

  447. 	//                                                  Pull / Keep Select Field: Keeper

  448. 	//                                                  Pull Up / Down Config. Field: 100K Ohm Pull Down

  449. 	//                                                  Hyst. Enable Field: Hysteresis Disabled */

  450. 	CORE_PIN15_PADCONFIG=0x10B0;

  451. 	SPDIF_SCR &=(~SPDIF_SCR_RXFIFO_OFF_ON);	//receive fifo is turned on again

  452. 

  453. 

  454. 	SPDIF_SRPC &= ~SPDIF_SRPC_CLKSRC_SEL(15);	//reset clock selection page 2136

  455. 	//SPDIF_SRPC |=SPDIF_SRPC_CLKSRC_SEL(6);		//if (DPLL Locked) SPDIF_RxClk else tx_clk (SPDIF0_CLK_ROOT)

  456. 	//page 2129: FrequMeas[23:0]=FreqMeas_CLK / BUS_CLK * 2^10 * GAIN

  457. 	SPDIF_SRPC &=~SPDIF_SRPC_GAINSEL(7);	//reset gain select 0 -> gain = 24*2^10

  458. 	//SPDIF_SRPC |= SPDIF_SRPC_GAINSEL(3);	//gain select: 8*2^10

  459. 	//==============================================

  460. 

  461. 	//interrupts

  462. 	SPDIF_SIE |= SPDIF_SIE_LOCK;	//enable spdif receiver lock interrupt

  463. 	SPDIF_SIE |=SPDIF_SIE_LOCKLOSS;

  464. 

  465. 	lockChanged=true;

  466. 	attachInterruptVector(IRQ_SPDIF, spdif_interrupt);

  467. 	NVIC_SET_PRIORITY(IRQ_SPDIF, 208); // 255 = lowest priority, 208 = priority of update

  468. 	NVIC_ENABLE_IRQ(IRQ_SPDIF);

  469. 

  470. 	SPDIF_SIC |= SPDIF_SIC_LOCK;	//clear SPDIF_SIC_LOCK interrupt

  471. 	SPDIF_SIC |= SPDIF_SIC_LOCKLOSS;//clear SPDIF_SIC_LOCKLOSS interrupt

  472. 	locked=(SPDIF_SRPC & SPDIF_SRPC_LOCK);

  473. }

  474. #endif