visus
/
teensy-audio
Bevaka 1
Stjärnmärk 0
Förgrening 0
Kod Ärenden 0 Pull-förfrågningar 0 Släpp 0 Wiki Aktiviteter
Du kan inte välja fler än 25 ämnen Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.
852 Incheckningar
2 Grenar
Träd: 166554098c
Grenar Taggar
${ item.name }
Skapa branchen ${ searchTerm }
från '166554098c'
${ noResults }
teensy-audio/output_i2s_hex.cpp

356 lines
9.6KB
Rå Blame Historik 

  1. /* Audio Library for Teensy 3.X

  2.  * Copyright (c) 2014, 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. #include <Arduino.h>

  28. #include "output_i2s_hex.h"

  29. #include "output_i2s.h"

  30. #include "memcpy_audio.h"

  31. 

  32. #if defined(__IMXRT1062__)

  33. #include "utility/imxrt_hw.h"

  34. 

  35. audio_block_t * AudioOutputI2SHex::block_ch1_1st = NULL;

  36. audio_block_t * AudioOutputI2SHex::block_ch2_1st = NULL;

  37. audio_block_t * AudioOutputI2SHex::block_ch3_1st = NULL;

  38. audio_block_t * AudioOutputI2SHex::block_ch4_1st = NULL;

  39. audio_block_t * AudioOutputI2SHex::block_ch5_1st = NULL;

  40. audio_block_t * AudioOutputI2SHex::block_ch6_1st = NULL;

  41. audio_block_t * AudioOutputI2SHex::block_ch1_2nd = NULL;

  42. audio_block_t * AudioOutputI2SHex::block_ch2_2nd = NULL;

  43. audio_block_t * AudioOutputI2SHex::block_ch3_2nd = NULL;

  44. audio_block_t * AudioOutputI2SHex::block_ch4_2nd = NULL;

  45. audio_block_t * AudioOutputI2SHex::block_ch5_2nd = NULL;

  46. audio_block_t * AudioOutputI2SHex::block_ch6_2nd = NULL;

  47. uint16_t  AudioOutputI2SHex::ch1_offset = 0;

  48. uint16_t  AudioOutputI2SHex::ch2_offset = 0;

  49. uint16_t  AudioOutputI2SHex::ch3_offset = 0;

  50. uint16_t  AudioOutputI2SHex::ch4_offset = 0;

  51. uint16_t  AudioOutputI2SHex::ch5_offset = 0;

  52. uint16_t  AudioOutputI2SHex::ch6_offset = 0;

  53. bool AudioOutputI2SHex::update_responsibility = false;

  54. DMAMEM __attribute__((aligned(32))) static uint32_t i2s_tx_buffer[AUDIO_BLOCK_SAMPLES*3];

  55. DMAChannel AudioOutputI2SHex::dma(false);

  56. 

  57. static const uint32_t zerodata[AUDIO_BLOCK_SAMPLES/4] = {0};

  58. 

  59. void AudioOutputI2SHex::begin(void)

  60. {

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

  62. 

  63. 	block_ch1_1st = NULL;

  64. 	block_ch2_1st = NULL;

  65. 	block_ch3_1st = NULL;

  66. 	block_ch4_1st = NULL;

  67. 	block_ch5_1st = NULL;

  68. 	block_ch6_1st = NULL;

  69. 

  70. 	const int pinoffset = 0; // TODO: make this configurable...

  71. 	memset(i2s_tx_buffer, 0, sizeof(i2s_tx_buffer));

  72. 	AudioOutputI2S::config_i2s();

  73. 	I2S1_TCR3 = I2S_TCR3_TCE_3CH << pinoffset;

  74. 	switch (pinoffset) {

  75. 	  case 0:

  76. 		CORE_PIN7_CONFIG  = 3;

  77. 		CORE_PIN32_CONFIG = 3;

  78. 		CORE_PIN9_CONFIG  = 3;

  79. 		break;

  80. 	  case 1:

  81. 		CORE_PIN32_CONFIG = 3;

  82. 		CORE_PIN9_CONFIG  = 3;

  83. 		CORE_PIN6_CONFIG  = 3;

  84. 	}

  85. 	dma.TCD->SADDR = i2s_tx_buffer;

  86. 	dma.TCD->SOFF = 2;

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

  88. 	dma.TCD->NBYTES_MLOFFYES = DMA_TCD_NBYTES_DMLOE |

  89. 		DMA_TCD_NBYTES_MLOFFYES_MLOFF(-12) |

  90. 		DMA_TCD_NBYTES_MLOFFYES_NBYTES(6);

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

  92. 	dma.TCD->DADDR = (void *)((uint32_t)&I2S1_TDR0 + 2 + pinoffset * 4);

  93. 	dma.TCD->DOFF = 4;

  94. 	dma.TCD->CITER_ELINKNO = AUDIO_BLOCK_SAMPLES * 2;

  95. 	dma.TCD->DLASTSGA = -12;

  96. 	dma.TCD->BITER_ELINKNO = AUDIO_BLOCK_SAMPLES * 2;

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

  98. 	dma.triggerAtHardwareEvent(DMAMUX_SOURCE_SAI1_TX);

  99. 	dma.enable();

  100. 	I2S1_RCSR |= I2S_RCSR_RE | I2S_RCSR_BCE;

  101. 	I2S1_TCSR = I2S_TCSR_TE | I2S_TCSR_BCE | I2S_TCSR_FRDE;

  102. 	I2S1_TCR3 = I2S_TCR3_TCE_3CH << pinoffset;

  103. 	update_responsibility = update_setup();

  104. 	dma.attachInterrupt(isr);

  105. }

  106. 

  107. void AudioOutputI2SHex::isr(void)

  108. {

  109. 	uint32_t saddr;

  110. 	const int16_t *src1, *src2, *src3, *src4, *src5, *src6;

  111. 	const int16_t *zeros = (const int16_t *)zerodata;

  112. 	int16_t *dest;

  113. 

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

  115. 	dma.clearInterrupt();

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

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

  118. 		// so we must fill the second half

  119. 		dest = (int16_t *)((uint32_t)i2s_tx_buffer + sizeof(i2s_tx_buffer) / 2);

  120. 		if (update_responsibility) update_all();

  121. 	} else {

  122. 		dest = (int16_t *)i2s_tx_buffer;

  123. 	}

  124. 

  125. 	src1 = (block_ch1_1st) ? block_ch1_1st->data + ch1_offset : zeros;

  126. 	src2 = (block_ch2_1st) ? block_ch2_1st->data + ch2_offset : zeros;

  127. 	src3 = (block_ch3_1st) ? block_ch3_1st->data + ch3_offset : zeros;

  128. 	src4 = (block_ch4_1st) ? block_ch4_1st->data + ch4_offset : zeros;

  129. 	src5 = (block_ch5_1st) ? block_ch5_1st->data + ch5_offset : zeros;

  130. 	src6 = (block_ch6_1st) ? block_ch6_1st->data + ch6_offset : zeros;

  131. #if 0

  132. 	// TODO: optimized 6 channel copy...

  133. 	memcpy_tointerleaveQuad(dest, src1, src2, src3, src4);

  134. #else

  135. 	int16_t *p=dest;

  136. 	for (int i=0; i < AUDIO_BLOCK_SAMPLES/2; i++) {

  137. 		*p++ = *src1++;

  138. 		*p++ = *src3++;

  139. 		*p++ = *src5++;

  140. 		*p++ = *src2++;

  141. 		*p++ = *src4++;

  142. 		*p++ = *src6++;

  143. 	}

  144. #endif

  145. 	arm_dcache_flush_delete(dest, sizeof(i2s_tx_buffer) / 2);

  146. 

  147. 	if (block_ch1_1st) {

  148. 		if (ch1_offset == 0) {

  149. 			ch1_offset = AUDIO_BLOCK_SAMPLES/2;

  150. 		} else {

  151. 			ch1_offset = 0;

  152. 			release(block_ch1_1st);

  153. 			block_ch1_1st = block_ch1_2nd;

  154. 			block_ch1_2nd = NULL;

  155. 		}

  156. 	}

  157. 	if (block_ch2_1st) {

  158. 		if (ch2_offset == 0) {

  159. 			ch2_offset = AUDIO_BLOCK_SAMPLES/2;

  160. 		} else {

  161. 			ch2_offset = 0;

  162. 			release(block_ch2_1st);

  163. 			block_ch2_1st = block_ch2_2nd;

  164. 			block_ch2_2nd = NULL;

  165. 		}

  166. 	}

  167. 	if (block_ch3_1st) {

  168. 		if (ch3_offset == 0) {

  169. 			ch3_offset = AUDIO_BLOCK_SAMPLES/2;

  170. 		} else {

  171. 			ch3_offset = 0;

  172. 			release(block_ch3_1st);

  173. 			block_ch3_1st = block_ch3_2nd;

  174. 			block_ch3_2nd = NULL;

  175. 		}

  176. 	}

  177. 	if (block_ch4_1st) {

  178. 		if (ch4_offset == 0) {

  179. 			ch4_offset = AUDIO_BLOCK_SAMPLES/2;

  180. 		} else {

  181. 			ch4_offset = 0;

  182. 			release(block_ch4_1st);

  183. 			block_ch4_1st = block_ch4_2nd;

  184. 			block_ch4_2nd = NULL;

  185. 		}

  186. 	}

  187. 	if (block_ch5_1st) {

  188. 		if (ch5_offset == 0) {

  189. 			ch5_offset = AUDIO_BLOCK_SAMPLES/2;

  190. 		} else {

  191. 			ch5_offset = 0;

  192. 			release(block_ch5_1st);

  193. 			block_ch5_1st = block_ch5_2nd;

  194. 			block_ch5_2nd = NULL;

  195. 		}

  196. 	}

  197. 	if (block_ch6_1st) {

  198. 		if (ch6_offset == 0) {

  199. 			ch6_offset = AUDIO_BLOCK_SAMPLES/2;

  200. 		} else {

  201. 			ch6_offset = 0;

  202. 			release(block_ch6_1st);

  203. 			block_ch6_1st = block_ch6_2nd;

  204. 			block_ch6_2nd = NULL;

  205. 		}

  206. 	}

  207. }

  208. 

  209. 

  210. void AudioOutputI2SHex::update(void)

  211. {

  212. 	audio_block_t *block, *tmp;

  213. 

  214. 	block = receiveReadOnly(0); // channel 1

  215. 	if (block) {

  216. 		__disable_irq();

  217. 		if (block_ch1_1st == NULL) {

  218. 			block_ch1_1st = block;

  219. 			ch1_offset = 0;

  220. 			__enable_irq();

  221. 		} else if (block_ch1_2nd == NULL) {

  222. 			block_ch1_2nd = block;

  223. 			__enable_irq();

  224. 		} else {

  225. 			tmp = block_ch1_1st;

  226. 			block_ch1_1st = block_ch1_2nd;

  227. 			block_ch1_2nd = block;

  228. 			ch1_offset = 0;

  229. 			__enable_irq();

  230. 			release(tmp);

  231. 		}

  232. 	}

  233. 	block = receiveReadOnly(1); // channel 2

  234. 	if (block) {

  235. 		__disable_irq();

  236. 		if (block_ch2_1st == NULL) {

  237. 			block_ch2_1st = block;

  238. 			ch2_offset = 0;

  239. 			__enable_irq();

  240. 		} else if (block_ch2_2nd == NULL) {

  241. 			block_ch2_2nd = block;

  242. 			__enable_irq();

  243. 		} else {

  244. 			tmp = block_ch2_1st;

  245. 			block_ch2_1st = block_ch2_2nd;

  246. 			block_ch2_2nd = block;

  247. 			ch2_offset = 0;

  248. 			__enable_irq();

  249. 			release(tmp);

  250. 		}

  251. 	}

  252. 	block = receiveReadOnly(2); // channel 3

  253. 	if (block) {

  254. 		__disable_irq();

  255. 		if (block_ch3_1st == NULL) {

  256. 			block_ch3_1st = block;

  257. 			ch3_offset = 0;

  258. 			__enable_irq();

  259. 		} else if (block_ch3_2nd == NULL) {

  260. 			block_ch3_2nd = block;

  261. 			__enable_irq();

  262. 		} else {

  263. 			tmp = block_ch3_1st;

  264. 			block_ch3_1st = block_ch3_2nd;

  265. 			block_ch3_2nd = block;

  266. 			ch3_offset = 0;

  267. 			__enable_irq();

  268. 			release(tmp);

  269. 		}

  270. 	}

  271. 	block = receiveReadOnly(3); // channel 4

  272. 	if (block) {

  273. 		__disable_irq();

  274. 		if (block_ch4_1st == NULL) {

  275. 			block_ch4_1st = block;

  276. 			ch4_offset = 0;

  277. 			__enable_irq();

  278. 		} else if (block_ch4_2nd == NULL) {

  279. 			block_ch4_2nd = block;

  280. 			__enable_irq();

  281. 		} else {

  282. 			tmp = block_ch4_1st;

  283. 			block_ch4_1st = block_ch4_2nd;

  284. 			block_ch4_2nd = block;

  285. 			ch4_offset = 0;

  286. 			__enable_irq();

  287. 			release(tmp);

  288. 		}

  289. 	}

  290. 	block = receiveReadOnly(4); // channel 5

  291. 	if (block) {

  292. 		__disable_irq();

  293. 		if (block_ch5_1st == NULL) {

  294. 			block_ch5_1st = block;

  295. 			ch5_offset = 0;

  296. 			__enable_irq();

  297. 		} else if (block_ch5_2nd == NULL) {

  298. 			block_ch5_2nd = block;

  299. 			__enable_irq();

  300. 		} else {

  301. 			tmp = block_ch5_1st;

  302. 			block_ch5_1st = block_ch5_2nd;

  303. 			block_ch5_2nd = block;

  304. 			ch5_offset = 0;

  305. 			__enable_irq();

  306. 			release(tmp);

  307. 		}

  308. 	}

  309. 	block = receiveReadOnly(5); // channel 6

  310. 	if (block) {

  311. 		__disable_irq();

  312. 		if (block_ch6_1st == NULL) {

  313. 			block_ch6_1st = block;

  314. 			ch6_offset = 0;

  315. 			__enable_irq();

  316. 		} else if (block_ch6_2nd == NULL) {

  317. 			block_ch6_2nd = block;

  318. 			__enable_irq();

  319. 		} else {

  320. 			tmp = block_ch6_1st;

  321. 			block_ch6_1st = block_ch6_2nd;

  322. 			block_ch6_2nd = block;

  323. 			ch6_offset = 0;

  324. 			__enable_irq();

  325. 			release(tmp);

  326. 		}

  327. 	}

  328. }

  329. 

  330. 

  331. #else // not supported

  332. 

  333. void AudioOutputI2SHex::begin(void)

  334. {

  335. }

  336. 

  337. void AudioOutputI2SHex::update(void)

  338. {

  339. 	audio_block_t *block;

  340. 

  341. 	block = receiveReadOnly(0);

  342. 	if (block) release(block);

  343. 	block = receiveReadOnly(1);

  344. 	if (block) release(block);

  345. 	block = receiveReadOnly(2);

  346. 	if (block) release(block);

  347. 	block = receiveReadOnly(3);

  348. 	if (block) release(block);

  349. 	block = receiveReadOnly(4);

  350. 	if (block) release(block);

  351. 	block = receiveReadOnly(5);

  352. 	if (block) release(block);

  353. }

  354. 

  355. #endif