visus
/
framework-arduinoteensy-cxx20
Volgen 1
Ster 0
Vork 0
Code Kwesties 0 Pull-aanvragen 0 Publicaties 0 Wiki Activiteit
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
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.
5 Commits
1 Branch
Branch: main
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van 'main'
${ noResults }
framework-arduinoteensy-cxx20/libraries/Audio/output_pt8211.cpp

563 lines
18KB
Ruw Permalink Blame Geschiedenis 

  1. /* Audio Library for Teensy 3.X

  2.  * Copyright (c) 2016, 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. //Adapted to PT8211, Frank Bösing, Ben-Rheinland

  28. 

  29. 

  30. #include <Arduino.h>

  31. #include "output_pt8211.h"

  32. #include "memcpy_audio.h"

  33. #include "utility/imxrt_hw.h"

  34. 

  35. audio_block_t * AudioOutputPT8211::block_left_1st = NULL;

  36. audio_block_t * AudioOutputPT8211::block_right_1st = NULL;

  37. audio_block_t * AudioOutputPT8211::block_left_2nd = NULL;

  38. audio_block_t * AudioOutputPT8211::block_right_2nd = NULL;

  39. uint16_t  AudioOutputPT8211::block_left_offset = 0;

  40. uint16_t  AudioOutputPT8211::block_right_offset = 0;

  41. bool AudioOutputPT8211::update_responsibility = false;

  42. #if defined(AUDIO_PT8211_OVERSAMPLING)

  43. DMAMEM __attribute__((aligned(32))) static uint32_t i2s_tx_buffer[AUDIO_BLOCK_SAMPLES*4];

  44. #else

  45. DMAMEM __attribute__((aligned(32))) static uint32_t i2s_tx_buffer[AUDIO_BLOCK_SAMPLES];

  46. #endif

  47. DMAChannel AudioOutputPT8211::dma(false);

  48. 

  49. void AudioOutputPT8211::begin(void)

  50. {

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

  52. 

  53. 	block_left_1st = NULL;

  54. 	block_right_1st = NULL;

  55. 

  56. 	// TODO: should we set & clear the I2S_TCSR_SR bit here?

  57. 	config_i2s();

  58. #if defined(KINETISK)

  59. 	CORE_PIN22_CONFIG = PORT_PCR_MUX(6); // pin 22, PTC1, I2S0_TXD0

  60. 

  61. 	dma.TCD->SADDR = i2s_tx_buffer;

  62. 	dma.TCD->SOFF = 2;

  63. 	dma.TCD->ATTR = DMA_TCD_ATTR_SSIZE(1) | DMA_TCD_ATTR_DSIZE(1);

  64. 	dma.TCD->NBYTES_MLNO = 2;

  65. 	dma.TCD->SLAST = -sizeof(i2s_tx_buffer);

  66. 	dma.TCD->DADDR = &I2S0_TDR0;

  67. 	dma.TCD->DOFF = 0;

  68. 	dma.TCD->CITER_ELINKNO = sizeof(i2s_tx_buffer) / 2;

  69. 	dma.TCD->DLASTSGA = 0;

  70. 	dma.TCD->BITER_ELINKNO = sizeof(i2s_tx_buffer) / 2;

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

  72. 

  73. 	dma.triggerAtHardwareEvent(DMAMUX_SOURCE_I2S0_TX);

  74. 	update_responsibility = update_setup();

  75. 	dma.attachInterrupt(isr);

  76. 	dma.enable();

  77. 	I2S0_TCSR |= I2S_TCSR_TE | I2S_TCSR_BCE | I2S_TCSR_FRDE | I2S_TCSR_FR;

  78. 	return;

  79. #elif defined(__IMXRT1052__) || defined(__IMXRT1062__)

  80. 

  81. #if defined(__IMXRT1052__)

  82. 	CORE_PIN6_CONFIG  = 3;  //1:TX_DATA0

  83. #elif defined(__IMXRT1062__)

  84. 	CORE_PIN7_CONFIG  = 3;  //1:TX_DATA0	

  85. #endif

  86. 

  87. 	dma.TCD->SADDR = i2s_tx_buffer;

  88. 	dma.TCD->SOFF = 2;

  89. 	dma.TCD->ATTR = DMA_TCD_ATTR_SSIZE(1) | DMA_TCD_ATTR_DSIZE(1);

  90. 	dma.TCD->NBYTES_MLNO = 2;

  91. 	dma.TCD->SLAST = -sizeof(i2s_tx_buffer);

  92. 	dma.TCD->DOFF = 0;

  93. 	dma.TCD->CITER_ELINKNO = sizeof(i2s_tx_buffer) / 2;

  94. 	dma.TCD->DLASTSGA = 0;

  95. 	dma.TCD->BITER_ELINKNO = sizeof(i2s_tx_buffer) / 2;

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

  97. 	dma.TCD->DADDR = (void *)((uint32_t)&I2S1_TDR0);

  98. 	dma.triggerAtHardwareEvent(DMAMUX_SOURCE_SAI1_TX);

  99. 

  100. 	I2S1_RCSR |= I2S_RCSR_RE;

  101. 	I2S1_TCSR |= I2S_TCSR_TE | I2S_TCSR_BCE | I2S_TCSR_FRDE;

  102. 

  103. 	update_responsibility = update_setup();

  104. 	dma.attachInterrupt(isr);

  105. 	dma.enable();

  106. 	return;

  107. #endif	

  108. }

  109. 

  110. void AudioOutputPT8211::isr(void)

  111. {

  112. 	int16_t *dest, *dest_copy;

  113. 	audio_block_t *blockL, *blockR;

  114. 	uint32_t saddr, offsetL, offsetR;

  115. 

  116. #if defined(KINETISK) || defined(__IMXRT1062__)

  117. 	saddr = (uint32_t)(dma.TCD->SADDR);

  118. #endif

  119. 	dma.clearInterrupt();

  120. 	if (saddr < (uint32_t)i2s_tx_buffer + sizeof(i2s_tx_buffer) / 2) {

  121. 		// DMA is transmitting the first half of the buffer

  122. 		// so we must fill the second half

  123. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

  124. 			dest = (int16_t *)&i2s_tx_buffer[(AUDIO_BLOCK_SAMPLES/2)*4];

  125. 		#else

  126. 			dest = (int16_t *)&i2s_tx_buffer[AUDIO_BLOCK_SAMPLES/2];

  127. 		#endif

  128. 		if (AudioOutputPT8211::update_responsibility) AudioStream::update_all();

  129. 	} else {

  130. 		// DMA is transmitting the second half of the buffer

  131. 		// so we must fill the first half

  132. 		dest = (int16_t *)i2s_tx_buffer;

  133. 	}

  134. 	dest_copy = dest;

  135. 

  136. 	blockL = AudioOutputPT8211::block_left_1st;

  137. 	blockR = AudioOutputPT8211::block_right_1st;

  138. 	offsetL = AudioOutputPT8211::block_left_offset;

  139. 	offsetR = AudioOutputPT8211::block_right_offset;

  140. 

  141. 	#if defined(AUDIO_PT8211_OVERSAMPLING)

  142. 		static int32_t oldL = 0;

  143. 		static int32_t oldR = 0;

  144. 	#endif

  145. 	if (blockL && blockR) {

  146. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

  147. 			#if defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  148. 				for (int i=0; i< AUDIO_BLOCK_SAMPLES / 2; i++, offsetL++, offsetR++) {

  149. 					int32_t valL = blockL->data[offsetL];

  150. 					int32_t valR = blockR->data[offsetR];

  151. 					int32_t nL = (oldL+valL) >> 1;

  152. 					int32_t nR = (oldR+valR) >> 1;

  153. 					*(dest+0) = (oldL+nL) >> 1;

  154. 					*(dest+1) = (oldR+nR) >> 1;

  155. 					*(dest+2) = nL;

  156. 					*(dest+3) = nR;

  157. 					*(dest+4) = (nL+valL) >> 1;

  158. 					*(dest+5) = (nR+valR) >> 1;

  159. 					*(dest+6) = valL;

  160. 					*(dest+7) = valR;

  161. 					dest+=8;

  162. 					oldL = valL;

  163. 					oldR = valR;

  164. 				}

  165. 			#elif defined(AUDIO_PT8211_INTERPOLATION_CIC)

  166. 				for (int i=0; i< AUDIO_BLOCK_SAMPLES / 2; i++, offsetL++, offsetR++) {

  167. 					int32_t valL = blockL->data[offsetL];

  168. 					int32_t valR = blockR->data[offsetR];

  169. 

  170. 					int32_t combL[3] = {0};

  171. 					static int32_t combLOld[2] = {0};

  172. 					int32_t combR[3] = {0};

  173. 					static int32_t combROld[2] = {0};

  174. 

  175. 					combL[0] = valL - oldL;

  176. 					combR[0] = valR - oldR;

  177. 					combL[1] = combL[0] - combLOld[0];

  178. 					combR[1] = combR[0] - combROld[0];

  179. 					combL[2] = combL[1] - combLOld[1];

  180. 					combR[2] = combR[1] - combROld[1];

  181. 					// combL[2] now holds input val

  182. 					// combR[2] now holds input val

  183. 					oldL = valL;

  184. 					oldR = valR;

  185. 					combLOld[0] = combL[0];

  186. 					combROld[0] = combR[0];

  187. 					combLOld[1] = combL[1];

  188. 					combROld[1] = combR[1];

  189. 					for (int j = 0; j < 4; j++) {

  190. 						int32_t integrateL[3];

  191. 						int32_t integrateR[3];

  192. 						static int32_t integrateLOld[3] = {0};

  193. 						static int32_t integrateROld[3] = {0};

  194. 						integrateL[0] = ( (j==0) ? (combL[2]) : (0) ) + integrateLOld[0];

  195. 						integrateR[0] = ( (j==0) ? (combR[2]) : (0) ) + integrateROld[0];

  196. 						integrateL[1] = integrateL[0] + integrateLOld[1];

  197. 						integrateR[1] = integrateR[0] + integrateROld[1];

  198. 						integrateL[2] = integrateL[1] + integrateLOld[2];

  199. 						integrateR[2] = integrateR[1] + integrateROld[2];

  200. 						// integrateL[2] now holds j'th upsampled value

  201. 						// integrateR[2] now holds j'th upsampled value

  202. 						*(dest+j*2) = integrateL[2] >> 4;

  203. 						*(dest+j*2+1) = integrateR[2] >> 4;

  204. 						integrateLOld[0] = integrateL[0];

  205. 						integrateROld[0] = integrateR[0];

  206. 						integrateLOld[1] = integrateL[1];

  207. 						integrateROld[1] = integrateR[1];

  208. 						integrateLOld[2] = integrateL[2];

  209. 						integrateROld[2] = integrateR[2];

  210. 					}

  211. 					dest+=8;

  212. 				}

  213. 			#else

  214. 				#error no interpolation method defined for oversampling.

  215. 			#endif //defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  216. 		#else

  217. 			memcpy_tointerleaveLR(dest, blockL->data + offsetL, blockR->data + offsetR);

  218. 			offsetL += AUDIO_BLOCK_SAMPLES / 2;

  219. 			offsetR += AUDIO_BLOCK_SAMPLES / 2;

  220. 		#endif //defined(AUDIO_PT8211_OVERSAMPLING)

  221. 

  222. 	} else if (blockL) {

  223. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

  224. 			#if defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  225. 				for (int i=0; i< AUDIO_BLOCK_SAMPLES / 2; i++, offsetL++) {

  226. 					int32_t val = blockL->data[offsetL];

  227. 					int32_t n = (oldL+val) >> 1;

  228. 					*(dest+0) = (oldL+n) >> 1;

  229. 					*(dest+1) = 0;

  230. 					*(dest+2) = n;

  231. 					*(dest+3) = 0;

  232. 					*(dest+4) = (n+val) >> 1;

  233. 					*(dest+5) = 0;

  234. 					*(dest+6) = val;

  235. 					*(dest+7) = 0;

  236. 					dest+=8;

  237. 					oldL = val;

  238. 				}

  239. 			#elif defined(AUDIO_PT8211_INTERPOLATION_CIC)

  240. 				for (int i=0; i< AUDIO_BLOCK_SAMPLES / 2; i++, offsetL++, offsetR++) {

  241. 					int32_t valL = blockL->data[offsetL];

  242. 

  243. 					int32_t combL[3] = {0};

  244. 					static int32_t combLOld[2] = {0};

  245. 

  246. 					combL[0] = valL - oldL;

  247. 					combL[1] = combL[0] - combLOld[0];

  248. 					combL[2] = combL[1] - combLOld[1];

  249. 					// combL[2] now holds input val

  250. 					combLOld[0] = combL[0];

  251. 					combLOld[1] = combL[1];

  252. 

  253. 					for (int j = 0; j < 4; j++) {

  254. 						int32_t integrateL[3];

  255. 						static int32_t integrateLOld[3] = {0};

  256. 						integrateL[0] = ( (j==0) ? (combL[2]) : (0) ) + integrateLOld[0];

  257. 						integrateL[1] = integrateL[0] + integrateLOld[1];

  258. 						integrateL[2] = integrateL[1] + integrateLOld[2];

  259. 						// integrateL[2] now holds j'th upsampled value

  260. 						*(dest+j*2) = integrateL[2] >> 4;

  261. 						integrateLOld[0] = integrateL[0];

  262. 						integrateLOld[1] = integrateL[1];

  263. 						integrateLOld[2] = integrateL[2];

  264. 					}

  265. 

  266. 					// fill right channel with zeros:

  267. 					*(dest+1) = 0;

  268. 					*(dest+3) = 0;

  269. 					*(dest+5) = 0;

  270. 					*(dest+7) = 0;

  271. 					dest+=8;

  272. 					oldL = valL;

  273. 				}

  274. 			#else

  275. 				#error no interpolation method defined for oversampling.

  276. 			#endif //defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  277. 		#else

  278. 			memcpy_tointerleaveL(dest, blockL->data + offsetL);

  279. 			offsetL += (AUDIO_BLOCK_SAMPLES / 2);

  280. 		#endif //defined(AUDIO_PT8211_OVERSAMPLING)

  281. 	} else if (blockR) {

  282. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

  283. 			#if defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  284. 				for (int i=0; i< AUDIO_BLOCK_SAMPLES / 2; i++, offsetR++) {

  285. 					int32_t val = blockR->data[offsetR];

  286. 					int32_t n = (oldR+val) >> 1;

  287. 					*(dest+0) = 0;

  288. 					*(dest+1) = ((oldR+n) >> 1);

  289. 					*(dest+2) = 0;

  290. 					*(dest+3) = n;

  291. 					*(dest+4) = 0;

  292. 					*(dest+5) = ((n+val) >> 1);

  293. 					*(dest+6) = 0;

  294. 					*(dest+7) = val;

  295. 					dest+=8;

  296. 					oldR = val;

  297. 				}

  298. 			#elif defined(AUDIO_PT8211_INTERPOLATION_CIC)

  299. 				for (int i=0; i< AUDIO_BLOCK_SAMPLES / 2; i++, offsetL++, offsetR++) {

  300. 					int32_t valR = blockR->data[offsetR];

  301. 

  302. 					int32_t combR[3] = {0};

  303. 					static int32_t combROld[2] = {0};

  304. 

  305. 					combR[0] = valR - oldR;

  306. 					combR[1] = combR[0] - combROld[0];

  307. 					combR[2] = combR[1] - combROld[1];

  308. 					// combR[2] now holds input val

  309. 					combROld[0] = combR[0];

  310. 					combROld[1] = combR[1];

  311. 

  312. 					for (int j = 0; j < 4; j++) {

  313. 						int32_t integrateR[3];

  314. 						static int32_t integrateROld[3] = {0};

  315. 						integrateR[0] = ( (j==0) ? (combR[2]) : (0) ) + integrateROld[0];

  316. 						integrateR[1] = integrateR[0] + integrateROld[1];

  317. 						integrateR[2] = integrateR[1] + integrateROld[2];

  318. 						// integrateR[2] now holds j'th upsampled value

  319. 						*(dest+j*2+1) = integrateR[2] >> 4;

  320. 						integrateROld[0] = integrateR[0];

  321. 						integrateROld[1] = integrateR[1];

  322. 						integrateROld[2] = integrateR[2];

  323. 					}

  324. 

  325. 					// fill left channel with zeros:

  326. 					*(dest+0) = 0;

  327. 					*(dest+2) = 0;

  328. 					*(dest+4) = 0;

  329. 					*(dest+6) = 0;

  330. 					dest+=8;

  331. 					oldR = valR;

  332. 				}

  333. 			#else

  334. 				#error no interpolation method defined for oversampling.

  335. 			#endif //defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  336. 		#else

  337. 			memcpy_tointerleaveR(dest, blockR->data + offsetR);

  338. 			offsetR += AUDIO_BLOCK_SAMPLES / 2;

  339. 		#endif //defined(AUDIO_PT8211_OVERSAMPLING)

  340. 	} else {

  341. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

  342. 			memset(dest,0,AUDIO_BLOCK_SAMPLES*8);

  343. 		#else

  344. 			memset(dest,0,AUDIO_BLOCK_SAMPLES*2);

  345. 		#endif

  346. 		return;

  347. 	}

  348. 

  349. 	arm_dcache_flush_delete(dest_copy, sizeof(i2s_tx_buffer) / 2);

  350. 

  351. 	if (offsetL < AUDIO_BLOCK_SAMPLES) {

  352. 		AudioOutputPT8211::block_left_offset = offsetL;

  353. 	} else {

  354. 		AudioOutputPT8211::block_left_offset = 0;

  355. 		AudioStream::release(blockL);

  356. 		AudioOutputPT8211::block_left_1st = AudioOutputPT8211::block_left_2nd;

  357. 		AudioOutputPT8211::block_left_2nd = NULL;

  358. 	}

  359. 	if (offsetR < AUDIO_BLOCK_SAMPLES) {

  360. 		AudioOutputPT8211::block_right_offset = offsetR;

  361. 	} else {

  362. 		AudioOutputPT8211::block_right_offset = 0;

  363. 		AudioStream::release(blockR);

  364. 		AudioOutputPT8211::block_right_1st = AudioOutputPT8211::block_right_2nd;

  365. 		AudioOutputPT8211::block_right_2nd = NULL;

  366. 	}

  367. }

  368. 

  369. 

  370. 

  371. void AudioOutputPT8211::update(void)

  372. {

  373. 

  374. 	audio_block_t *block;

  375. 	block = receiveReadOnly(0); // input 0 = left channel

  376. 	if (block) {

  377. 		__disable_irq();

  378. 		if (block_left_1st == NULL) {

  379. 			block_left_1st = block;

  380. 			block_left_offset = 0;

  381. 			__enable_irq();

  382. 		} else if (block_left_2nd == NULL) {

  383. 			block_left_2nd = block;

  384. 			__enable_irq();

  385. 		} else {

  386. 			audio_block_t *tmp = block_left_1st;

  387. 			block_left_1st = block_left_2nd;

  388. 			block_left_2nd = block;

  389. 			block_left_offset = 0;

  390. 			__enable_irq();

  391. 			release(tmp);

  392. 		}

  393. 	}

  394. 	block = receiveReadOnly(1); // input 1 = right channel

  395. 	if (block) {

  396. 		__disable_irq();

  397. 		if (block_right_1st == NULL) {

  398. 			block_right_1st = block;

  399. 			block_right_offset = 0;

  400. 			__enable_irq();

  401. 		} else if (block_right_2nd == NULL) {

  402. 			block_right_2nd = block;

  403. 			__enable_irq();

  404. 		} else {

  405. 			audio_block_t *tmp = block_right_1st;

  406. 			block_right_1st = block_right_2nd;

  407. 			block_right_2nd = block;

  408. 			block_right_offset = 0;

  409. 			__enable_irq();

  410. 			release(tmp);

  411. 		}

  412. 	}

  413. }

  414. 

  415. #if defined(KINETISK)

  416. // MCLK needs to be 48e6 / 1088 * 256 = 11.29411765 MHz -> 44.117647 kHz sample rate

  417. //

  418. #if F_CPU == 96000000 || F_CPU == 48000000 || F_CPU == 24000000

  419.   // PLL is at 96 MHz in these modes

  420.   #define MCLK_MULT 2

  421.   #define MCLK_DIV  17

  422. #elif F_CPU == 72000000

  423.   #define MCLK_MULT 8

  424.   #define MCLK_DIV  51

  425. #elif F_CPU == 120000000

  426.   #define MCLK_MULT 8

  427.   #define MCLK_DIV  85

  428. #elif F_CPU == 144000000

  429.   #define MCLK_MULT 4

  430.   #define MCLK_DIV  51

  431. #elif F_CPU == 168000000

  432.   #define MCLK_MULT 8

  433.   #define MCLK_DIV  119

  434. #elif F_CPU == 180000000

  435.   #define MCLK_MULT 16

  436.   #define MCLK_DIV  255

  437.   #define MCLK_SRC  0

  438. #elif F_CPU == 192000000

  439.   #define MCLK_MULT 1

  440.   #define MCLK_DIV  17

  441. #elif F_CPU == 216000000

  442.   #define MCLK_MULT 12

  443.   #define MCLK_DIV  17

  444.   #define MCLK_SRC  1

  445. #elif F_CPU == 240000000

  446.   #define MCLK_MULT 2

  447.   #define MCLK_DIV  85

  448.   #define MCLK_SRC  0

  449. #elif F_CPU == 256000000

  450.   #define MCLK_MULT 12

  451.   #define MCLK_DIV  17

  452.   #define MCLK_SRC  1

  453. #elif F_CPU == 16000000

  454.   #define MCLK_MULT 12

  455.   #define MCLK_DIV  17

  456. #else

  457.   #error "This CPU Clock Speed is not supported by the Audio library";

  458. #endif

  459. 

  460. #ifndef MCLK_SRC

  461. #if F_CPU >= 20000000

  462.   #define MCLK_SRC  3  // the PLL

  463. #else

  464.   #define MCLK_SRC  0  // system clock

  465. #endif

  466. #endif

  467. #endif

  468. 

  469. void AudioOutputPT8211::config_i2s(void)

  470. {

  471. #if defined(KINETISK)

  472. 	SIM_SCGC6 |= SIM_SCGC6_I2S;

  473. 	SIM_SCGC7 |= SIM_SCGC7_DMA;

  474. 	SIM_SCGC6 |= SIM_SCGC6_DMAMUX;

  475. 

  476. 	// if transmitter is enabled, do nothing

  477. 	if (I2S0_TCSR & I2S_TCSR_TE) return;

  478. 

  479. 

  480. 	// enable MCLK output

  481. 	I2S0_MCR = I2S_MCR_MICS(MCLK_SRC) | I2S_MCR_MOE;

  482. 	while (I2S0_MCR & I2S_MCR_DUF) ;

  483. 	I2S0_MDR = I2S_MDR_FRACT((MCLK_MULT-1)) | I2S_MDR_DIVIDE((MCLK_DIV-1));

  484. 

  485. 	// configure transmitter

  486. 	I2S0_TMR = 0;

  487. 	I2S0_TCR1 = I2S_TCR1_TFW(1);  // watermark at half fifo size

  488. 	#if defined(AUDIO_PT8211_OVERSAMPLING)

  489. 		I2S0_TCR2 = I2S_TCR2_SYNC(0) | I2S_TCR2_BCP | I2S_TCR2_MSEL(1) | I2S_TCR2_BCD | I2S_TCR2_DIV(0);

  490. 	#else

  491. 		I2S0_TCR2 = I2S_TCR2_SYNC(0) | I2S_TCR2_BCP | I2S_TCR2_MSEL(1) | I2S_TCR2_BCD | I2S_TCR2_DIV(3);

  492. 	#endif

  493. 	I2S0_TCR3 = I2S_TCR3_TCE;

  494. //	I2S0_TCR4 = I2S_TCR4_FRSZ(1) | I2S_TCR4_SYWD(15) | I2S_TCR4_MF | I2S_TCR4_FSE | I2S_TCR4_FSP | I2S_TCR4_FSD; //TDA1543

  495. 	I2S0_TCR4 = I2S_TCR4_FRSZ(1) | I2S_TCR4_SYWD(15) | I2S_TCR4_MF /*| I2S_TCR4_FSE*/ | I2S_TCR4_FSP | I2S_TCR4_FSD; //PT8211

  496. 	I2S0_TCR5 = I2S_TCR5_WNW(15) | I2S_TCR5_W0W(15) | I2S_TCR5_FBT(15);

  497. 

  498. 	// configure pin mux for 3 clock signals

  499. 	CORE_PIN23_CONFIG = PORT_PCR_MUX(6); // pin 23, PTC2, I2S0_TX_FS (LRCLK)

  500. 	CORE_PIN9_CONFIG  = PORT_PCR_MUX(6); // pin  9, PTC3, I2S0_TX_BCLK

  501. 	//CORE_PIN11_CONFIG = PORT_PCR_MUX(6); // pin 11, PTC6, I2S0_MCLK

  502. 	

  503. #elif ( defined(__IMXRT1052__) || defined(__IMXRT1062__) )

  504. 

  505. 	CCM_CCGR5 |= CCM_CCGR5_SAI1(CCM_CCGR_ON);

  506. //PLL:

  507. 	int fs = AUDIO_SAMPLE_RATE_EXACT;

  508. 	// PLL between 27*24 = 648MHz und 54*24=1296MHz

  509. 	int n1 = 4; //SAI prescaler 4 => (n1*n2) = multiple of 4

  510. 	int n2 = 1 + (24000000 * 27) / (fs * 256 * n1);

  511. 

  512. 	double C = ((double)fs * 256 * n1 * n2) / 24000000;

  513. 	int c0 = C;

  514. 	int c2 = 10000;

  515. 	int c1 = C * c2 - (c0 * c2);

  516. 	set_audioClock(c0, c1, c2);

  517. 

  518. 	// clear SAI1_CLK register locations

  519. 	CCM_CSCMR1 = (CCM_CSCMR1 & ~(CCM_CSCMR1_SAI1_CLK_SEL_MASK))

  520. 		   | CCM_CSCMR1_SAI1_CLK_SEL(2); // &0x03 // (0,1,2): PLL3PFD0, PLL5, PLL4

  521. 	CCM_CS1CDR = (CCM_CS1CDR & ~(CCM_CS1CDR_SAI1_CLK_PRED_MASK | CCM_CS1CDR_SAI1_CLK_PODF_MASK))

  522. 		   | CCM_CS1CDR_SAI1_CLK_PRED(n1-1) // &0x07

  523. 		   | CCM_CS1CDR_SAI1_CLK_PODF(n2-1); // &0x3f

  524. 

  525. 	IOMUXC_GPR_GPR1 = (IOMUXC_GPR_GPR1 & ~(IOMUXC_GPR_GPR1_SAI1_MCLK1_SEL_MASK))

  526. 			| (IOMUXC_GPR_GPR1_SAI1_MCLK_DIR | IOMUXC_GPR_GPR1_SAI1_MCLK1_SEL(0));	//Select MCLK

  527. 

  528. 	if (I2S1_TCSR & I2S_TCSR_TE) return;

  529. 

  530. //	CORE_PIN23_CONFIG = 3;  //1:MCLK

  531. 	CORE_PIN21_CONFIG = 3;  //1:RX_BCLK

  532. 	CORE_PIN20_CONFIG = 3;  //1:RX_SYNC

  533. //	CORE_PIN6_CONFIG  = 3;  //1:TX_DATA0

  534. //	CORE_PIN7_CONFIG  = 3;  //1:RX_DATA0

  535. 

  536. 	int rsync = 0;

  537. 	int tsync = 1;

  538. 	#if defined(AUDIO_PT8211_OVERSAMPLING)

  539. 	int div = 0;

  540. 	#else

  541. 	int div = 3;

  542. 	#endif

  543. 	// configure transmitter

  544. 	I2S1_TMR = 0;

  545. 	I2S1_TCR1 = I2S_TCR1_RFW(0);

  546. 	I2S1_TCR2 = I2S_TCR2_SYNC(tsync) | I2S_TCR2_BCP | I2S_TCR2_MSEL(1) | I2S_TCR2_BCD | I2S_TCR2_DIV(div);

  547. 	I2S1_TCR3 = I2S_TCR3_TCE;

  548. //	I2S1_TCR4 = I2S_TCR4_FRSZ(1) | I2S_TCR4_SYWD(15) | I2S_TCR4_MF | I2S_TCR4_FSE | I2S_TCR4_FSP | I2S_TCR4_FSD; //TDA1543

  549. 	I2S1_TCR4 = I2S_TCR4_FRSZ(1) | I2S_TCR4_SYWD(15) | I2S_TCR4_MF /*| I2S_TCR4_FSE*/ | I2S_TCR4_FSP | I2S_TCR4_FSD; //PT8211

  550. 	I2S1_TCR5 = I2S_TCR5_WNW(15) | I2S_TCR5_W0W(15) | I2S_TCR5_FBT(15);

  551. 

  552. 	I2S1_RMR = 0;

  553. 	//I2S1_RCSR = (1<<25); //Reset

  554. 	I2S1_RCR1 = I2S_RCR1_RFW(0);

  555. 	I2S1_RCR2 = I2S_RCR2_SYNC(rsync) | I2S_RCR2_BCP | I2S_RCR2_MSEL(1) | I2S_TCR2_BCD | I2S_TCR2_DIV(div);

  556. 	I2S1_RCR3 = I2S_RCR3_RCE;

  557. //	I2S1_TCR4 = I2S_TCR4_FRSZ(1) | I2S_TCR4_SYWD(15) | I2S_TCR4_MF | I2S_TCR4_FSE | I2S_TCR4_FSP | I2S_TCR4_FSD; //TDA1543	

  558. 	I2S1_RCR4 = I2S_RCR4_FRSZ(1) | I2S_RCR4_SYWD(15) | I2S_RCR4_MF /*| I2S_RCR4_FSE*/ | I2S_RCR4_FSP | I2S_RCR4_FSD; //PT8211

  559. 	I2S1_RCR5 = I2S_RCR5_WNW(15) | I2S_RCR5_W0W(15) | I2S_RCR5_FBT(15);

  560. 

  561. #endif

  562. }