visus
/
teensy-cores
Observar 1
Favorito 0
Fork 0
Código Issues 0 Pull requests 0 Versões 0 Wiki Atividade
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
181 Commits
1 Branch
Tag: af89f7072e
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de af89f7072e
${ noResults }
teensy-cores/teensy3/DMAChannel.h

817 linhas
29KB
Original Anotar Histórico 

  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 <-- DmaSpi has adopted this scheme

  19. 

  20. #if defined(KINETISK)

  21. 

  22. #ifdef __cplusplus

  23. 

  24. #define DMACHANNEL_HAS_BEGIN

  25. #define DMACHANNEL_HAS_BOOLEAN_CTOR

  26. 

  27. class DMABaseClass {

  28. public:

  29. 	typedef struct __attribute__((packed)) {

  30. 		volatile const void * volatile SADDR;

  31. 		int16_t SOFF;

  32. 		union { uint16_t ATTR;

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

  34. 		union { uint32_t NBYTES; uint32_t NBYTES_MLNO;

  35. 			uint32_t NBYTES_MLOFFNO; uint32_t NBYTES_MLOFFYES; };

  36. 		int32_t SLAST;

  37. 		volatile void * volatile DADDR;

  38. 		int16_t DOFF;

  39. 		union { volatile uint16_t CITER;

  40. 			volatile uint16_t CITER_ELINKYES; volatile uint16_t CITER_ELINKNO; };

  41. 		int32_t DLASTSGA;

  42. 		volatile uint16_t CSR;

  43. 		union { volatile uint16_t BITER;

  44. 			volatile uint16_t BITER_ELINKYES; volatile uint16_t BITER_ELINKNO; };

  45. 	} TCD_t;

  46. 	TCD_t *TCD;

  47. 

  48. 	/***************************************/

  49. 	/**    Data Transfer                  **/

  50. 	/***************************************/

  51. 

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

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

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

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

  56. 		TCD->SADDR = &p;

  57. 		TCD->SOFF = 0;

  58. 		TCD->ATTR_SRC = 0;

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

  60. 		TCD->SLAST = 0;

  61. 	}

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

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

  64. 		TCD->SADDR = &p;

  65. 		TCD->SOFF = 0;

  66. 		TCD->ATTR_SRC = 1;

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

  68. 		TCD->SLAST = 0;

  69. 	}

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

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

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

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

  74. 		TCD->SADDR = &p;

  75. 		TCD->SOFF = 0;

  76. 		TCD->ATTR_SRC = 2;

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

  78. 		TCD->SLAST = 0;

  79. 	}

  80. 

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

  82. 	// buffer for transmitting data is used.

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

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

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

  86. 		TCD->SADDR = p;

  87. 		TCD->SOFF = 1;

  88. 		TCD->ATTR_SRC = 0;

  89. 		TCD->NBYTES = 1;

  90. 		TCD->SLAST = -len;

  91. 		TCD->BITER = len;

  92. 		TCD->CITER = len;

  93. 	}

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

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

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

  97. 		TCD->SADDR = p;

  98. 		TCD->SOFF = 2;

  99. 		TCD->ATTR_SRC = 1;

  100. 		TCD->NBYTES = 2;

  101. 		TCD->SLAST = -len;

  102. 		TCD->BITER = len / 2;

  103. 		TCD->CITER = len / 2;

  104. 	}

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

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

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

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

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

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

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

  112. 		TCD->SADDR = p;

  113. 		TCD->SOFF = 4;

  114. 		TCD->ATTR_SRC = 2;

  115. 		TCD->NBYTES = 4;

  116. 		TCD->SLAST = -len;

  117. 		TCD->BITER = len / 4;

  118. 		TCD->CITER = len / 4;

  119. 	}

  120. 

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

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

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

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

  125. 		TCD->SADDR = p;

  126. 		TCD->SOFF = 1;

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

  128. 		TCD->NBYTES = 1;

  129. 		TCD->SLAST = 0;

  130. 		TCD->BITER = len;

  131. 		TCD->CITER = len;

  132. 	}

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

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

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

  136. 		TCD->SADDR = p;

  137. 		TCD->SOFF = 2;

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

  139. 		TCD->NBYTES = 2;

  140. 		TCD->SLAST = 0;

  141. 		TCD->BITER = len / 2;

  142. 		TCD->CITER = len / 2;

  143. 	}

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

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

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

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

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

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

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

  151. 		TCD->SADDR = p;

  152. 		TCD->SOFF = 4;

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

  154. 		TCD->NBYTES = 4;

  155. 		TCD->SLAST = 0;

  156. 		TCD->BITER = len / 4;

  157. 		TCD->CITER = len / 4;

  158. 	}

  159. 

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

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

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

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

  164. 		TCD->DADDR = &p;

  165. 		TCD->DOFF = 0;

  166. 		TCD->ATTR_DST = 0;

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

  168. 		TCD->DLASTSGA = 0;

  169. 	}

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

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

  172. 		TCD->DADDR = &p;

  173. 		TCD->DOFF = 0;

  174. 		TCD->ATTR_DST = 1;

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

  176. 		TCD->DLASTSGA = 0;

  177. 	}

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

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

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

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

  182. 		TCD->DADDR = &p;

  183. 		TCD->DOFF = 0;

  184. 		TCD->ATTR_DST = 2;

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

  186. 		TCD->DLASTSGA = 0;

  187. 	}

  188. 

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

  190. 	// buffer for receiving data is used.

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

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

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

  194. 		TCD->DADDR = p;

  195. 		TCD->DOFF = 1;

  196. 		TCD->ATTR_DST = 0;

  197. 		TCD->NBYTES = 1;

  198. 		TCD->DLASTSGA = -len;

  199. 		TCD->BITER = len;

  200. 		TCD->CITER = len;

  201. 	}

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

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

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

  205. 		TCD->DADDR = p;

  206. 		TCD->DOFF = 2;

  207. 		TCD->ATTR_DST = 1;

  208. 		TCD->NBYTES = 2;

  209. 		TCD->DLASTSGA = -len;

  210. 		TCD->BITER = len / 2;

  211. 		TCD->CITER = len / 2;

  212. 	}

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

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

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

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

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

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

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

  220. 		TCD->DADDR = p;

  221. 		TCD->DOFF = 4;

  222. 		TCD->ATTR_DST = 2;

  223. 		TCD->NBYTES = 4;

  224. 		TCD->DLASTSGA = -len;

  225. 		TCD->BITER = len / 4;

  226. 		TCD->CITER = len / 4;

  227. 	}

  228. 

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

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

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

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

  233. 		TCD->DADDR = p;

  234. 		TCD->DOFF = 1;

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

  236. 		TCD->NBYTES = 1;

  237. 		TCD->DLASTSGA = 0;

  238. 		TCD->BITER = len;

  239. 		TCD->CITER = len;

  240. 	}

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

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

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

  244. 		TCD->DADDR = p;

  245. 		TCD->DOFF = 2;

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

  247. 		TCD->NBYTES = 2;

  248. 		TCD->DLASTSGA = 0;

  249. 		TCD->BITER = len / 2;

  250. 		TCD->CITER = len / 2;

  251. 	}

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

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

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

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

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

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

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

  259. 		TCD->DADDR = p;

  260. 		TCD->DOFF = 4;

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

  262. 		TCD->NBYTES = 4;

  263. 		TCD->DLASTSGA = 0;

  264. 		TCD->BITER = len / 4;

  265. 		TCD->CITER = len / 4;

  266. 	}

  267. 

  268. 	/*************************************************/

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

  270. 	/*************************************************/

  271. 

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

  273. 	void transferSize(unsigned int len) {

  274. 		if (len == 4) {

  275. 			TCD->NBYTES = 4;

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

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

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

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

  280. 			TCD->NBYTES = 2;

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

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

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

  284. 		} else {

  285. 			TCD->NBYTES = 1;

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

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

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

  289. 		}

  290. 	}

  291. 

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

  293. 	void transferCount(unsigned int len) {

  294. 		if (len > 32767) return;

  295. 		if (len >= 512) {

  296. 			TCD->BITER = len;

  297. 			TCD->CITER = len;

  298. 		} else {

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

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

  301. 		}

  302. 	}

  303. 

  304. 	/*************************************************/

  305. 	/**    Special Options / Features               **/

  306. 	/*************************************************/

  307. 

  308. 	void interruptAtCompletion(void) {

  309. 		TCD->CSR |= DMA_TCD_CSR_INTMAJOR;

  310. 	}

  311. 

  312. 	void interruptAtHalf(void) {

  313. 		TCD->CSR |= DMA_TCD_CSR_INTHALF;

  314. 	}

  315. 

  316. 	void disableOnCompletion(void) {

  317. 		TCD->CSR |= DMA_TCD_CSR_DREQ;

  318. 	}

  319. 

  320. 	void replaceSettingsOnCompletion(const DMABaseClass &settings) {

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

  322. 		TCD->CSR &= ~DMA_TCD_CSR_DONE;

  323. 		TCD->CSR |= DMA_TCD_CSR_ESG;

  324. 	}

  325. 

  326. protected:

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

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

  329. 	DMABaseClass() {}

  330. 

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

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

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

  334. 		uint32_t t1, t2, t3, t4;

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

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

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

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

  339. 	}

  340. };

  341. 

  342. 

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

  344. // applied to any DMA channel.

  345. 

  346. class DMASetting : public DMABaseClass {

  347. public:

  348. 	DMASetting() {

  349. 		TCD = &tcddata;

  350. 	}

  351. 	DMASetting(const DMASetting &c) {

  352. 		TCD = &tcddata;

  353. 		*this = c;

  354. 	}

  355. 	DMASetting(const DMABaseClass &c) {

  356. 		TCD = &tcddata;

  357. 		*this = c;

  358. 	}

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

  360. 		copy_tcd(TCD, rhs.TCD);

  361. 		return *this;

  362. 	}

  363. private:

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

  365. };

  366. 

  367. 

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

  369. 

  370. class DMAChannel : public DMABaseClass {

  371. public:

  372. 	/*************************************************/

  373. 	/**    Channel Allocation                       **/

  374. 	/*************************************************/

  375. 

  376. 	DMAChannel() {

  377. 		begin();

  378. 	}

  379. 	DMAChannel(const DMAChannel &c) {

  380. 		TCD = c.TCD;

  381. 		channel = c.channel;

  382. 	}

  383. 	DMAChannel(const DMASetting &c) {

  384. 		begin();

  385. 		copy_tcd(TCD, c.TCD);

  386. 	}

  387. 	DMAChannel(bool allocate) {

  388. 		if (allocate) begin();

  389. 	}

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

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

  392. 			release();

  393. 			TCD = rhs.TCD;

  394. 			channel = rhs.channel;

  395. 		}

  396. 		return *this;

  397. 	}

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

  399. 		copy_tcd(TCD, rhs.TCD);

  400. 		return *this;

  401. 	}

  402. 	~DMAChannel() {

  403. 		release();

  404. 	}

  405. 	void begin(bool force_initialization = false);

  406. private:

  407. 	void release(void);

  408. 

  409. public:

  410. 	/***************************************/

  411. 	/**    Triggering                     **/

  412. 	/***************************************/

  413. 

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

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

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

  417. 

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

  419. 	void triggerAtHardwareEvent(uint8_t source) {

  420. 		volatile uint8_t *mux;

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

  422. 		*mux = 0;

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

  424. 	}

  425. 

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

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

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

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

  430. 	void triggerAtTransfersOf(DMABaseClass &ch) {

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

  432. 		  | DMA_TCD_BITER_ELINKYES_LINKCH(channel) | DMA_TCD_BITER_ELINKYES_ELINK;

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

  434. 	}

  435. 

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

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

  438. 	void triggerAtCompletionOf(DMABaseClass &ch) {

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

  440. 		  | DMA_TCD_CSR_MAJORLINKCH(channel) | DMA_TCD_CSR_MAJORELINK;

  441. 	}

  442. 

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

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

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

  446. 	void triggerContinuously(void) {

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

  448. 		mux[channel] = 0;

  449. #if DMAMUX_NUM_SOURCE_ALWAYS >= DMA_NUM_CHANNELS

  450. 		mux[channel] = DMAMUX_SOURCE_ALWAYS0 + channel;	

  451. #else

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

  453. 		unsigned int i = DMAMUX_SOURCE_ALWAYS0;

  454. 		for (i = DMAMUX_SOURCE_ALWAYS0;

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

  456. 			unsigned int ch;

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

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

  459. 			}

  460. 			if (ch >= DMA_NUM_CHANNELS) {

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

  462. 				return;

  463. 			}

  464. 		}

  465. #endif

  466. 	}

  467. 

  468. 	// Manually trigger the DMA channel.

  469. 	void triggerManual(void) {

  470. 		DMA_SSRT = channel;

  471. 	}

  472. 

  473. 

  474. 	/***************************************/

  475. 	/**    Interrupts                     **/

  476. 	/***************************************/

  477. 

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

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

  480. 	// transfer is completed.

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

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

  483. 		NVIC_ENABLE_IRQ(IRQ_DMA_CH0 + channel);

  484. 	}

  485. 

  486. 	void detachInterrupt(void) {

  487. 		NVIC_DISABLE_IRQ(IRQ_DMA_CH0 + channel);

  488. 	}

  489. 

  490. 	void clearInterrupt(void) {

  491. 		DMA_CINT = channel;

  492. 	}

  493. 

  494. 

  495. 	/***************************************/

  496. 	/**    Enable / Disable               **/

  497. 	/***************************************/

  498. 

  499. 	void enable(void) {

  500. 		DMA_SERQ = channel;

  501. 	}

  502. 	void disable(void) {

  503. 		DMA_CERQ = channel;

  504. 	}

  505. 

  506. 	/***************************************/

  507. 	/**    Status                         **/

  508. 	/***************************************/

  509. 

  510. 	bool complete(void) {

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

  512. 		return false;

  513. 	}

  514. 	void clearComplete(void) {

  515. 		DMA_CDNE = channel;

  516. 	}

  517. 	bool error(void) {

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

  519. 		return false;

  520. 	}

  521. 	void clearError(void) {

  522. 		DMA_CERR = channel;

  523. 	}

  524. 	void * sourceAddress(void) {

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

  526. 	}

  527. 	void * destinationAddress(void) {

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

  529. 	}

  530. 

  531. 	/***************************************/

  532. 	/**    Direct Hardware Access         **/

  533. 	/***************************************/

  534. 

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

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

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

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

  539. 	uint8_t channel;

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

  541. 

  542. /* usage cases:

  543. 

  544. ************************

  545. OctoWS2811:

  546. ************************

  547. 

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

  549.         SIM_SCGC7 |= SIM_SCGC7_DMA;

  550.         SIM_SCGC6 |= SIM_SCGC6_DMAMUX;

  551.         DMA_CR = 0;

  552.         DMA_CERQ = 1;

  553.         DMA_CERQ = 2;

  554.         DMA_CERQ = 3;

  555. 

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

  557.          DMA_TCD1_SADDR = &ones;

  558.          DMA_TCD1_SOFF = 0;

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

  560.          DMA_TCD1_NBYTES_MLNO = 1;

  561.          DMA_TCD1_SLAST = 0;

  562.          DMA_TCD1_DADDR = &GPIOD_PSOR;

  563.          DMA_TCD1_DOFF = 0;

  564.          DMA_TCD1_CITER_ELINKNO = bufsize;

  565.          DMA_TCD1_DLASTSGA = 0;

  566.          DMA_TCD1_CSR = DMA_TCD_CSR_DREQ;

  567.          DMA_TCD1_BITER_ELINKNO = bufsize;

  568. 	dma1.source(ones);

  569. 	dma1.destination(GPIOD_PSOR);

  570. 	dma1.size(1);

  571. 	dma1.count(bufsize);

  572. 	dma1.disableOnCompletion();

  573. 

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

  575.          DMA_TCD2_SADDR = frameBuffer;

  576.          DMA_TCD2_SOFF = 1;

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

  578.          DMA_TCD2_NBYTES_MLNO = 1;

  579.          DMA_TCD2_SLAST = -bufsize;

  580.          DMA_TCD2_DADDR = &GPIOD_PDOR;

  581.          DMA_TCD2_DOFF = 0;

  582.          DMA_TCD2_CITER_ELINKNO = bufsize;

  583.          DMA_TCD2_DLASTSGA = 0;

  584.          DMA_TCD2_CSR = DMA_TCD_CSR_DREQ;

  585.          DMA_TCD2_BITER_ELINKNO = bufsize;

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

  587. 	dma2.destination(GPIOD_PDOR);

  588. 	dma2.size(1);

  589. 	dma2.count(bufsize);

  590. 	dma2.disableOnCompletion();

  591. 

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

  593.         DMA_TCD3_SADDR = &ones;

  594.         DMA_TCD3_SOFF = 0;

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

  596.         DMA_TCD3_NBYTES_MLNO = 1;

  597.         DMA_TCD3_SLAST = 0;

  598.         DMA_TCD3_DADDR = &GPIOD_PCOR;

  599.         DMA_TCD3_DOFF = 0;

  600.         DMA_TCD3_CITER_ELINKNO = bufsize;

  601.         DMA_TCD3_DLASTSGA = 0;

  602.         DMA_TCD3_CSR = DMA_TCD_CSR_DREQ | DMA_TCD_CSR_INTMAJOR;

  603.         DMA_TCD3_BITER_ELINKNO = bufsize;

  604. 	dma3.source(ones);

  605. 	dma3.destination(GPIOD_PCOR);

  606. 	dma3.size(1);

  607. 	dma3.count(bufsize);

  608. 	dma3.disableOnCompletion();

  609. 

  610. ************************

  611. Audio, DAC

  612. ************************

  613. 

  614.         DMA_CR = 0;

  615.         DMA_TCD4_SADDR = dac_buffer;

  616.         DMA_TCD4_SOFF = 2;

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

  618.         DMA_TCD4_NBYTES_MLNO = 2;

  619.         DMA_TCD4_SLAST = -sizeof(dac_buffer);

  620.         DMA_TCD4_DADDR = &DAC0_DAT0L;

  621.         DMA_TCD4_DOFF = 0;

  622.         DMA_TCD4_CITER_ELINKNO = sizeof(dac_buffer) / 2;

  623.         DMA_TCD4_DLASTSGA = 0;

  624.         DMA_TCD4_BITER_ELINKNO = sizeof(dac_buffer) / 2;

  625.         DMA_TCD4_CSR = DMA_TCD_CSR_INTHALF | DMA_TCD_CSR_INTMAJOR;

  626.         DMAMUX0_CHCFG4 = DMAMUX_DISABLE;

  627.         DMAMUX0_CHCFG4 = DMAMUX_SOURCE_PDB | DMAMUX_ENABLE;

  628. 

  629. ************************

  630. Audio, I2S

  631. ************************

  632. 

  633.         DMA_CR = 0;

  634.         DMA_TCD0_SADDR = i2s_tx_buffer;

  635.         DMA_TCD0_SOFF = 2;

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

  637.         DMA_TCD0_NBYTES_MLNO = 2;

  638.         DMA_TCD0_SLAST = -sizeof(i2s_tx_buffer);

  639.         DMA_TCD0_DADDR = &I2S0_TDR0;

  640.         DMA_TCD0_DOFF = 0;

  641.         DMA_TCD0_CITER_ELINKNO = sizeof(i2s_tx_buffer) / 2;

  642.         DMA_TCD0_DLASTSGA = 0;

  643.         DMA_TCD0_BITER_ELINKNO = sizeof(i2s_tx_buffer) / 2;

  644.         DMA_TCD0_CSR = DMA_TCD_CSR_INTHALF | DMA_TCD_CSR_INTMAJOR;

  645. 

  646.         DMAMUX0_CHCFG0 = DMAMUX_DISABLE;

  647.         DMAMUX0_CHCFG0 = DMAMUX_SOURCE_I2S0_TX | DMAMUX_ENABLE;

  648. 

  649. ************************

  650. ADC lib, Pedro Villanueva

  651. ************************

  652. 

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

  654. 

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

  656. 

  657.     *DMA_TCD_ATTR = DMA_TCD_ATTR_SSIZE(DMA_TCD_ATTR_SIZE_16BIT) |

  658.                   DMA_TCD_ATTR_DSIZE(DMA_TCD_ATTR_SIZE_16BIT) |

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

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

  661. 

  662.     *DMA_TCD_SADDR = ADC_RA; // source address

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

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

  665. 

  666.     *DMA_TCD_DADDR = elems; // destination address

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

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

  669. 

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

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

  672. 

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

  674. 

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

  676.     DMA_CINT = DMA_channel; // clear interrupts

  677. 

  678.     uint8_t DMAMUX_SOURCE_ADC = DMAMUX_SOURCE_ADC0;

  679.     if(ADC_number==1){

  680.         DMAMUX_SOURCE_ADC = DMAMUX_SOURCE_ADC1;

  681.     }

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

  683. 

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

  685.     NVIC_ENABLE_IRQ(IRQ_DMA_CH); // enable interrupts

  686. 

  687. ************************

  688. SmartMatrix

  689. ************************

  690. 

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

  692.     DMA_CR = 1 << 7;

  693. 

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

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

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

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

  698. #define ADDRESS_ARRAY_REGISTERS_TO_UPDATE   2

  699.     DMA_TCD0_SADDR = &gpiosync.gpio_pcor;

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

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

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

  703.     // 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

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

  705.     DMA_TCD0_NBYTES_MLOFFYES = DMA_TCD_NBYTES_SMLOE | DMA_TCD_NBYTES_DMLOE |

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

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

  708.     // 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)

  709.     DMA_TCD0_DADDR = &ADDX_GPIO_CLEAR_REGISTER;

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

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

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

  713.     // single major loop

  714.     DMA_TCD0_CITER_ELINKNO = 1;

  715.     DMA_TCD0_BITER_ELINKNO = 1;

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

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

  718.     DMAMUX0_CHCFG0 = DMAMUX_SOURCE_LATCH_RISING_EDGE | DMAMUX_ENABLE;

  719. 

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

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

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

  723.     DMA_TCD1_SOFF = sizeof(uint16_t);

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

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

  726.     // 16-bit = 2 bytes transferred

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

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

  729.     // 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)

  730.     DMA_TCD1_DADDR = &gpiosync.gpio_pcor;

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

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

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

  734.     DMA_TCD1_CITER_ELINKNO = 1;

  735.     DMA_TCD1_BITER_ELINKNO = 1;

  736.     DMA_TCD1_CSR = 0;

  737. 

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

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

  740.     // link to channel 3 when complete

  741. #define TIMER_REGISTERS_TO_UPDATE   2

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

  743.     DMA_TCD2_SOFF = sizeof(uint16_t);

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

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

  746.     // 16-bit = 2 bytes transferred

  747.     DMA_TCD2_NBYTES_MLOFFNO = TIMER_REGISTERS_TO_UPDATE * sizeof(uint16_t);

  748.     DMA_TCD2_DADDR = &FTM1_C1V;

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

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

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

  752.     DMA_TCD2_CITER_ELINKNO = 1;

  753.     DMA_TCD2_BITER_ELINKNO = 1;

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

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

  756.     DMAMUX0_CHCFG2 = DMAMUX_SOURCE_LATCH_FALLING_EDGE | DMAMUX_ENABLE;

  757. 

  758. #define DMA_TCD_MLOFF_MASK  (0x3FFFFC00)

  759. 

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

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

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

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

  764.     DMA_TCD3_SLAST = 0;

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

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

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

  768.     DMA_TCD3_NBYTES_MLOFFYES = DMA_TCD_NBYTES_SMLOE |

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

  770.                                (MATRIX_WIDTH * DMA_UPDATES_PER_CLOCK);

  771.     DMA_TCD3_DADDR = &GPIOD_PDOR;

  772.     DMA_TCD3_DOFF = 0;

  773.     DMA_TCD3_DLASTSGA = 0;

  774.     DMA_TCD3_CITER_ELINKNO = LATCHES_PER_ROW;

  775.     DMA_TCD3_BITER_ELINKNO = LATCHES_PER_ROW;

  776.     // int after major loop is complete

  777.     DMA_TCD3_CSR = DMA_TCD_CSR_INTMAJOR;

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

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

  780. 

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

  782.     NVIC_ENABLE_IRQ(IRQ_DMA_CH3);

  783. 

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

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

  786.     NVIC_ENABLE_IRQ(IRQ_DMA_CH1);

  787. 

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

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

  790. 

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

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

  793. 

  794. 

  795. */

  796. 

  797. 

  798. };

  799. 

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

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

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

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

  804. 

  805. 

  806. 

  807. extern "C" {

  808. #endif

  809. extern uint16_t dma_channel_allocated_mask;

  810. #ifdef __cplusplus

  811. }

  812. #endif

  813. 

  814. #endif // KINETISK

  815. 

  816. #endif