visus
/
teensy-audio
Vērot 1
Pievienot zvaigznīti 0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
647 Revīzijas
2 Atzari
Koks: bf58e235bb
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no 'bf58e235bb'
${ noResults }
teensy-audio/output_pt8211.cpp

461 rinda
15KB
Neapstrādāts Vainot Vēsture 

  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. #include "output_pt8211.h"

  30. #include "memcpy_audio.h"

  31. 

  32. audio_block_t * AudioOutputPT8211::block_left_1st = NULL;

  33. audio_block_t * AudioOutputPT8211::block_right_1st = NULL;

  34. audio_block_t * AudioOutputPT8211::block_left_2nd = NULL;

  35. audio_block_t * AudioOutputPT8211::block_right_2nd = NULL;

  36. uint16_t  AudioOutputPT8211::block_left_offset = 0;

  37. uint16_t  AudioOutputPT8211::block_right_offset = 0;

  38. bool AudioOutputPT8211::update_responsibility = false;

  39. #if defined(AUDIO_PT8211_OVERSAMPLING)

  40. 	DMAMEM static uint32_t i2s_tx_buffer[AUDIO_BLOCK_SAMPLES*4];

  41. #else

  42. 	DMAMEM static uint32_t i2s_tx_buffer[AUDIO_BLOCK_SAMPLES];

  43. #endif

  44. DMAChannel AudioOutputPT8211::dma(false);

  45. 

  46. void AudioOutputPT8211::begin(void)

  47. {

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

  49. 

  50. 	block_left_1st = NULL;

  51. 	block_right_1st = NULL;

  52. 

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

  54. 	config_i2s();

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

  56. 

  57. #if defined(KINETISK)

  58. 	dma.TCD->SADDR = i2s_tx_buffer;

  59. 	dma.TCD->SOFF = 2;

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

  61. 	dma.TCD->NBYTES_MLNO = 2;

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

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

  64. 	dma.TCD->DOFF = 0;

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

  66. 	dma.TCD->DLASTSGA = 0;

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

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

  69. #endif

  70. 	dma.triggerAtHardwareEvent(DMAMUX_SOURCE_I2S0_TX);

  71. 	update_responsibility = update_setup();

  72. 	dma.enable();

  73. 

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

  75. 	dma.attachInterrupt(isr);

  76. }

  77. 

  78. void AudioOutputPT8211::isr(void)

  79. {

  80. 	int16_t *dest;

  81. 	audio_block_t *blockL, *blockR;

  82. 	uint32_t saddr, offsetL, offsetR;

  83. 

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

  85. 	dma.clearInterrupt();

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

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

  88. 		// so we must fill the second half

  89. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

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

  91. 		#else

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

  93. 		#endif

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

  95. 	} else {

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

  97. 		// so we must fill the first half

  98. 		dest = (int16_t *)i2s_tx_buffer;

  99. 	}

  100. 

  101. 	blockL = AudioOutputPT8211::block_left_1st;

  102. 	blockR = AudioOutputPT8211::block_right_1st;

  103. 	offsetL = AudioOutputPT8211::block_left_offset;

  104. 	offsetR = AudioOutputPT8211::block_right_offset;

  105. 	

  106. 	#if defined(AUDIO_PT8211_OVERSAMPLING)

  107. 		static int32_t oldL = 0;

  108. 		static int32_t oldR = 0;

  109. 	#endif

  110. 	if (blockL && blockR) {

  111. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

  112. 			#if defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

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

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

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

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

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

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

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

  120. 					*(dest+2) = nL;

  121. 					*(dest+3) = nR;

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

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

  124. 					*(dest+6) = valL;

  125. 					*(dest+7) = valR;

  126. 					dest+=8;

  127. 					oldL = valL;

  128. 					oldR = valR;

  129. 				}

  130. 			#elif defined(AUDIO_PT8211_INTERPOLATION_CIC)

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

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

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

  134. 					

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

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

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

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

  139. 					

  140. 					combL[0] = valL - oldL;

  141. 					combR[0] = valR - oldR;

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

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

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

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

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

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

  148. 					oldL = valL;

  149. 					oldR = valR;

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

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

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

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

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

  155. 						int32_t integrateL[3];

  156. 						int32_t integrateR[3];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  175. 					}

  176. 					dest+=8;

  177. 				}

  178. 			#else

  179. 				#error no interpolation method defined for oversampling.

  180. 			#endif //defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  181. 		#else

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

  183. 			offsetL += AUDIO_BLOCK_SAMPLES / 2;

  184. 			offsetR += AUDIO_BLOCK_SAMPLES / 2;

  185. 		#endif //defined(AUDIO_PT8211_OVERSAMPLING)

  186. 		

  187. 	} else if (blockL) {

  188. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

  189. 			#if defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

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

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

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

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

  194. 					*(dest+1) = 0;

  195. 					*(dest+2) = n;

  196. 					*(dest+3) = 0;

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

  198. 					*(dest+5) = 0;

  199. 					*(dest+6) = val;

  200. 					*(dest+7) = 0;

  201. 					dest+=8;

  202. 					oldL = val;

  203. 				}

  204. 			#elif defined(AUDIO_PT8211_INTERPOLATION_CIC)

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

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

  207. 

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

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

  210. 					

  211. 					combL[0] = valL - oldL;

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

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

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

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

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

  217. 					

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

  219. 						int32_t integrateL[3];

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

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

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

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

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

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

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

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

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

  229. 					}

  230. 					

  231. 					// fill right channel with zeros:

  232. 					*(dest+1) = 0;

  233. 					*(dest+3) = 0;

  234. 					*(dest+5) = 0;

  235. 					*(dest+7) = 0;

  236. 					dest+=8;

  237. 					oldL = valL;

  238. 				}

  239. 			#else

  240. 				#error no interpolation method defined for oversampling.

  241. 			#endif //defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  242. 		#else 

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

  244. 			offsetL += (AUDIO_BLOCK_SAMPLES / 2);

  245. 		#endif //defined(AUDIO_PT8211_OVERSAMPLING)

  246. 	} else if (blockR) {

  247. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

  248. 			#if defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

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

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

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

  252. 					*(dest+0) = 0;

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

  254. 					*(dest+2) = 0;

  255. 					*(dest+3) = n;

  256. 					*(dest+4) = 0;

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

  258. 					*(dest+6) = 0;

  259. 					*(dest+7) = val;

  260. 					dest+=8;

  261. 					oldR = val;

  262. 				}

  263. 			#elif defined(AUDIO_PT8211_INTERPOLATION_CIC)

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

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

  266. 

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

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

  269. 					

  270. 					combR[0] = valR - oldR;

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

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

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

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

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

  276. 					

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

  278. 						int32_t integrateR[3];

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

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

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

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

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

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

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

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

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

  288. 					}

  289. 					

  290. 					// fill left channel with zeros:

  291. 					*(dest+0) = 0;

  292. 					*(dest+2) = 0;

  293. 					*(dest+4) = 0;

  294. 					*(dest+6) = 0;

  295. 					dest+=8;

  296. 					oldR = valR;

  297. 				}

  298. 			#else

  299. 				#error no interpolation method defined for oversampling.

  300. 			#endif //defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  301. 		#else

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

  303. 			offsetR += AUDIO_BLOCK_SAMPLES / 2;

  304. 		#endif //defined(AUDIO_PT8211_OVERSAMPLING)

  305. 	} else {

  306. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

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

  308. 		#else

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

  310. 		#endif

  311. 		return;

  312. 	}

  313. 

  314. 	if (offsetL < AUDIO_BLOCK_SAMPLES) {

  315. 		AudioOutputPT8211::block_left_offset = offsetL;

  316. 	} else {

  317. 		AudioOutputPT8211::block_left_offset = 0;

  318. 		AudioStream::release(blockL);

  319. 		AudioOutputPT8211::block_left_1st = AudioOutputPT8211::block_left_2nd;

  320. 		AudioOutputPT8211::block_left_2nd = NULL;

  321. 	}

  322. 	if (offsetR < AUDIO_BLOCK_SAMPLES) {

  323. 		AudioOutputPT8211::block_right_offset = offsetR;

  324. 	} else {

  325. 		AudioOutputPT8211::block_right_offset = 0;

  326. 		AudioStream::release(blockR);

  327. 		AudioOutputPT8211::block_right_1st = AudioOutputPT8211::block_right_2nd;

  328. 		AudioOutputPT8211::block_right_2nd = NULL;

  329. 	}

  330. }

  331. 

  332. 

  333. 

  334. void AudioOutputPT8211::update(void)

  335. {

  336. 

  337. 	audio_block_t *block;

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

  339. 	if (block) {

  340. 		__disable_irq();

  341. 		if (block_left_1st == NULL) {

  342. 			block_left_1st = block;

  343. 			block_left_offset = 0;

  344. 			__enable_irq();

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

  346. 			block_left_2nd = block;

  347. 			__enable_irq();

  348. 		} else {

  349. 			audio_block_t *tmp = block_left_1st;

  350. 			block_left_1st = block_left_2nd;

  351. 			block_left_2nd = block;

  352. 			block_left_offset = 0;

  353. 			__enable_irq();

  354. 			release(tmp);

  355. 		}

  356. 	}

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

  358. 	if (block) {

  359. 		__disable_irq();

  360. 		if (block_right_1st == NULL) {

  361. 			block_right_1st = block;

  362. 			block_right_offset = 0;

  363. 			__enable_irq();

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

  365. 			block_right_2nd = block;

  366. 			__enable_irq();

  367. 		} else {

  368. 			audio_block_t *tmp = block_right_1st;

  369. 			block_right_1st = block_right_2nd;

  370. 			block_right_2nd = block;

  371. 			block_right_offset = 0;

  372. 			__enable_irq();

  373. 			release(tmp);

  374. 		}

  375. 	}

  376. }

  377. 

  378. 

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

  380. //

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

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

  383.   #define MCLK_MULT 2

  384.   #define MCLK_DIV  17

  385. #elif F_CPU == 72000000

  386.   #define MCLK_MULT 8

  387.   #define MCLK_DIV  51

  388. #elif F_CPU == 120000000

  389.   #define MCLK_MULT 8

  390.   #define MCLK_DIV  85

  391. #elif F_CPU == 144000000

  392.   #define MCLK_MULT 4

  393.   #define MCLK_DIV  51

  394. #elif F_CPU == 168000000

  395.   #define MCLK_MULT 8

  396.   #define MCLK_DIV  119

  397. #elif F_CPU == 180000000

  398.   #define MCLK_MULT 16

  399.   #define MCLK_DIV  255

  400.   #define MCLK_SRC  0

  401. #elif F_CPU == 192000000

  402.   #define MCLK_MULT 1

  403.   #define MCLK_DIV  17

  404. #elif F_CPU == 216000000

  405.   #define MCLK_MULT 8

  406.   #define MCLK_DIV  153

  407.   #define MCLK_SRC  0

  408. #elif F_CPU == 240000000

  409.   #define MCLK_MULT 4

  410.   #define MCLK_DIV  85

  411. #elif F_CPU == 16000000

  412.   #define MCLK_MULT 12

  413.   #define MCLK_DIV  17

  414. #else

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

  416. #endif

  417. 

  418. #ifndef MCLK_SRC

  419. #if F_CPU >= 20000000

  420.   #define MCLK_SRC  3  // the PLL

  421. #else

  422.   #define MCLK_SRC  0  // system clock

  423. #endif

  424. #endif

  425. 

  426. void AudioOutputPT8211::config_i2s(void)

  427. {

  428. 	SIM_SCGC6 |= SIM_SCGC6_I2S;

  429. 	SIM_SCGC7 |= SIM_SCGC7_DMA;

  430. 	SIM_SCGC6 |= SIM_SCGC6_DMAMUX;

  431. 

  432. 	// if transmitter is enabled, do nothing

  433. 	if (I2S0_TCSR & I2S_TCSR_TE) return;

  434. 

  435. 

  436. 	// enable MCLK output

  437. 	I2S0_MCR = I2S_MCR_MICS(MCLK_SRC) | I2S_MCR_MOE;

  438. 	while (I2S0_MCR & I2S_MCR_DUF) ;

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

  440. 

  441. 	// configure transmitter

  442. 	I2S0_TMR = 0;

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

  444. 	#if defined(AUDIO_PT8211_OVERSAMPLING)

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

  446. 	#else

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

  448. 	#endif

  449. 	I2S0_TCR3 = I2S_TCR3_TCE;

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

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

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

  453. 

  454. 	// configure pin mux for 3 clock signals

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

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

  457. #if 0

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

  459. #endif

  460. }