visus
/
teensy-core-4.1
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Teensy 4.1 core updated for 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.
146 Commits
2 Branches
Tree: 064c0b52ee
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '064c0b52ee'
${ noResults }
teensy-core-4.1/teensy3/DMAChannel.h

811 lines
28KB
Raw Blame History 

  1. #ifndef DMAChannel_h_

  2. #define DMAChannel_h_

  3. 

  4. #include "kinetis.h"

  5. 

  6. // This code is a work-in-progress.  It's incomplete and not usable yet...

  7. //

  8. // http://forum.pjrc.com/threads/25778-Could-there-be-something-like-an-ISR-template-function/page3

  9. 

  10. 

  11. // known libraries with DMA usage (in need of porting to this new scheme):

  12. //

  13. // https://github.com/PaulStoffregen/Audio

  14. // https://github.com/PaulStoffregen/OctoWS2811

  15. // https://github.com/pedvide/ADC

  16. // https://github.com/duff2013/SerialEvent

  17. // https://github.com/pixelmatix/SmartMatrix

  18. // https://github.com/crteensy/DmaSpi

  19. 

  20. 

  21. #ifdef __cplusplus

  22. 

  23. 

  24. class DMABaseClass {

  25. public:

  26. 	typedef struct __attribute__((packed)) {

  27. 		volatile const void * volatile SADDR;

  28. 		int16_t SOFF;

  29. 		union { uint16_t ATTR;

  30. 			struct { uint8_t ATTR_DST; uint8_t ATTR_SRC; }; };

  31. 		union { uint32_t NBYTES; uint32_t NBYTES_MLNO;

  32. 			uint32_t NBYTES_MLOFFNO; uint32_t NBYTES_MLOFFYES; };

  33. 		int32_t SLAST;

  34. 		volatile void * volatile DADDR;

  35. 		int16_t DOFF;

  36. 		union { volatile uint16_t CITER;

  37. 			volatile uint16_t CITER_ELINKYES; volatile uint16_t CITER_ELINKNO; };

  38. 		int32_t DLASTSGA;

  39. 		volatile uint16_t CSR;

  40. 		union { volatile uint16_t BITER;

  41. 			volatile uint16_t BITER_ELINKYES; volatile uint16_t BITER_ELINKNO; };

  42. 	} TCD_t;

  43. 	TCD_t *TCD;

  44. 

  45. 	/***************************************/

  46. 	/**    Data Transfer                  **/

  47. 	/***************************************/

  48. 

  49. 	// Use a single variable as the data source.  Typically a register

  50. 	// for receiving data from one of the hardware peripherals is used.

  51. 	void source(volatile const signed char &p) { source(*(volatile const uint8_t *)&p); }

  52. 	void source(volatile const unsigned char &p) {

  53. 		TCD->SADDR = &p;

  54. 		TCD->SOFF = 0;

  55. 		TCD->ATTR_SRC = 0;

  56. 		if ((uint32_t)p < 0x40000000 || TCD->NBYTES == 0) TCD->NBYTES = 1;

  57. 		TCD->SLAST = 0;

  58. 	}

  59. 	void source(volatile const signed short &p) { source(*(volatile const uint16_t *)&p); }

  60. 	void source(volatile const unsigned short &p) {

  61. 		TCD->SADDR = &p;

  62. 		TCD->SOFF = 0;

  63. 		TCD->ATTR_SRC = 1;

  64. 		if ((uint32_t)p < 0x40000000 || TCD->NBYTES == 0) TCD->NBYTES = 2;

  65. 		TCD->SLAST = 0;

  66. 	}

  67. 	void source(volatile const signed int &p) { source(*(volatile const uint32_t *)&p); }

  68. 	void source(volatile const unsigned int &p) { source(*(volatile const uint32_t *)&p); }

  69. 	void source(volatile const signed long &p) { source(*(volatile const uint32_t *)&p); }

  70. 	void source(volatile const unsigned long &p) {

  71. 		TCD->SADDR = &p;

  72. 		TCD->SOFF = 0;

  73. 		TCD->ATTR_SRC = 2;

  74. 		if ((uint32_t)p < 0x40000000 || TCD->NBYTES == 0) TCD->NBYTES = 4;

  75. 		TCD->SLAST = 0;

  76. 	}

  77. 

  78. 	// Use a buffer (array of data) as the data source.  Typically a

  79. 	// buffer for transmitting data is used.

  80. 	void sourceBuffer(volatile const signed char p[], unsigned int len) {

  81. 		sourceBuffer((volatile const uint8_t *)p, len); }

  82. 	void sourceBuffer(volatile const unsigned char p[], unsigned int len) {

  83. 		TCD->SADDR = p;

  84. 		TCD->SOFF = 1;

  85. 		TCD->ATTR_SRC = 0;

  86. 		TCD->NBYTES = 1;

  87. 		TCD->SLAST = -len;

  88. 		TCD->BITER = len;

  89. 		TCD->CITER = len;

  90. 	}

  91. 	void sourceBuffer(volatile const signed short p[], unsigned int len) {

  92. 		sourceBuffer((volatile const uint16_t *)p, len); }

  93. 	void sourceBuffer(volatile const unsigned short p[], unsigned int len) {

  94. 		TCD->SADDR = p;

  95. 		TCD->SOFF = 2;

  96. 		TCD->ATTR_SRC = 1;

  97. 		TCD->NBYTES = 2;

  98. 		TCD->SLAST = -len;

  99. 		TCD->BITER = len / 2;

  100. 		TCD->CITER = len / 2;

  101. 	}

  102. 	void sourceBuffer(volatile const signed int p[], unsigned int len) {

  103. 		sourceBuffer((volatile const uint32_t *)p, len); }

  104. 	void sourceBuffer(volatile const unsigned int p[], unsigned int len) {

  105. 		sourceBuffer((volatile const uint32_t *)p, len); }

  106. 	void sourceBuffer(volatile const signed long p[], unsigned int len) {

  107. 		sourceBuffer((volatile const uint32_t *)p, len); }

  108. 	void sourceBuffer(volatile const unsigned long p[], unsigned int len) {

  109. 		TCD->SADDR = p;

  110. 		TCD->SOFF = 4;

  111. 		TCD->ATTR_SRC = 2;

  112. 		TCD->NBYTES = 4;

  113. 		TCD->SLAST = -len;

  114. 		TCD->BITER = len / 4;

  115. 		TCD->CITER = len / 4;

  116. 	}

  117. 

  118. 	// Use a circular buffer as the data source

  119. 	void sourceCircular(volatile const signed char p[], unsigned int len) {

  120. 		sourceCircular((volatile const uint8_t *)p, len); }

  121. 	void sourceCircular(volatile const unsigned char p[], unsigned int len) {

  122. 		TCD->SADDR = p;

  123. 		TCD->SOFF = 1;

  124. 		TCD->ATTR_SRC = ((31 - __builtin_clz(len)) << 3);

  125. 		TCD->NBYTES = 1;

  126. 		TCD->SLAST = 0;

  127. 		TCD->BITER = len;

  128. 		TCD->CITER = len;

  129. 	}

  130. 	void sourceCircular(volatile const signed short p[], unsigned int len) {

  131. 		sourceCircular((volatile const uint16_t *)p, len); }

  132. 	void sourceCircular(volatile const unsigned short p[], unsigned int len) {

  133. 		TCD->SADDR = p;

  134. 		TCD->SOFF = 2;

  135. 		TCD->ATTR_SRC = ((31 - __builtin_clz(len)) << 3) | 1;

  136. 		TCD->NBYTES = 2;

  137. 		TCD->SLAST = 0;

  138. 		TCD->BITER = len / 2;

  139. 		TCD->CITER = len / 2;

  140. 	}

  141. 	void sourceCircular(volatile const signed int p[], unsigned int len) {

  142. 		sourceCircular((volatile const uint32_t *)p, len); }

  143. 	void sourceCircular(volatile const unsigned int p[], unsigned int len) {

  144. 		sourceCircular((volatile const uint32_t *)p, len); }

  145. 	void sourceCircular(volatile const signed long p[], unsigned int len) {

  146. 		sourceCircular((volatile const uint32_t *)p, len); }

  147. 	void sourceCircular(volatile const unsigned long p[], unsigned int len) {

  148. 		TCD->SADDR = p;

  149. 		TCD->SOFF = 4;

  150. 		TCD->ATTR_SRC = ((31 - __builtin_clz(len)) << 3) | 2;

  151. 		TCD->NBYTES = 4;

  152. 		TCD->SLAST = 0;

  153. 		TCD->BITER = len / 4;

  154. 		TCD->CITER = len / 4;

  155. 	}

  156. 

  157. 	// Use a single variable as the data destination.  Typically a register

  158. 	// for transmitting data to one of the hardware peripherals is used.

  159. 	void destination(volatile signed char &p) { destination(*(volatile uint8_t *)&p); }

  160. 	void destination(volatile unsigned char &p) {

  161. 		TCD->DADDR = &p;

  162. 		TCD->DOFF = 0;

  163. 		TCD->ATTR_DST = 0;

  164. 		if ((uint32_t)p < 0x40000000 || TCD->NBYTES == 0) TCD->NBYTES = 1;

  165. 		TCD->DLASTSGA = 0;

  166. 	}

  167. 	void destination(volatile signed short &p) { destination(*(volatile uint16_t *)&p); }

  168. 	void destination(volatile unsigned short &p) {

  169. 		TCD->DADDR = &p;

  170. 		TCD->DOFF = 0;

  171. 		TCD->ATTR_DST = 1;

  172. 		if ((uint32_t)p < 0x40000000 || TCD->NBYTES == 0) TCD->NBYTES = 2;

  173. 		TCD->DLASTSGA = 0;

  174. 	}

  175. 	void destination(volatile signed int &p) { destination(*(volatile uint32_t *)&p); }

  176. 	void destination(volatile unsigned int &p) { destination(*(volatile uint32_t *)&p); }

  177. 	void destination(volatile signed long &p) { destination(*(volatile uint32_t *)&p); }

  178. 	void destination(volatile unsigned long &p) {

  179. 		TCD->DADDR = &p;

  180. 		TCD->DOFF = 0;

  181. 		TCD->ATTR_DST = 2;

  182. 		if ((uint32_t)p < 0x40000000 || TCD->NBYTES == 0) TCD->NBYTES = 4;

  183. 		TCD->DLASTSGA = 0;

  184. 	}

  185. 

  186. 	// Use a buffer (array of data) as the data destination.  Typically a

  187. 	// buffer for receiving data is used.

  188. 	void destinationBuffer(volatile signed char p[], unsigned int len) {

  189. 		destinationBuffer((volatile uint8_t *)p, len); }

  190. 	void destinationBuffer(volatile unsigned char p[], unsigned int len) {

  191. 		TCD->DADDR = p;

  192. 		TCD->DOFF = 1;

  193. 		TCD->ATTR_DST = 0;

  194. 		TCD->NBYTES = 1;

  195. 		TCD->DLASTSGA = -len;

  196. 		TCD->BITER = len;

  197. 		TCD->CITER = len;

  198. 	}

  199. 	void destinationBuffer(volatile signed short p[], unsigned int len) {

  200. 		destinationBuffer((volatile uint16_t *)p, len); }

  201. 	void destinationBuffer(volatile unsigned short p[], unsigned int len) {

  202. 		TCD->DADDR = p;

  203. 		TCD->DOFF = 2;

  204. 		TCD->ATTR_DST = 1;

  205. 		TCD->NBYTES = 2;

  206. 		TCD->DLASTSGA = -len;

  207. 		TCD->BITER = len / 2;

  208. 		TCD->CITER = len / 2;

  209. 	}

  210. 	void destinationBuffer(volatile signed int p[], unsigned int len) {

  211. 		destinationBuffer((volatile uint32_t *)p, len); }

  212. 	void destinationBuffer(volatile unsigned int p[], unsigned int len) {

  213. 		destinationBuffer((volatile uint32_t *)p, len); }

  214. 	void destinationBuffer(volatile signed long p[], unsigned int len) {

  215. 		destinationBuffer((volatile uint32_t *)p, len); }

  216. 	void destinationBuffer(volatile unsigned long p[], unsigned int len) {

  217. 		TCD->DADDR = p;

  218. 		TCD->DOFF = 4;

  219. 		TCD->ATTR_DST = 2;

  220. 		TCD->NBYTES = 4;

  221. 		TCD->DLASTSGA = -len;

  222. 		TCD->BITER = len / 4;

  223. 		TCD->CITER = len / 4;

  224. 	}

  225. 

  226. 	// Use a circular buffer as the data destination

  227. 	void destinationCircular(volatile signed char p[], unsigned int len) {

  228. 		destinationCircular((volatile uint8_t *)p, len); }

  229. 	void destinationCircular(volatile unsigned char p[], unsigned int len) {

  230. 		TCD->DADDR = p;

  231. 		TCD->DOFF = 1;

  232. 		TCD->ATTR_DST = ((31 - __builtin_clz(len)) << 3);

  233. 		TCD->NBYTES = 1;

  234. 		TCD->DLASTSGA = 0;

  235. 		TCD->BITER = len;

  236. 		TCD->CITER = len;

  237. 	}

  238. 	void destinationCircular(volatile signed short p[], unsigned int len) {

  239. 		destinationCircular((volatile uint16_t *)p, len); }

  240. 	void destinationCircular(volatile unsigned short p[], unsigned int len) {

  241. 		TCD->DADDR = p;

  242. 		TCD->DOFF = 2;

  243. 		TCD->ATTR_DST = ((31 - __builtin_clz(len)) << 3) | 1;

  244. 		TCD->NBYTES = 2;

  245. 		TCD->DLASTSGA = 0;

  246. 		TCD->BITER = len / 2;

  247. 		TCD->CITER = len / 2;

  248. 	}

  249. 	void destinationCircular(volatile signed int p[], unsigned int len) {

  250. 		destinationCircular((volatile uint32_t *)p, len); }

  251. 	void destinationCircular(volatile unsigned int p[], unsigned int len) {

  252. 		destinationCircular((volatile uint32_t *)p, len); }

  253. 	void destinationCircular(volatile signed long p[], unsigned int len) {

  254. 		destinationCircular((volatile uint32_t *)p, len); }

  255. 	void destinationCircular(volatile unsigned long p[], unsigned int len) {

  256. 		TCD->DADDR = p;

  257. 		TCD->DOFF = 4;

  258. 		TCD->ATTR_DST = ((31 - __builtin_clz(len)) << 3) | 2;

  259. 		TCD->NBYTES = 4;

  260. 		TCD->DLASTSGA = 0;

  261. 		TCD->BITER = len / 4;

  262. 		TCD->CITER = len / 4;

  263. 	}

  264. 

  265. 	/*************************************************/

  266. 	/**    Quantity of Data to Transfer             **/

  267. 	/*************************************************/

  268. 

  269. 	// Set the data size used for each triggered transfer

  270. 	void transferSize(unsigned int len) {

  271. 		if (len == 4) {

  272. 			TCD->NBYTES = 4;

  273. 			if (TCD->SOFF != 0) TCD->SOFF = 4;

  274. 			if (TCD->DOFF != 0) TCD->DOFF = 4;

  275. 			TCD->ATTR = (TCD->ATTR & 0xF8F8) | 0x0202;

  276. 		} else if (len == 2) {

  277. 			TCD->NBYTES = 2;

  278. 			if (TCD->SOFF != 0) TCD->SOFF = 2;

  279. 			if (TCD->DOFF != 0) TCD->DOFF = 2;

  280. 			TCD->ATTR = (TCD->ATTR & 0xF8F8) | 0x0101;

  281. 		} else {

  282. 			TCD->NBYTES = 1;

  283. 			if (TCD->SOFF != 0) TCD->SOFF = 1;

  284. 			if (TCD->DOFF != 0) TCD->DOFF = 1;

  285. 			TCD->ATTR = TCD->ATTR & 0xF8F8;

  286. 		}

  287. 	}

  288. 

  289. 	// Set the number of transfers (number of triggers until complete)

  290. 	void transferCount(unsigned int len) {

  291. 		if (len > 32767) return;

  292. 		if (len >= 512) {

  293. 			TCD->BITER = len;

  294. 			TCD->CITER = len;

  295. 		} else {

  296. 			TCD->BITER = (TCD->BITER & 0xFE00) | len;

  297. 			TCD->CITER = (TCD->CITER & 0xFE00) | len;

  298. 		}

  299. 	}

  300. 

  301. 	/*************************************************/

  302. 	/**    Special Options / Features               **/

  303. 	/*************************************************/

  304. 

  305. 	void interruptAtCompletion(void) {

  306. 		TCD->CSR |= DMA_TCD_CSR_INTMAJOR;

  307. 	}

  308. 

  309. 	void interruptAtHalf(void) {

  310. 		TCD->CSR |= DMA_TCD_CSR_INTHALF;

  311. 	}

  312. 

  313. 	void disableOnCompletion(void) {

  314. 		TCD->CSR |= DMA_TCD_CSR_DREQ;

  315. 	}

  316. 

  317. 	void replaceSettingsOnCompletion(const DMABaseClass &settings) {

  318. 		TCD->DLASTSGA = (int32_t)(settings.TCD);

  319. 		TCD->CSR &= ~DMA_TCD_CSR_DONE;

  320. 		TCD->CSR |= DMA_TCD_CSR_ESG;

  321. 	}

  322. 

  323. protected:

  324. 	// users should not be able to create instances of DMABaseClass, which

  325. 	// require the inheriting class to initialize the TCD pointer.

  326. 	DMABaseClass() {}

  327. 

  328. 	static inline void copy_tcd(TCD_t *dst, const TCD_t *src) {

  329. 		const uint32_t *p = (const uint32_t *)src;

  330. 		uint32_t *q = (uint32_t *)dst;

  331. 		uint32_t t1, t2, t3, t4;

  332. 		t1 = *p++; t2 = *p++; t3 = *p++; t4 = *p++;

  333. 		*q++ = t1; *q++ = t2; *q++ = t3; *q++ = t4;

  334. 		t1 = *p++; t2 = *p++; t3 = *p++; t4 = *p++;

  335. 		*q++ = t1; *q++ = t2; *q++ = t3; *q++ = t4;

  336. 	}

  337. };

  338. 

  339. 

  340. // DMASetting represents settings stored only in memory, which can be

  341. // applied to any DMA channel.

  342. 

  343. class DMASetting : public DMABaseClass {

  344. public:

  345. 	DMASetting() {

  346. 		TCD = &tcddata;

  347. 	}

  348. 	DMASetting(const DMASetting &c) {

  349. 		TCD = &tcddata;

  350. 		*this = c;

  351. 	}

  352. 	DMASetting(const DMABaseClass &c) {

  353. 		TCD = &tcddata;

  354. 		*this = c;

  355. 	}

  356. 	DMASetting & operator = (const DMABaseClass &rhs) {

  357. 		copy_tcd(TCD, rhs.TCD);

  358. 		return *this;

  359. 	}

  360. private:

  361. 	TCD_t tcddata __attribute__((aligned(32)));

  362. };

  363. 

  364. 

  365. // DMAChannel reprents an actual DMA channel and its current settings

  366. 

  367. class DMAChannel : public DMABaseClass {

  368. public:

  369. 	/*************************************************/

  370. 	/**    Channel Allocation                       **/

  371. 	/*************************************************/

  372. 

  373. 	DMAChannel() {

  374. 		init();

  375. 	}

  376. 	DMAChannel(const DMAChannel &c) {

  377. 		TCD = c.TCD;

  378. 		channel = c.channel;

  379. 	}

  380. 	DMAChannel(const DMASetting &c) {

  381. 		init();

  382. 		copy_tcd(TCD, c.TCD);

  383. 	}

  384. 	DMAChannel & operator = (const DMAChannel &rhs) {

  385. 		if (channel != rhs.channel) {

  386. 			release();

  387. 			TCD = rhs.TCD;

  388. 			channel = rhs.channel;

  389. 		}

  390. 		return *this;

  391. 	}

  392. 	DMAChannel & operator = (const DMASetting &rhs) {

  393. 		copy_tcd(TCD, rhs.TCD);

  394. 		return *this;

  395. 	}

  396. 	~DMAChannel() {

  397. 		release();

  398. 	}

  399. private:

  400. 	void init(void);

  401. 	void release(void);

  402. 

  403. public:

  404. 	/***************************************/

  405. 	/**    Triggering                     **/

  406. 	/***************************************/

  407. 

  408. 	// Triggers cause the DMA channel to actually move data.  Each

  409. 	// trigger moves a single data unit, which is typically 8, 16 or

  410. 	// 32 bits.  If a channel is configured for 200 transfers

  411. 

  412. 	// Use a hardware trigger to make the DMA channel run

  413. 	void triggerAtHardwareEvent(uint8_t source) {

  414. 		volatile uint8_t *mux;

  415. 		mux = (volatile uint8_t *)&(DMAMUX0_CHCFG0) + channel;

  416. 		*mux = 0;

  417. 		*mux = (source & 63) | DMAMUX_ENABLE;

  418. 	}

  419. 

  420. 	// Use another DMA channel as the trigger, causing this

  421. 	// channel to trigger after each transfer is makes, except

  422. 	// the its last transfer.  This effectively makes the 2

  423. 	// channels run in parallel until the last transfer

  424. 	void triggerAtTransfersOf(DMABaseClass &ch) {

  425. 		ch.TCD->BITER = (ch.TCD->BITER & ~DMA_TCD_BITER_ELINKYES_LINKCH_MASK)

  426. 		  | DMA_TCD_BITER_ELINKYES_LINKCH(channel) | DMA_TCD_BITER_ELINKYES_ELINK;

  427. 		ch.TCD->CITER = ch.TCD->BITER ;

  428. 	}

  429. 

  430. 	// Use another DMA channel as the trigger, causing this

  431. 	// channel to trigger when the other channel completes.

  432. 	void triggerAtCompletionOf(DMABaseClass &ch) {

  433. 		ch.TCD->CSR = (ch.TCD->CSR & ~(DMA_TCD_CSR_MAJORLINKCH_MASK|DMA_TCD_CSR_DONE))

  434. 		  | DMA_TCD_CSR_MAJORLINKCH(channel) | DMA_TCD_CSR_MAJORELINK;

  435. 	}

  436. 

  437. 	// Cause this DMA channel to be continuously triggered, so

  438. 	// it will move data as rapidly as possible, without waiting.

  439. 	// Normally this would be used with disableOnCompletion().

  440. 	void triggerContinuously(void) {

  441. 		volatile uint8_t *mux = (volatile uint8_t *)&DMAMUX0_CHCFG0;

  442. 		mux[channel] = 0;

  443. #if DMAMUX_NUM_SOURCE_ALWAYS >= DMA_NUM_CHANNELS

  444. 		mux[channel] = DMAMUX_SOURCE_ALWAYS0 + channel;	

  445. #else

  446. 		// search for an unused "always on" source

  447. 		unsigned int i = DMAMUX_SOURCE_ALWAYS0;

  448. 		for (i = DMAMUX_SOURCE_ALWAYS0;

  449. 		  i < DMAMUX_SOURCE_ALWAYS0 + DMAMUX_NUM_SOURCE_ALWAYS; i++) {

  450. 			unsigned int ch;

  451. 			for (ch=0; ch < DMA_NUM_CHANNELS; ch++) {

  452. 				if (mux[ch] == i) break;

  453. 			}

  454. 			if (ch >= DMA_NUM_CHANNELS) {

  455. 				mux[channel] = (i | DMAMUX_ENABLE);

  456. 				return;

  457. 			}

  458. 		}

  459. #endif

  460. 	}

  461. 

  462. 	// Manually trigger the DMA channel.

  463. 	void triggerManual(void) {

  464. 		DMA_SSRT = channel;

  465. 	}

  466. 

  467. 

  468. 	/***************************************/

  469. 	/**    Interrupts                     **/

  470. 	/***************************************/

  471. 

  472. 	// An interrupt routine can be run when the DMA channel completes

  473. 	// the entire transfer, and also optionally when half of the

  474. 	// transfer is completed.

  475. 	void attachInterrupt(void (*isr)(void)) {

  476. 		_VectorsRam[channel + IRQ_DMA_CH0 + 16] = isr;

  477. 		NVIC_ENABLE_IRQ(IRQ_DMA_CH0 + channel);

  478. 	}

  479. 

  480. 	void detachInterrupt(void) {

  481. 		NVIC_DISABLE_IRQ(IRQ_DMA_CH0 + channel);

  482. 	}

  483. 

  484. 	void clearInterrupt(void) {

  485. 		DMA_CINT = channel;

  486. 	}

  487. 

  488. 

  489. 	/***************************************/

  490. 	/**    Enable / Disable               **/

  491. 	/***************************************/

  492. 

  493. 	void enable(void) {

  494. 		DMA_SERQ = channel;

  495. 	}

  496. 	void disable(void) {

  497. 		DMA_CERQ = channel;

  498. 	}

  499. 

  500. 	/***************************************/

  501. 	/**    Status                         **/

  502. 	/***************************************/

  503. 

  504. 	bool complete(void) {

  505. 		if (TCD->CSR & DMA_TCD_CSR_DONE) return true;

  506. 		return false;

  507. 	}

  508. 	void clearComplete(void) {

  509. 		DMA_CDNE = channel;

  510. 	}

  511. 	bool error(void) {

  512. 		if (DMA_ERR & (1<<channel)) return true;

  513. 		return false;

  514. 	}

  515. 	void clearError(void) {

  516. 		DMA_CERR = channel;

  517. 	}

  518. 	void * sourceAddress(void) {

  519. 		return (void *)(TCD->SADDR);

  520. 	}

  521. 	void * destinationAddress(void) {

  522. 		return (void *)(TCD->DADDR);

  523. 	}

  524. 

  525. 	/***************************************/

  526. 	/**    Direct Hardware Access         **/

  527. 	/***************************************/

  528. 

  529. 	// For complex and unusual configurations not possible with the above

  530. 	// functions, the Transfer Control Descriptor (TCD) and channel number

  531. 	// can be used directly.  This leads to less portable and less readable

  532. 	// code, but direct control of all parameters is possible.

  533. 	uint8_t channel;

  534. 	// TCD is accessible due to inheritance from DMABaseClass

  535. 

  536. /* usage cases:

  537. 

  538. ************************

  539. OctoWS2811:

  540. ************************

  541. 

  542.         // enable clocks to the DMA controller and DMAMUX

  543.         SIM_SCGC7 |= SIM_SCGC7_DMA;

  544.         SIM_SCGC6 |= SIM_SCGC6_DMAMUX;

  545.         DMA_CR = 0;

  546.         DMA_CERQ = 1;

  547.         DMA_CERQ = 2;

  548.         DMA_CERQ = 3;

  549. 

  550.         // DMA channel #1 sets WS2811 high at the beginning of each cycle

  551.          DMA_TCD1_SADDR = &ones;

  552.          DMA_TCD1_SOFF = 0;

  553.          DMA_TCD1_ATTR = DMA_TCD_ATTR_SSIZE(0) | DMA_TCD_ATTR_DSIZE(0);

  554.          DMA_TCD1_NBYTES_MLNO = 1;

  555.          DMA_TCD1_SLAST = 0;

  556.          DMA_TCD1_DADDR = &GPIOD_PSOR;

  557.          DMA_TCD1_DOFF = 0;

  558.          DMA_TCD1_CITER_ELINKNO = bufsize;

  559.          DMA_TCD1_DLASTSGA = 0;

  560.          DMA_TCD1_CSR = DMA_TCD_CSR_DREQ;

  561.          DMA_TCD1_BITER_ELINKNO = bufsize;

  562. 	dma1.source(ones);

  563. 	dma1.destination(GPIOD_PSOR);

  564. 	dma1.size(1);

  565. 	dma1.count(bufsize);

  566. 	dma1.disableOnCompletion();

  567. 

  568.         // DMA channel #2 writes the pixel data at 20% of the cycle

  569.          DMA_TCD2_SADDR = frameBuffer;

  570.          DMA_TCD2_SOFF = 1;

  571.          DMA_TCD2_ATTR = DMA_TCD_ATTR_SSIZE(0) | DMA_TCD_ATTR_DSIZE(0);

  572.          DMA_TCD2_NBYTES_MLNO = 1;

  573.          DMA_TCD2_SLAST = -bufsize;

  574.          DMA_TCD2_DADDR = &GPIOD_PDOR;

  575.          DMA_TCD2_DOFF = 0;

  576.          DMA_TCD2_CITER_ELINKNO = bufsize;

  577.          DMA_TCD2_DLASTSGA = 0;

  578.          DMA_TCD2_CSR = DMA_TCD_CSR_DREQ;

  579.          DMA_TCD2_BITER_ELINKNO = bufsize;

  580. 	dma2.source(frameBuffer, sizeof(frameBuffer));

  581. 	dma2.destination(GPIOD_PDOR);

  582. 	dma2.size(1);

  583. 	dma2.count(bufsize);

  584. 	dma2.disableOnCompletion();

  585. 

  586.         // DMA channel #3 clear all the pins low at 48% of the cycle

  587.         DMA_TCD3_SADDR = &ones;

  588.         DMA_TCD3_SOFF = 0;

  589.         DMA_TCD3_ATTR = DMA_TCD_ATTR_SSIZE(0) | DMA_TCD_ATTR_DSIZE(0);

  590.         DMA_TCD3_NBYTES_MLNO = 1;

  591.         DMA_TCD3_SLAST = 0;

  592.         DMA_TCD3_DADDR = &GPIOD_PCOR;

  593.         DMA_TCD3_DOFF = 0;

  594.         DMA_TCD3_CITER_ELINKNO = bufsize;

  595.         DMA_TCD3_DLASTSGA = 0;

  596.         DMA_TCD3_CSR = DMA_TCD_CSR_DREQ | DMA_TCD_CSR_INTMAJOR;

  597.         DMA_TCD3_BITER_ELINKNO = bufsize;

  598. 	dma3.source(ones);

  599. 	dma3.destination(GPIOD_PCOR);

  600. 	dma3.size(1);

  601. 	dma3.count(bufsize);

  602. 	dma3.disableOnCompletion();

  603. 

  604. ************************

  605. Audio, DAC

  606. ************************

  607. 

  608.         DMA_CR = 0;

  609.         DMA_TCD4_SADDR = dac_buffer;

  610.         DMA_TCD4_SOFF = 2;

  611.         DMA_TCD4_ATTR = DMA_TCD_ATTR_SSIZE(1) | DMA_TCD_ATTR_DSIZE(1);

  612.         DMA_TCD4_NBYTES_MLNO = 2;

  613.         DMA_TCD4_SLAST = -sizeof(dac_buffer);

  614.         DMA_TCD4_DADDR = &DAC0_DAT0L;

  615.         DMA_TCD4_DOFF = 0;

  616.         DMA_TCD4_CITER_ELINKNO = sizeof(dac_buffer) / 2;

  617.         DMA_TCD4_DLASTSGA = 0;

  618.         DMA_TCD4_BITER_ELINKNO = sizeof(dac_buffer) / 2;

  619.         DMA_TCD4_CSR = DMA_TCD_CSR_INTHALF | DMA_TCD_CSR_INTMAJOR;

  620.         DMAMUX0_CHCFG4 = DMAMUX_DISABLE;

  621.         DMAMUX0_CHCFG4 = DMAMUX_SOURCE_PDB | DMAMUX_ENABLE;

  622. 

  623. ************************

  624. Audio, I2S

  625. ************************

  626. 

  627.         DMA_CR = 0;

  628.         DMA_TCD0_SADDR = i2s_tx_buffer;

  629.         DMA_TCD0_SOFF = 2;

  630.         DMA_TCD0_ATTR = DMA_TCD_ATTR_SSIZE(1) | DMA_TCD_ATTR_DSIZE(1);

  631.         DMA_TCD0_NBYTES_MLNO = 2;

  632.         DMA_TCD0_SLAST = -sizeof(i2s_tx_buffer);

  633.         DMA_TCD0_DADDR = &I2S0_TDR0;

  634.         DMA_TCD0_DOFF = 0;

  635.         DMA_TCD0_CITER_ELINKNO = sizeof(i2s_tx_buffer) / 2;

  636.         DMA_TCD0_DLASTSGA = 0;

  637.         DMA_TCD0_BITER_ELINKNO = sizeof(i2s_tx_buffer) / 2;

  638.         DMA_TCD0_CSR = DMA_TCD_CSR_INTHALF | DMA_TCD_CSR_INTMAJOR;

  639. 

  640.         DMAMUX0_CHCFG0 = DMAMUX_DISABLE;

  641.         DMAMUX0_CHCFG0 = DMAMUX_SOURCE_I2S0_TX | DMAMUX_ENABLE;

  642. 

  643. ************************

  644. ADC lib, Pedro Villanueva

  645. ************************

  646. 

  647.     DMA_CR = 0; // normal mode of operation

  648. 

  649.     *DMAMUX0_CHCFG = DMAMUX_DISABLE; // disable before changing

  650. 

  651.     *DMA_TCD_ATTR = DMA_TCD_ATTR_SSIZE(DMA_TCD_ATTR_SIZE_16BIT) |

  652.                   DMA_TCD_ATTR_DSIZE(DMA_TCD_ATTR_SIZE_16BIT) |

  653.                   DMA_TCD_ATTR_DMOD(4); // src and dst data is 16 bit (2 bytes), buffer size 2^^4 bytes = 8 values

  654.     *DMA_TCD_NBYTES_MLNO = 2; // Minor Byte Transfer Count 2 bytes = 16 bits (we transfer 2 bytes each minor loop)

  655. 

  656.     *DMA_TCD_SADDR = ADC_RA; // source address

  657.     *DMA_TCD_SOFF = 0; // don't change the address when minor loop finishes

  658.     *DMA_TCD_SLAST = 0; // don't change src address after major loop completes

  659. 

  660.     *DMA_TCD_DADDR = elems; // destination address

  661.     *DMA_TCD_DOFF = 2; // increment 2 bytes each minor loop

  662.     *DMA_TCD_DLASTSGA = 0; // modulus feature takes care of going back to first element

  663. 

  664.     *DMA_TCD_CITER_ELINKNO = 1; // Current Major Iteration Count with channel linking disabled

  665.     *DMA_TCD_BITER_ELINKNO = 1; // Starting Major Iteration Count with channel linking disabled

  666. 

  667.     *DMA_TCD_CSR = DMA_TCD_CSR_INTMAJOR; // Control and status: interrupt when major counter is complete

  668. 

  669.     DMA_CERQ = DMA_CERQ_CERQ(DMA_channel); // clear all past request

  670.     DMA_CINT = DMA_channel; // clear interrupts

  671. 

  672.     uint8_t DMAMUX_SOURCE_ADC = DMAMUX_SOURCE_ADC0;

  673.     if(ADC_number==1){

  674.         DMAMUX_SOURCE_ADC = DMAMUX_SOURCE_ADC1;

  675.     }

  676.     *DMAMUX0_CHCFG = DMAMUX_SOURCE_ADC | DMAMUX_ENABLE; // enable mux and set channel DMA_channel to ADC0

  677. 

  678.     DMA_SERQ = DMA_SERQ_SERQ(DMA_channel); // enable DMA request

  679.     NVIC_ENABLE_IRQ(IRQ_DMA_CH); // enable interrupts

  680. 

  681. ************************

  682. SmartMatrix

  683. ************************

  684. 

  685.     // enable minor loop mapping so addresses can get reset after minor loops

  686.     DMA_CR = 1 << 7;

  687. 

  688.     // DMA channel #0 - on latch rising edge, read address from fixed address temporary buffer, and output address on GPIO

  689.     // using combo of writes to set+clear registers, to only modify the address pins and not other GPIO pins

  690.     // address temporary buffer is refreshed before each DMA trigger (by DMA channel #2)

  691.     // only use single major loop, never disable channel

  692. #define ADDRESS_ARRAY_REGISTERS_TO_UPDATE   2

  693.     DMA_TCD0_SADDR = &gpiosync.gpio_pcor;

  694.     DMA_TCD0_SOFF = (int)&gpiosync.gpio_psor - (int)&gpiosync.gpio_pcor;

  695.     DMA_TCD0_SLAST = (ADDRESS_ARRAY_REGISTERS_TO_UPDATE * ((int)&ADDX_GPIO_CLEAR_REGISTER - (int)&ADDX_GPIO_SET_REGISTER));

  696.     DMA_TCD0_ATTR = DMA_TCD_ATTR_SSIZE(2) | DMA_TCD_ATTR_DSIZE(2);

  697.     // Destination Minor Loop Offset Enabled - transfer appropriate number of bytes per minor loop, and put DADDR back to original value when minor loop is complete

  698.     // Source Minor Loop Offset Enabled - source buffer is same size and offset as destination so values reset after each minor loop

  699.     DMA_TCD0_NBYTES_MLOFFYES = DMA_TCD_NBYTES_SMLOE | DMA_TCD_NBYTES_DMLOE |

  700.                                ((ADDRESS_ARRAY_REGISTERS_TO_UPDATE * ((int)&ADDX_GPIO_CLEAR_REGISTER - (int)&ADDX_GPIO_SET_REGISTER)) << 10) |

  701.                                (ADDRESS_ARRAY_REGISTERS_TO_UPDATE * sizeof(gpiosync.gpio_psor));

  702.     // start on higher value of two registers, and make offset decrement to avoid negative number in NBYTES_MLOFFYES (TODO: can switch order by masking negative offset)

  703.     DMA_TCD0_DADDR = &ADDX_GPIO_CLEAR_REGISTER;

  704.     // update destination address so the second update per minor loop is ADDX_GPIO_SET_REGISTER

  705.     DMA_TCD0_DOFF = (int)&ADDX_GPIO_SET_REGISTER - (int)&ADDX_GPIO_CLEAR_REGISTER;

  706.     DMA_TCD0_DLASTSGA = (ADDRESS_ARRAY_REGISTERS_TO_UPDATE * ((int)&ADDX_GPIO_CLEAR_REGISTER - (int)&ADDX_GPIO_SET_REGISTER));

  707.     // single major loop

  708.     DMA_TCD0_CITER_ELINKNO = 1;

  709.     DMA_TCD0_BITER_ELINKNO = 1;

  710.     // link channel 1, enable major channel-to-channel linking, don't clear enable on major loop complete

  711.     DMA_TCD0_CSR = (1 << 8) | (1 << 5);

  712.     DMAMUX0_CHCFG0 = DMAMUX_SOURCE_LATCH_RISING_EDGE | DMAMUX_ENABLE;

  713. 

  714.     // DMA channel #1 - copy address values from current position in array to buffer to temporarily hold row values for the next timer cycle

  715.     // only use single major loop, never disable channel

  716.     DMA_TCD1_SADDR = &matrixUpdateBlocks[0][0].addressValues;

  717.     DMA_TCD1_SOFF = sizeof(uint16_t);

  718.     DMA_TCD1_SLAST = sizeof(matrixUpdateBlock) - (ADDRESS_ARRAY_REGISTERS_TO_UPDATE * sizeof(uint16_t));

  719.     DMA_TCD1_ATTR = DMA_TCD_ATTR_SSIZE(1) | DMA_TCD_ATTR_DSIZE(1);

  720.     // 16-bit = 2 bytes transferred

  721.     // transfer two 16-bit values, reset destination address back after each minor loop

  722.     DMA_TCD1_NBYTES_MLOFFNO = (ADDRESS_ARRAY_REGISTERS_TO_UPDATE * sizeof(uint16_t));

  723.     // start with the register that's the highest location in memory and make offset decrement to avoid negative number in NBYTES_MLOFFYES register (TODO: can switch order by masking negative offset)

  724.     DMA_TCD1_DADDR = &gpiosync.gpio_pcor;

  725.     DMA_TCD1_DOFF = (int)&gpiosync.gpio_psor - (int)&gpiosync.gpio_pcor;

  726.     DMA_TCD1_DLASTSGA = (ADDRESS_ARRAY_REGISTERS_TO_UPDATE * ((int)&gpiosync.gpio_pcor - (int)&gpiosync.gpio_psor));

  727.     // no minor loop linking, single major loop, single minor loop, don't clear enable after major loop complete

  728.     DMA_TCD1_CITER_ELINKNO = 1;

  729.     DMA_TCD1_BITER_ELINKNO = 1;

  730.     DMA_TCD1_CSR = 0;

  731. 

  732.     // DMA channel #2 - on latch falling edge, load FTM1_CV1 and FTM1_MOD with with next values from current block

  733.     // only use single major loop, never disable channel

  734.     // link to channel 3 when complete

  735. #define TIMER_REGISTERS_TO_UPDATE   2

  736.     DMA_TCD2_SADDR = &matrixUpdateBlocks[0][0].timerValues.timer_oe;

  737.     DMA_TCD2_SOFF = sizeof(uint16_t);

  738.     DMA_TCD2_SLAST = sizeof(matrixUpdateBlock) - (TIMER_REGISTERS_TO_UPDATE * sizeof(uint16_t));

  739.     DMA_TCD2_ATTR = DMA_TCD_ATTR_SSIZE(1) | DMA_TCD_ATTR_DSIZE(1);

  740.     // 16-bit = 2 bytes transferred

  741.     DMA_TCD2_NBYTES_MLOFFNO = TIMER_REGISTERS_TO_UPDATE * sizeof(uint16_t);

  742.     DMA_TCD2_DADDR = &FTM1_C1V;

  743.     DMA_TCD2_DOFF = (int)&FTM1_MOD - (int)&FTM1_C1V;

  744.     DMA_TCD2_DLASTSGA = TIMER_REGISTERS_TO_UPDATE * ((int)&FTM1_C1V - (int)&FTM1_MOD);

  745.     // no minor loop linking, single major loop

  746.     DMA_TCD2_CITER_ELINKNO = 1;

  747.     DMA_TCD2_BITER_ELINKNO = 1;

  748.     // link channel 3, enable major channel-to-channel linking, don't clear enable after major loop complete

  749.     DMA_TCD2_CSR = (3 << 8) | (1 << 5);

  750.     DMAMUX0_CHCFG2 = DMAMUX_SOURCE_LATCH_FALLING_EDGE | DMAMUX_ENABLE;

  751. 

  752. #define DMA_TCD_MLOFF_MASK  (0x3FFFFC00)

  753. 

  754.     // DMA channel #3 - repeatedly load gpio_array into GPIOD_PDOR, stop and int on major loop complete

  755.     DMA_TCD3_SADDR = matrixUpdateData[0][0];

  756.     DMA_TCD3_SOFF = sizeof(matrixUpdateData[0][0]) / 2;

  757.     // SADDR will get updated by ISR, no need to set SLAST

  758.     DMA_TCD3_SLAST = 0;

  759.     DMA_TCD3_ATTR = DMA_TCD_ATTR_SSIZE(0) | DMA_TCD_ATTR_DSIZE(0);

  760.     // after each minor loop, set source to point back to the beginning of this set of data,

  761.     // but advance by 1 byte to get the next significant bits data

  762.     DMA_TCD3_NBYTES_MLOFFYES = DMA_TCD_NBYTES_SMLOE |

  763.                                (((1 - sizeof(matrixUpdateData[0])) << 10) & DMA_TCD_MLOFF_MASK) |

  764.                                (MATRIX_WIDTH * DMA_UPDATES_PER_CLOCK);

  765.     DMA_TCD3_DADDR = &GPIOD_PDOR;

  766.     DMA_TCD3_DOFF = 0;

  767.     DMA_TCD3_DLASTSGA = 0;

  768.     DMA_TCD3_CITER_ELINKNO = LATCHES_PER_ROW;

  769.     DMA_TCD3_BITER_ELINKNO = LATCHES_PER_ROW;

  770.     // int after major loop is complete

  771.     DMA_TCD3_CSR = DMA_TCD_CSR_INTMAJOR;

  772.     // for debugging - enable bandwidth control (space out GPIO updates so they can be seen easier on a low-bandwidth logic analyzer)

  773.     //DMA_TCD3_CSR |= (0x02 << 14);

  774. 

  775.     // enable a done interrupt when all DMA operations are complete

  776.     NVIC_ENABLE_IRQ(IRQ_DMA_CH3);

  777. 

  778.     // enable additional dma interrupt used as software interrupt

  779.     NVIC_SET_PRIORITY(IRQ_DMA_CH1, 0xFF); // 0xFF = lowest priority

  780.     NVIC_ENABLE_IRQ(IRQ_DMA_CH1);

  781. 

  782.     // enable channels 0, 1, 2, 3

  783.     DMA_ERQ = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3);

  784. 

  785.     // at the end after everything is set up: enable timer from system clock, with appropriate prescale

  786.     FTM1_SC = FTM_SC_CLKS(1) | FTM_SC_PS(LATCH_TIMER_PRESCALE);

  787. 

  788. 

  789. */

  790. 

  791. 

  792. };

  793. 

  794. // arrange the relative priority of 2 or more DMA channels

  795. void DMAPriorityOrder(DMAChannel &ch1, DMAChannel &ch2);

  796. void DMAPriorityOrder(DMAChannel &ch1, DMAChannel &ch2, DMAChannel &ch3);

  797. void DMAPriorityOrder(DMAChannel &ch1, DMAChannel &ch2, DMAChannel &ch3, DMAChannel &ch4);

  798. 

  799. 

  800. 

  801. extern "C" {

  802. #endif

  803. extern uint16_t dma_channel_allocated_mask;

  804. #ifdef __cplusplus

  805. }

  806. #endif

  807. 

  808. 

  809. 

  810. #endif