visus
/
framework-arduinoteensy-cxx20
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Commits
1 Branch
Tree: 8b2d08b377
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8b2d08b377'
${ noResults }
framework-arduinoteensy-cxx20/cores/teensy3/avr_emulation.h

2310 lines
73KB
Raw Blame History 

  1. /* Teensyduino Core Library

  2.  * http://www.pjrc.com/teensy/

  3.  * Copyright (c) 2017 PJRC.COM, LLC.

  4.  *

  5.  * Permission is hereby granted, free of charge, to any person obtaining

  6.  * a copy of this software and associated documentation files (the

  7.  * "Software"), to deal in the Software without restriction, including

  8.  * without limitation the rights to use, copy, modify, merge, publish,

  9.  * distribute, sublicense, and/or sell copies of the Software, and to

  10.  * permit persons to whom the Software is furnished to do so, subject to

  11.  * the following conditions:

  12.  *

  13.  * 1. The above copyright notice and this permission notice shall be

  14.  * included in all copies or substantial portions of the Software.

  15.  *

  16.  * 2. If the Software is incorporated into a build system that allows

  17.  * selection among a list of target devices, then similar target

  18.  * devices manufactured by PJRC.COM must be included in the list of

  19.  * target devices and selectable in the same manner.

  20.  *

  21.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

  22.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

  23.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

  24.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

  25.  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

  26.  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

  27.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  28.  * SOFTWARE.

  29.  */

  30. 

  31. #ifndef _avr_emulation_h_

  32. #define _avr_emulation_h_

  33. 

  34. #include "kinetis.h"

  35. #include "core_pins.h"

  36. #include "pins_arduino.h"

  37. 

  38. #ifdef __cplusplus

  39. 

  40. #define GPIO_BITBAND_ADDR(reg, bit) (((uint32_t)&(reg) - 0x40000000) * 32 + (bit) * 4 + 0x42000000)

  41. #define CONFIG_PULLUP (PORT_PCR_MUX(1) | PORT_PCR_PE | PORT_PCR_PS)

  42. #define CONFIG_NOPULLUP (PORT_PCR_MUX(1))

  43. 

  44. #if defined(KINETISK)

  45. // bitband addressing for atomic access to data direction register

  46. #define GPIO_SETBIT_ATOMIC(reg, bit) (*(uint32_t *)GPIO_BITBAND_ADDR((reg), (bit)) = 1)

  47. #define GPIO_CLRBIT_ATOMIC(reg, bit) (*(uint32_t *)GPIO_BITBAND_ADDR((reg), (bit)) = 0)

  48. #elif defined(KINETISL)

  49. // bit manipulation engine for atomic access to data direction register

  50. #define GPIO_SETBIT_ATOMIC(reg, bit) (*(uint32_t *)(((uint32_t)&(reg) - 0xF8000000) | 0x480FF000) = 1 << (bit))

  51. #define GPIO_CLRBIT_ATOMIC(reg, bit) (*(uint32_t *)(((uint32_t)&(reg) - 0xF8000000) | 0x440FF000) = ~(1 << (bit)))

  52. #endif

  53. 

  54. 

  55. class PORTDemulation

  56. {

  57. public:

  58. 	inline PORTDemulation & operator = (int val) __attribute__((always_inline)) {

  59. 		digitalWriteFast(0, (val & (1<<0)));

  60. 		if (!(CORE_PIN0_DDRREG & CORE_PIN0_BIT))

  61. 			CORE_PIN0_CONFIG = ((val & (1<<0)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  62. 		digitalWriteFast(1, (val & (1<<1)));

  63. 		if (!(CORE_PIN1_DDRREG & CORE_PIN1_BIT))

  64. 			CORE_PIN1_CONFIG = ((val & (1<<1)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  65. 		digitalWriteFast(2, (val & (1<<2)));

  66. 		if (!(CORE_PIN2_DDRREG & CORE_PIN2_BIT))

  67. 			CORE_PIN2_CONFIG = ((val & (1<<2)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  68. 		digitalWriteFast(3, (val & (1<<3)));

  69. 		if (!(CORE_PIN3_DDRREG & CORE_PIN3_BIT))

  70. 			CORE_PIN3_CONFIG = ((val & (1<<3)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  71. 		digitalWriteFast(4, (val & (1<<4)));

  72. 		if (!(CORE_PIN4_DDRREG & CORE_PIN4_BIT))

  73. 			CORE_PIN4_CONFIG = ((val & (1<<4)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  74. 		digitalWriteFast(5, (val & (1<<5)));

  75. 		if (!(CORE_PIN5_DDRREG & CORE_PIN5_BIT))

  76. 			CORE_PIN5_CONFIG = ((val & (1<<5)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  77. 		digitalWriteFast(6, (val & (1<<6)));

  78. 		if (!(CORE_PIN6_DDRREG & CORE_PIN6_BIT))

  79. 			CORE_PIN6_CONFIG = ((val & (1<<6)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  80. 		digitalWriteFast(7, (val & (1<<7)));

  81. 		if (!(CORE_PIN7_DDRREG & CORE_PIN7_BIT))

  82. 			CORE_PIN7_CONFIG = ((val & (1<<7)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  83. 		return *this;

  84. 	}

  85. 	inline PORTDemulation & operator |= (int val) __attribute__((always_inline)) {

  86. 		if (val & (1<<0)) {

  87. 			digitalWriteFast(0, HIGH);

  88. 			if (!(CORE_PIN0_DDRREG & CORE_PIN0_BIT)) CORE_PIN0_CONFIG = CONFIG_PULLUP;

  89. 		}

  90. 		if (val & (1<<1)) {

  91. 			digitalWriteFast(1, HIGH);

  92. 			if (!(CORE_PIN1_DDRREG & CORE_PIN1_BIT)) CORE_PIN1_CONFIG = CONFIG_PULLUP;

  93. 		}

  94. 		if (val & (1<<2)) {

  95. 			digitalWriteFast(2, HIGH);

  96. 			if (!(CORE_PIN2_DDRREG & CORE_PIN2_BIT)) CORE_PIN2_CONFIG = CONFIG_PULLUP;

  97. 		}

  98. 		if (val & (1<<3)) {

  99. 			digitalWriteFast(3, HIGH);

  100. 			if (!(CORE_PIN3_DDRREG & CORE_PIN3_BIT)) CORE_PIN3_CONFIG = CONFIG_PULLUP;

  101. 		}

  102. 		if (val & (1<<4)) {

  103. 			digitalWriteFast(4, HIGH);

  104. 			if (!(CORE_PIN4_DDRREG & CORE_PIN4_BIT)) CORE_PIN4_CONFIG = CONFIG_PULLUP;

  105. 		}

  106. 		if (val & (1<<5)) {

  107. 			digitalWriteFast(5, HIGH);

  108. 			if (!(CORE_PIN5_DDRREG & CORE_PIN5_BIT)) CORE_PIN5_CONFIG = CONFIG_PULLUP;

  109. 		}

  110. 		if (val & (1<<6)) {

  111. 			digitalWriteFast(6, HIGH);

  112. 			if (!(CORE_PIN6_DDRREG & CORE_PIN6_BIT)) CORE_PIN6_CONFIG = CONFIG_PULLUP;

  113. 		}

  114. 		if (val & (1<<7)) {

  115. 			digitalWriteFast(7, HIGH);

  116. 			if (!(CORE_PIN7_DDRREG & CORE_PIN7_BIT)) CORE_PIN7_CONFIG = CONFIG_PULLUP;

  117. 		}

  118. 		return *this;

  119. 	}

  120. 	inline PORTDemulation & operator &= (int val) __attribute__((always_inline)) {

  121. 		if (!(val & (1<<0))) {

  122. 			digitalWriteFast(0, LOW);

  123. 			if (!(CORE_PIN0_DDRREG & CORE_PIN0_BIT)) CORE_PIN0_CONFIG = CONFIG_NOPULLUP;

  124. 		}

  125. 		if (!(val & (1<<1))) {

  126. 			digitalWriteFast(1, LOW);

  127. 			if (!(CORE_PIN1_DDRREG & CORE_PIN1_BIT)) CORE_PIN1_CONFIG = CONFIG_NOPULLUP;

  128. 		}

  129. 		if (!(val & (1<<2))) {

  130. 			digitalWriteFast(2, LOW);

  131. 			if (!(CORE_PIN2_DDRREG & CORE_PIN2_BIT)) CORE_PIN2_CONFIG = CONFIG_NOPULLUP;

  132. 		}

  133. 		if (!(val & (1<<3))) {

  134. 			digitalWriteFast(3, LOW);

  135. 			if (!(CORE_PIN3_DDRREG & CORE_PIN3_BIT)) CORE_PIN3_CONFIG = CONFIG_NOPULLUP;

  136. 		}

  137. 		if (!(val & (1<<4))) {

  138. 			digitalWriteFast(4, LOW);

  139. 			if (!(CORE_PIN4_DDRREG & CORE_PIN4_BIT)) CORE_PIN4_CONFIG = CONFIG_NOPULLUP;

  140. 		}

  141. 		if (!(val & (1<<5))) {

  142. 			digitalWriteFast(5, LOW);

  143. 			if (!(CORE_PIN5_DDRREG & CORE_PIN5_BIT)) CORE_PIN5_CONFIG = CONFIG_NOPULLUP;

  144. 		}

  145. 		if (!(val & (1<<6))) {

  146. 			digitalWriteFast(6, LOW);

  147. 			if (!(CORE_PIN6_DDRREG & CORE_PIN6_BIT)) CORE_PIN6_CONFIG = CONFIG_NOPULLUP;

  148. 		}

  149. 		if (!(val & (1<<7))) {

  150. 			digitalWriteFast(7, LOW);

  151. 			if (!(CORE_PIN7_DDRREG & CORE_PIN7_BIT)) CORE_PIN7_CONFIG = CONFIG_NOPULLUP;

  152. 		}

  153. 		return *this;

  154. 	}

  155. };

  156. extern PORTDemulation PORTD;

  157. 

  158. class PINDemulation

  159. {

  160. public:

  161. 	inline int operator & (int val) const __attribute__((always_inline)) {

  162. 		int ret = 0;

  163. 		if ((val & (1<<0)) && digitalReadFast(0)) ret |= (1<<0);

  164. 		if ((val & (1<<1)) && digitalReadFast(1)) ret |= (1<<1);

  165. 		if ((val & (1<<2)) && digitalReadFast(2)) ret |= (1<<2);

  166. 		if ((val & (1<<3)) && digitalReadFast(3)) ret |= (1<<3);

  167. 		if ((val & (1<<4)) && digitalReadFast(4)) ret |= (1<<4);

  168. 		if ((val & (1<<5)) && digitalReadFast(5)) ret |= (1<<5);

  169. 		if ((val & (1<<6)) && digitalReadFast(6)) ret |= (1<<6);

  170. 		if ((val & (1<<7)) && digitalReadFast(7)) ret |= (1<<7);

  171. 		return ret;

  172. 	}

  173. 	operator int () const __attribute__((always_inline)) {

  174. 		int ret = 0;

  175. 		if (digitalReadFast(0)) ret |= (1<<0);

  176. 		if (digitalReadFast(1)) ret |= (1<<1);

  177. 		if (digitalReadFast(2)) ret |= (1<<2);

  178. 		if (digitalReadFast(3)) ret |= (1<<3);

  179. 		if (digitalReadFast(4)) ret |= (1<<4);

  180. 		if (digitalReadFast(5)) ret |= (1<<5);

  181. 		if (digitalReadFast(6)) ret |= (1<<6);

  182. 		if (digitalReadFast(7)) ret |= (1<<7);

  183. 		return ret;

  184. 	}

  185. };

  186. extern PINDemulation PIND;

  187. 

  188. class DDRDemulation

  189. {

  190. public:

  191. 	inline DDRDemulation & operator = (int val) __attribute__((always_inline)) {

  192. 		if (val & (1<<0)) set0(); else clr0();

  193. 		if (val & (1<<1)) set1(); else clr1();

  194. 		if (val & (1<<2)) set2(); else clr2();

  195. 		if (val & (1<<3)) set3(); else clr3();

  196. 		if (val & (1<<4)) set4(); else clr4();

  197. 		if (val & (1<<5)) set5(); else clr5();

  198. 		if (val & (1<<6)) set6(); else clr6();

  199. 		if (val & (1<<7)) set7(); else clr7();

  200. 		return *this;

  201. 	}

  202. 	inline DDRDemulation & operator |= (int val) __attribute__((always_inline)) {

  203. 		if (val & (1<<0)) set0();

  204. 		if (val & (1<<1)) set1();

  205. 		if (val & (1<<2)) set2();

  206. 		if (val & (1<<3)) set3();

  207. 		if (val & (1<<4)) set4();

  208. 		if (val & (1<<5)) set5();

  209. 		if (val & (1<<6)) set6();

  210. 		if (val & (1<<7)) set7();

  211. 		return *this;

  212. 	}

  213. 	inline DDRDemulation & operator &= (int val) __attribute__((always_inline)) {

  214. 		if (!(val & (1<<0))) clr0();

  215. 		if (!(val & (1<<1))) clr1();

  216. 		if (!(val & (1<<2))) clr2();

  217. 		if (!(val & (1<<3))) clr3();

  218. 		if (!(val & (1<<4))) clr4();

  219. 		if (!(val & (1<<5))) clr5();

  220. 		if (!(val & (1<<6))) clr6();

  221. 		if (!(val & (1<<7))) clr7();

  222. 		return *this;

  223. 	}

  224. private:

  225. 	inline void set0() __attribute__((always_inline)) {

  226. 		GPIO_SETBIT_ATOMIC(CORE_PIN0_DDRREG, CORE_PIN0_BIT);

  227. 		CORE_PIN0_CONFIG = CONFIG_PULLUP;

  228. 	}

  229. 	inline void set1() __attribute__((always_inline)) {

  230. 		GPIO_SETBIT_ATOMIC(CORE_PIN1_DDRREG, CORE_PIN1_BIT);

  231. 		CORE_PIN1_CONFIG = CONFIG_PULLUP;

  232. 	}

  233. 	inline void set2() __attribute__((always_inline)) {

  234. 		GPIO_SETBIT_ATOMIC(CORE_PIN2_DDRREG, CORE_PIN2_BIT);

  235. 		CORE_PIN2_CONFIG = CONFIG_PULLUP;

  236. 	}

  237. 	inline void set3() __attribute__((always_inline)) {

  238. 		GPIO_SETBIT_ATOMIC(CORE_PIN3_DDRREG, CORE_PIN3_BIT);

  239. 		CORE_PIN3_CONFIG = CONFIG_PULLUP;

  240. 	}

  241. 	inline void set4() __attribute__((always_inline)) {

  242. 		GPIO_SETBIT_ATOMIC(CORE_PIN4_DDRREG, CORE_PIN4_BIT);

  243. 		CORE_PIN4_CONFIG = CONFIG_PULLUP;

  244. 	}

  245. 	inline void set5() __attribute__((always_inline)) {

  246. 		GPIO_SETBIT_ATOMIC(CORE_PIN5_DDRREG, CORE_PIN5_BIT);

  247. 		CORE_PIN5_CONFIG = CONFIG_PULLUP;

  248. 	}

  249. 	inline void set6() __attribute__((always_inline)) {

  250. 		GPIO_SETBIT_ATOMIC(CORE_PIN6_DDRREG, CORE_PIN6_BIT);

  251. 		CORE_PIN6_CONFIG = CONFIG_PULLUP;

  252. 	}

  253. 	inline void set7() __attribute__((always_inline)) {

  254. 		GPIO_SETBIT_ATOMIC(CORE_PIN7_DDRREG, CORE_PIN7_BIT);

  255. 		CORE_PIN7_CONFIG = CONFIG_PULLUP;

  256. 	}

  257. 	inline void clr0() __attribute__((always_inline)) {

  258. 		CORE_PIN0_CONFIG = ((CORE_PIN0_PORTREG & CORE_PIN0_BITMASK)

  259. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  260. 		GPIO_CLRBIT_ATOMIC(CORE_PIN0_DDRREG, CORE_PIN0_BIT);

  261. 	}

  262. 	inline void clr1() __attribute__((always_inline)) {

  263. 		CORE_PIN1_CONFIG = ((CORE_PIN1_PORTREG & CORE_PIN1_BITMASK)

  264. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  265. 		GPIO_CLRBIT_ATOMIC(CORE_PIN1_DDRREG, CORE_PIN1_BIT);

  266. 	}

  267. 	inline void clr2() __attribute__((always_inline)) {

  268. 		CORE_PIN2_CONFIG = ((CORE_PIN2_PORTREG & CORE_PIN2_BITMASK)

  269. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  270. 		GPIO_CLRBIT_ATOMIC(CORE_PIN2_DDRREG, CORE_PIN2_BIT);

  271. 	}

  272. 	inline void clr3() __attribute__((always_inline)) {

  273. 		CORE_PIN3_CONFIG = ((CORE_PIN3_PORTREG & CORE_PIN3_BITMASK)

  274. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  275. 		GPIO_CLRBIT_ATOMIC(CORE_PIN3_DDRREG, CORE_PIN3_BIT);

  276. 	}

  277. 	inline void clr4() __attribute__((always_inline)) {

  278. 		CORE_PIN4_CONFIG = ((CORE_PIN4_PORTREG & CORE_PIN4_BITMASK)

  279. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  280. 		GPIO_CLRBIT_ATOMIC(CORE_PIN4_DDRREG, CORE_PIN4_BIT);

  281. 	}

  282. 	inline void clr5() __attribute__((always_inline)) {

  283. 		CORE_PIN5_CONFIG = ((CORE_PIN5_PORTREG & CORE_PIN5_BITMASK)

  284. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  285. 		GPIO_CLRBIT_ATOMIC(CORE_PIN5_DDRREG, CORE_PIN5_BIT);

  286. 	}

  287. 	inline void clr6() __attribute__((always_inline)) {

  288. 		CORE_PIN6_CONFIG = ((CORE_PIN6_PORTREG & CORE_PIN6_BITMASK)

  289. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  290. 		GPIO_CLRBIT_ATOMIC(CORE_PIN6_DDRREG, CORE_PIN6_BIT);

  291. 	}

  292. 	inline void clr7() __attribute__((always_inline)) {

  293. 		CORE_PIN7_CONFIG = ((CORE_PIN7_PORTREG & CORE_PIN7_BITMASK)

  294. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  295. 		GPIO_CLRBIT_ATOMIC(CORE_PIN7_DDRREG, CORE_PIN7_BIT);

  296. 	}

  297. };

  298. 

  299. extern DDRDemulation DDRD;

  300. 

  301. 

  302. 

  303. 

  304. 

  305. 

  306. class PORTBemulation

  307. {

  308. public:

  309. 	inline PORTBemulation & operator = (int val) __attribute__((always_inline)) {

  310. 		digitalWriteFast(8, (val & (1<<0)));

  311. 		if (!(CORE_PIN8_DDRREG & CORE_PIN8_BIT))

  312. 			CORE_PIN8_CONFIG = ((val & (1<<0)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  313. 		digitalWriteFast(9, (val & (1<<1)));

  314. 		if (!(CORE_PIN9_DDRREG & CORE_PIN9_BIT))

  315. 			CORE_PIN9_CONFIG = ((val & (1<<1)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  316. 		digitalWriteFast(10, (val & (1<<2)));

  317. 		if (!(CORE_PIN10_DDRREG & CORE_PIN10_BIT))

  318. 			CORE_PIN10_CONFIG = ((val & (1<<2)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  319. 		digitalWriteFast(11, (val & (1<<3)));

  320. 		if (!(CORE_PIN11_DDRREG & CORE_PIN11_BIT))

  321. 			CORE_PIN11_CONFIG = ((val & (1<<3)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  322. 		digitalWriteFast(12, (val & (1<<4)));

  323. 		if (!(CORE_PIN12_DDRREG & CORE_PIN12_BIT))

  324. 			CORE_PIN12_CONFIG = ((val & (1<<4)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  325. 		digitalWriteFast(13, (val & (1<<5)));

  326. 		if (!(CORE_PIN13_DDRREG & CORE_PIN13_BIT))

  327. 			CORE_PIN13_CONFIG = ((val & (1<<5)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  328. 		return *this;

  329. 	}

  330. 	inline PORTBemulation & operator |= (int val) __attribute__((always_inline)) {

  331. 		if (val & (1<<0)) {

  332. 			digitalWriteFast(8, HIGH);

  333. 			if (!(CORE_PIN7_DDRREG & CORE_PIN7_BIT)) CORE_PIN8_CONFIG = CONFIG_PULLUP;

  334. 		}

  335. 		if (val & (1<<1)) {

  336. 			digitalWriteFast(9, HIGH);

  337. 			if (!(CORE_PIN7_DDRREG & CORE_PIN7_BIT)) CORE_PIN9_CONFIG = CONFIG_PULLUP;

  338. 		}

  339. 		if (val & (1<<2)) {

  340. 			digitalWriteFast(10, HIGH);

  341. 			if (!(CORE_PIN10_DDRREG & CORE_PIN10_BIT)) CORE_PIN10_CONFIG = CONFIG_PULLUP;

  342. 		}

  343. 		if (val & (1<<3)) {

  344. 			digitalWriteFast(11, HIGH);

  345. 			if (!(CORE_PIN11_DDRREG & CORE_PIN11_BIT)) CORE_PIN11_CONFIG = CONFIG_PULLUP;

  346. 		}

  347. 		if (val & (1<<4)) {

  348. 			digitalWriteFast(12, HIGH);

  349. 			if (!(CORE_PIN12_DDRREG & CORE_PIN12_BIT)) CORE_PIN12_CONFIG = CONFIG_PULLUP;

  350. 		}

  351. 		if (val & (1<<5)) {

  352. 			digitalWriteFast(13, HIGH);

  353. 			if (!(CORE_PIN13_DDRREG & CORE_PIN13_BIT)) CORE_PIN13_CONFIG = CONFIG_PULLUP;

  354. 		}

  355. 		return *this;

  356. 	}

  357. 	inline PORTBemulation & operator &= (int val) __attribute__((always_inline)) {

  358. 		if (!(val & (1<<0))) {

  359. 			digitalWriteFast(8, LOW);

  360. 			if (!(CORE_PIN8_DDRREG & CORE_PIN8_BIT)) CORE_PIN8_CONFIG = CONFIG_NOPULLUP;

  361. 		}

  362. 		if (!(val & (1<<1))) {

  363. 			digitalWriteFast(9, LOW);

  364. 			if (!(CORE_PIN9_DDRREG & CORE_PIN9_BIT)) CORE_PIN9_CONFIG = CONFIG_NOPULLUP;

  365. 		}

  366. 		if (!(val & (1<<2))) {

  367. 			digitalWriteFast(10, LOW);

  368. 			if (!(CORE_PIN10_DDRREG & CORE_PIN10_BIT)) CORE_PIN10_CONFIG = CONFIG_NOPULLUP;

  369. 		}

  370. 		if (!(val & (1<<3))) {

  371. 			digitalWriteFast(11, LOW);

  372. 			if (!(CORE_PIN11_DDRREG & CORE_PIN11_BIT)) CORE_PIN11_CONFIG = CONFIG_NOPULLUP;

  373. 		}

  374. 		if (!(val & (1<<4))) {

  375. 			digitalWriteFast(12, LOW);

  376. 			if (!(CORE_PIN12_DDRREG & CORE_PIN12_BIT)) CORE_PIN12_CONFIG = CONFIG_NOPULLUP;

  377. 		}

  378. 		if (!(val & (1<<5))) {

  379. 			digitalWriteFast(13, LOW);

  380. 			if (!(CORE_PIN13_DDRREG & CORE_PIN13_BIT)) CORE_PIN13_CONFIG = CONFIG_NOPULLUP;

  381. 		}

  382. 		return *this;

  383. 	}

  384. };

  385. extern PORTBemulation PORTB;

  386. 

  387. class PINBemulation

  388. {

  389. public:

  390. 	inline int operator & (int val) const __attribute__((always_inline)) {

  391. 		int ret = 0;

  392. 		if ((val & (1<<0)) && digitalReadFast(8)) ret |= (1<<0);

  393. 		if ((val & (1<<1)) && digitalReadFast(9)) ret |= (1<<1);

  394. 		if ((val & (1<<2)) && digitalReadFast(10)) ret |= (1<<2);

  395. 		if ((val & (1<<3)) && digitalReadFast(11)) ret |= (1<<3);

  396. 		if ((val & (1<<4)) && digitalReadFast(12)) ret |= (1<<4);

  397. 		if ((val & (1<<5)) && digitalReadFast(13)) ret |= (1<<5);

  398. 		return ret;

  399. 	}

  400. 	operator int () const __attribute__((always_inline)) {

  401. 		int ret = 0;

  402. 		if (digitalReadFast(8)) ret |= (1<<0);

  403. 		if (digitalReadFast(9)) ret |= (1<<1);

  404. 		if (digitalReadFast(10)) ret |= (1<<2);

  405. 		if (digitalReadFast(11)) ret |= (1<<3);

  406. 		if (digitalReadFast(12)) ret |= (1<<4);

  407. 		if (digitalReadFast(13)) ret |= (1<<5);

  408. 		return ret;

  409. 	}

  410. };

  411. extern PINBemulation PINB;

  412. 

  413. class DDRBemulation

  414. {

  415. public:

  416. 	inline DDRBemulation & operator = (int val) __attribute__((always_inline)) {

  417. 		if (val & (1<<0)) set0(); else clr0();

  418. 		if (val & (1<<1)) set1(); else clr1();

  419. 		if (val & (1<<2)) set2(); else clr2();

  420. 		if (val & (1<<3)) set3(); else clr3();

  421. 		if (val & (1<<4)) set4(); else clr4();

  422. 		if (val & (1<<5)) set5(); else clr5();

  423. 		return *this;

  424. 	}

  425. 	inline DDRBemulation & operator |= (int val) __attribute__((always_inline)) {

  426. 		if (val & (1<<0)) set0();

  427. 		if (val & (1<<1)) set1();

  428. 		if (val & (1<<2)) set2();

  429. 		if (val & (1<<3)) set3();

  430. 		if (val & (1<<4)) set4();

  431. 		if (val & (1<<5)) set5();

  432. 		return *this;

  433. 	}

  434. 	inline DDRBemulation & operator &= (int val) __attribute__((always_inline)) {

  435. 		if (!(val & (1<<0))) clr0();

  436. 		if (!(val & (1<<1))) clr1();

  437. 		if (!(val & (1<<2))) clr2();

  438. 		if (!(val & (1<<3))) clr3();

  439. 		if (!(val & (1<<4))) clr4();

  440. 		if (!(val & (1<<5))) clr5();

  441. 		return *this;

  442. 	}

  443. private:

  444. 	inline void set0() __attribute__((always_inline)) {

  445. 		GPIO_SETBIT_ATOMIC(CORE_PIN8_DDRREG, CORE_PIN8_BIT);

  446. 		CORE_PIN8_CONFIG = CONFIG_PULLUP;

  447. 	}

  448. 	inline void set1() __attribute__((always_inline)) {

  449. 		GPIO_SETBIT_ATOMIC(CORE_PIN9_DDRREG, CORE_PIN9_BIT);

  450. 		CORE_PIN9_CONFIG = CONFIG_PULLUP;

  451. 	}

  452. 	inline void set2() __attribute__((always_inline)) {

  453. 		GPIO_SETBIT_ATOMIC(CORE_PIN10_DDRREG, CORE_PIN10_BIT);

  454. 		CORE_PIN10_CONFIG = CONFIG_PULLUP;

  455. 	}

  456. 	inline void set3() __attribute__((always_inline)) {

  457. 		GPIO_SETBIT_ATOMIC(CORE_PIN11_DDRREG, CORE_PIN11_BIT);

  458. 		CORE_PIN11_CONFIG = CONFIG_PULLUP;

  459. 	}

  460. 	inline void set4() __attribute__((always_inline)) {

  461. 		GPIO_SETBIT_ATOMIC(CORE_PIN12_DDRREG, CORE_PIN12_BIT);

  462. 		CORE_PIN12_CONFIG = CONFIG_PULLUP;

  463. 	}

  464. 	inline void set5() __attribute__((always_inline)) {

  465. 		GPIO_SETBIT_ATOMIC(CORE_PIN13_DDRREG, CORE_PIN13_BIT);

  466. 		CORE_PIN13_CONFIG = CONFIG_PULLUP;

  467. 	}

  468. 	inline void clr0() __attribute__((always_inline)) {

  469. 		CORE_PIN8_CONFIG = ((CORE_PIN8_PORTREG & CORE_PIN8_BITMASK)

  470. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  471. 		GPIO_CLRBIT_ATOMIC(CORE_PIN8_DDRREG, CORE_PIN8_BIT);

  472. 	}

  473. 	inline void clr1() __attribute__((always_inline)) {

  474. 		CORE_PIN9_CONFIG = ((CORE_PIN9_PORTREG & CORE_PIN9_BITMASK)

  475. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  476. 		GPIO_CLRBIT_ATOMIC(CORE_PIN9_DDRREG, CORE_PIN9_BIT);

  477. 	}

  478. 	inline void clr2() __attribute__((always_inline)) {

  479. 		CORE_PIN10_CONFIG = ((CORE_PIN10_PORTREG & CORE_PIN10_BITMASK)

  480. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  481. 		GPIO_CLRBIT_ATOMIC(CORE_PIN10_DDRREG, CORE_PIN10_BIT);

  482. 	}

  483. 	inline void clr3() __attribute__((always_inline)) {

  484. 		CORE_PIN11_CONFIG = ((CORE_PIN11_PORTREG & CORE_PIN11_BITMASK)

  485. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  486. 		GPIO_CLRBIT_ATOMIC(CORE_PIN11_DDRREG, CORE_PIN11_BIT);

  487. 	}

  488. 	inline void clr4() __attribute__((always_inline)) {

  489. 		CORE_PIN12_CONFIG = ((CORE_PIN12_PORTREG & CORE_PIN12_BITMASK)

  490. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  491. 		GPIO_CLRBIT_ATOMIC(CORE_PIN12_DDRREG, CORE_PIN12_BIT);

  492. 	}

  493. 	inline void clr5() __attribute__((always_inline)) {

  494. 		CORE_PIN13_CONFIG = ((CORE_PIN13_PORTREG & CORE_PIN13_BITMASK)

  495. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  496. 		GPIO_CLRBIT_ATOMIC(CORE_PIN13_DDRREG, CORE_PIN13_BIT);

  497. 	}

  498. };

  499. 

  500. extern DDRBemulation DDRB;

  501. 

  502. 

  503. 

  504. 

  505. 

  506. 

  507. class PORTCemulation

  508. {

  509. public:

  510. 	inline PORTCemulation & operator = (int val) __attribute__((always_inline)) {

  511. 		digitalWriteFast(14, (val & (1<<0)));

  512. 		if (!(CORE_PIN14_DDRREG & CORE_PIN14_BIT))

  513. 			CORE_PIN14_CONFIG = ((val & (1<<0)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  514. 		digitalWriteFast(15, (val & (1<<1)));

  515. 		if (!(CORE_PIN15_DDRREG & CORE_PIN15_BIT))

  516. 			CORE_PIN15_CONFIG = ((val & (1<<1)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  517. 		digitalWriteFast(16, (val & (1<<2)));

  518. 		if (!(CORE_PIN16_DDRREG & CORE_PIN16_BIT))

  519. 			CORE_PIN16_CONFIG = ((val & (1<<2)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  520. 		digitalWriteFast(17, (val & (1<<3)));

  521. 		if (!(CORE_PIN17_DDRREG & CORE_PIN17_BIT))

  522. 			CORE_PIN17_CONFIG = ((val & (1<<3)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  523. 		digitalWriteFast(18, (val & (1<<4)));

  524. 		if (!(CORE_PIN18_DDRREG & CORE_PIN18_BIT))

  525. 			CORE_PIN18_CONFIG = ((val & (1<<4)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  526. 		digitalWriteFast(19, (val & (1<<5)));

  527. 		if (!(CORE_PIN19_DDRREG & CORE_PIN19_BIT))

  528. 			CORE_PIN19_CONFIG = ((val & (1<<5)) ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  529. 		return *this;

  530. 	}

  531. 	inline PORTCemulation & operator |= (int val) __attribute__((always_inline)) {

  532. 		if (val & (1<<0)) {

  533. 			digitalWriteFast(14, HIGH);

  534. 			if (!(CORE_PIN14_DDRREG & CORE_PIN14_BIT)) CORE_PIN14_CONFIG = CONFIG_PULLUP;

  535. 		}

  536. 		if (val & (1<<1)) {

  537. 			digitalWriteFast(15, HIGH);

  538. 			if (!(CORE_PIN15_DDRREG & CORE_PIN15_BIT)) CORE_PIN15_CONFIG = CONFIG_PULLUP;

  539. 		}

  540. 		if (val & (1<<2)) {

  541. 			digitalWriteFast(16, HIGH);

  542. 			if (!(CORE_PIN16_DDRREG & CORE_PIN16_BIT)) CORE_PIN16_CONFIG = CONFIG_PULLUP;

  543. 		}

  544. 		if (val & (1<<3)) {

  545. 			digitalWriteFast(17, HIGH);

  546. 			if (!(CORE_PIN17_DDRREG & CORE_PIN17_BIT)) CORE_PIN17_CONFIG = CONFIG_PULLUP;

  547. 		}

  548. 		if (val & (1<<4)) {

  549. 			digitalWriteFast(18, HIGH);

  550. 			if (!(CORE_PIN18_DDRREG & CORE_PIN18_BIT)) CORE_PIN18_CONFIG = CONFIG_PULLUP;

  551. 		}

  552. 		if (val & (1<<5)) {

  553. 			digitalWriteFast(19, HIGH);

  554. 			if (!(CORE_PIN19_DDRREG & CORE_PIN19_BIT)) CORE_PIN19_CONFIG = CONFIG_PULLUP;

  555. 		}

  556. 		return *this;

  557. 	}

  558. 	inline PORTCemulation & operator &= (int val) __attribute__((always_inline)) {

  559. 		if (!(val & (1<<0))) {

  560. 			digitalWriteFast(14, LOW);

  561. 			if (!(CORE_PIN14_DDRREG & CORE_PIN14_BIT)) CORE_PIN14_CONFIG = CONFIG_NOPULLUP;

  562. 		}

  563. 		if (!(val & (1<<1))) {

  564. 			digitalWriteFast(15, LOW);

  565. 			if (!(CORE_PIN15_DDRREG & CORE_PIN15_BIT)) CORE_PIN15_CONFIG = CONFIG_NOPULLUP;

  566. 		}

  567. 		if (!(val & (1<<2))) {

  568. 			digitalWriteFast(16, LOW);

  569. 			if (!(CORE_PIN16_DDRREG & CORE_PIN16_BIT)) CORE_PIN16_CONFIG = CONFIG_NOPULLUP;

  570. 		}

  571. 		if (!(val & (1<<3))) {

  572. 			digitalWriteFast(17, LOW);

  573. 			if (!(CORE_PIN17_DDRREG & CORE_PIN17_BIT)) CORE_PIN17_CONFIG = CONFIG_NOPULLUP;

  574. 		}

  575. 		if (!(val & (1<<4))) {

  576. 			digitalWriteFast(18, LOW);

  577. 			if (!(CORE_PIN18_DDRREG & CORE_PIN18_BIT)) CORE_PIN18_CONFIG = CONFIG_NOPULLUP;

  578. 		}

  579. 		if (!(val & (1<<5))) {

  580. 			digitalWriteFast(19, LOW);

  581. 			if (!(CORE_PIN19_DDRREG & CORE_PIN19_BIT)) CORE_PIN19_CONFIG = CONFIG_NOPULLUP;

  582. 		}

  583. 		return *this;

  584. 	}

  585. };

  586. extern PORTCemulation PORTC;

  587. 

  588. class PINCemulation

  589. {

  590. public:

  591. 	inline int operator & (int val) const __attribute__((always_inline)) {

  592. 		int ret = 0;

  593. 		if ((val & (1<<0)) && digitalReadFast(14)) ret |= (1<<0);

  594. 		if ((val & (1<<1)) && digitalReadFast(15)) ret |= (1<<1);

  595. 		if ((val & (1<<2)) && digitalReadFast(16)) ret |= (1<<2);

  596. 		if ((val & (1<<3)) && digitalReadFast(17)) ret |= (1<<3);

  597. 		if ((val & (1<<4)) && digitalReadFast(18)) ret |= (1<<4);

  598. 		if ((val & (1<<5)) && digitalReadFast(19)) ret |= (1<<5);

  599. 		return ret;

  600. 	}

  601. 	operator int () const __attribute__((always_inline)) {

  602. 		int ret = 0;

  603. 		if (digitalReadFast(14)) ret |= (1<<0);

  604. 		if (digitalReadFast(15)) ret |= (1<<1);

  605. 		if (digitalReadFast(16)) ret |= (1<<2);

  606. 		if (digitalReadFast(17)) ret |= (1<<3);

  607. 		if (digitalReadFast(18)) ret |= (1<<4);

  608. 		if (digitalReadFast(19)) ret |= (1<<5);

  609. 		return ret;

  610. 	}

  611. };

  612. extern PINCemulation PINC;

  613. 

  614. class DDRCemulation

  615. {

  616. public:

  617. 	inline DDRCemulation & operator = (int val) __attribute__((always_inline)) {

  618. 		if (val & (1<<0)) set0(); else clr0();

  619. 		if (val & (1<<1)) set1(); else clr1();

  620. 		if (val & (1<<2)) set2(); else clr2();

  621. 		if (val & (1<<3)) set3(); else clr3();

  622. 		if (val & (1<<4)) set4(); else clr4();

  623. 		if (val & (1<<5)) set5(); else clr5();

  624. 		return *this;

  625. 	}

  626. 	inline DDRCemulation & operator |= (int val) __attribute__((always_inline)) {

  627. 		if (val & (1<<0)) set0();

  628. 		if (val & (1<<1)) set1();

  629. 		if (val & (1<<2)) set2();

  630. 		if (val & (1<<3)) set3();

  631. 		if (val & (1<<4)) set4();

  632. 		if (val & (1<<5)) set5();

  633. 		return *this;

  634. 	}

  635. 	inline DDRCemulation & operator &= (int val) __attribute__((always_inline)) {

  636. 		if (!(val & (1<<0))) clr0();

  637. 		if (!(val & (1<<1))) clr1();

  638. 		if (!(val & (1<<2))) clr2();

  639. 		if (!(val & (1<<3))) clr3();

  640. 		if (!(val & (1<<4))) clr4();

  641. 		if (!(val & (1<<5))) clr5();

  642. 		return *this;

  643. 	}

  644. private:

  645. 	inline void set0() __attribute__((always_inline)) {

  646. 		GPIO_SETBIT_ATOMIC(CORE_PIN14_DDRREG, CORE_PIN14_BIT);

  647. 		CORE_PIN14_CONFIG = CONFIG_PULLUP;

  648. 	}

  649. 	inline void set1() __attribute__((always_inline)) {

  650. 		GPIO_SETBIT_ATOMIC(CORE_PIN15_DDRREG, CORE_PIN15_BIT);

  651. 		CORE_PIN15_CONFIG = CONFIG_PULLUP;

  652. 	}

  653. 	inline void set2() __attribute__((always_inline)) {

  654. 		GPIO_SETBIT_ATOMIC(CORE_PIN16_DDRREG, CORE_PIN16_BIT);

  655. 		CORE_PIN16_CONFIG = CONFIG_PULLUP;

  656. 	}

  657. 	inline void set3() __attribute__((always_inline)) {

  658. 		GPIO_SETBIT_ATOMIC(CORE_PIN17_DDRREG, CORE_PIN17_BIT);

  659. 		CORE_PIN17_CONFIG = CONFIG_PULLUP;

  660. 	}

  661. 	inline void set4() __attribute__((always_inline)) {

  662. 		GPIO_SETBIT_ATOMIC(CORE_PIN18_DDRREG, CORE_PIN18_BIT);

  663. 		CORE_PIN18_CONFIG = CONFIG_PULLUP;

  664. 	}

  665. 	inline void set5() __attribute__((always_inline)) {

  666. 		GPIO_SETBIT_ATOMIC(CORE_PIN19_DDRREG, CORE_PIN19_BIT);

  667. 		CORE_PIN19_CONFIG = CONFIG_PULLUP;

  668. 	}

  669. 	inline void clr0() __attribute__((always_inline)) {

  670. 		CORE_PIN14_CONFIG = ((CORE_PIN14_PORTREG & CORE_PIN14_BITMASK)

  671. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  672. 		GPIO_CLRBIT_ATOMIC(CORE_PIN14_DDRREG, CORE_PIN14_BIT);

  673. 	}

  674. 	inline void clr1() __attribute__((always_inline)) {

  675. 		CORE_PIN15_CONFIG = ((CORE_PIN15_PORTREG & CORE_PIN15_BITMASK)

  676. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  677. 		GPIO_CLRBIT_ATOMIC(CORE_PIN15_DDRREG, CORE_PIN15_BIT);

  678. 	}

  679. 	inline void clr2() __attribute__((always_inline)) {

  680. 		CORE_PIN16_CONFIG = ((CORE_PIN16_PORTREG & CORE_PIN16_BITMASK)

  681. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  682. 		GPIO_CLRBIT_ATOMIC(CORE_PIN16_DDRREG, CORE_PIN16_BIT);

  683. 	}

  684. 	inline void clr3() __attribute__((always_inline)) {

  685. 		CORE_PIN17_CONFIG = ((CORE_PIN17_PORTREG & CORE_PIN17_BITMASK)

  686. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  687. 		GPIO_CLRBIT_ATOMIC(CORE_PIN17_DDRREG, CORE_PIN17_BIT);

  688. 	}

  689. 	inline void clr4() __attribute__((always_inline)) {

  690. 		CORE_PIN18_CONFIG = ((CORE_PIN18_PORTREG & CORE_PIN18_BITMASK)

  691. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  692. 		GPIO_CLRBIT_ATOMIC(CORE_PIN18_DDRREG, CORE_PIN18_BIT);

  693. 	}

  694. 	inline void clr5() __attribute__((always_inline)) {

  695. 		CORE_PIN19_CONFIG = ((CORE_PIN19_PORTREG & CORE_PIN19_BITMASK)

  696. 		  ? CONFIG_PULLUP : CONFIG_NOPULLUP);

  697. 		GPIO_CLRBIT_ATOMIC(CORE_PIN19_DDRREG, CORE_PIN19_BIT);

  698. 	}

  699. };

  700. 

  701. extern DDRCemulation DDRC;

  702. 

  703. 

  704. #define PINB0 0

  705. #define PINB1 1

  706. #define PINB2 2

  707. #define PINB3 3

  708. #define PINB4 4

  709. #define PINB5 5

  710. #define PINB6 6

  711. #define PINB7 7

  712. #define DDB0 0

  713. #define DDB1 1

  714. #define DDB2 2

  715. #define DDB3 3

  716. #define DDB4 4

  717. #define DDB5 5

  718. #define DDB6 6

  719. #define DDB7 7

  720. #define PORTB0 0

  721. #define PORTB1 1

  722. #define PORTB2 2

  723. #define PORTB3 3

  724. #define PORTB4 4

  725. #define PORTB5 5

  726. #define PORTB6 6

  727. #define PORTB7 7

  728. #define PINC0 0

  729. #define PINC1 1

  730. #define PINC2 2

  731. #define PINC3 3

  732. #define PINC4 4

  733. #define PINC5 5

  734. #define PINC6 6

  735. #define DDC0 0

  736. #define DDC1 1

  737. #define DDC2 2

  738. #define DDC3 3

  739. #define DDC4 4

  740. #define DDC5 5

  741. #define DDC6 6

  742. #define PORTC0 0

  743. #define PORTC1 1

  744. #define PORTC2 2

  745. #define PORTC3 3

  746. #define PORTC4 4

  747. #define PORTC5 5

  748. #define PORTC6 6

  749. #define PIND0 0

  750. #define PIND1 1

  751. #define PIND2 2

  752. #define PIND3 3

  753. #define PIND4 4

  754. #define PIND5 5

  755. #define PIND6 6

  756. #define PIND7 7

  757. #define DDD0 0

  758. #define DDD1 1

  759. #define DDD2 2

  760. #define DDD3 3

  761. #define DDD4 4

  762. #define DDD5 5

  763. #define DDD6 6

  764. #define DDD7 7

  765. #define PORTD0 0

  766. #define PORTD1 1

  767. #define PORTD2 2

  768. #define PORTD3 3

  769. #define PORTD4 4

  770. #define PORTD5 5

  771. #define PORTD6 6

  772. #define PORTD7 7

  773. 

  774. 

  775. 

  776. 

  777. 

  778. #if 0

  779. extern "C" {

  780. void serial_print(const char *p);

  781. void serial_phex(uint32_t n);

  782. void serial_phex16(uint32_t n);

  783. void serial_phex32(uint32_t n);

  784. }

  785. #endif

  786. 

  787. 

  788. // SPI Control Register ­ SPCR

  789. #define SPIE	7	// SPI Interrupt Enable - not supported

  790. #define SPE	6	// SPI Enable

  791. #define DORD	5	// DORD: Data Order

  792. #define MSTR	4	// MSTR: Master/Slave Select

  793. #define CPOL	3	// CPOL: Clock Polarity

  794. #define CPHA	2	// CPHA: Clock Phase

  795. #define SPR1	1	// Clock: 3 = 125 kHz, 2 = 250 kHz, 1 = 1 MHz, 0->4 MHz

  796. #define SPR0	0

  797. // SPI Status Register ­ SPSR

  798. #define SPIF	7	// SPIF: SPI Interrupt Flag

  799. #define WCOL	6	// WCOL: Write COLlision Flag - not implemented

  800. #define SPI2X	0	// SPI2X: Double SPI Speed Bit

  801. // SPI Data Register ­ SPDR

  802. 

  803. 

  804. class SPCRemulation;

  805. class SPSRemulation;

  806. class SPDRemulation;

  807. 

  808. #if defined(KINETISK)

  809. 

  810. class SPCRemulation

  811. {

  812. public:

  813. 	inline SPCRemulation & operator = (int val) __attribute__((always_inline)) {

  814. 		uint32_t ctar, mcr, sim6;

  815. 		//serial_print("SPCR=");

  816. 		//serial_phex(val);

  817. 		//serial_print("\n");

  818. 		sim6 = SIM_SCGC6;

  819. 		if (!(sim6 & SIM_SCGC6_SPI0)) {

  820. 			//serial_print("init1\n");

  821. 			SIM_SCGC6 = sim6 | SIM_SCGC6_SPI0;

  822. 			SPI0_CTAR0 = SPI_CTAR_FMSZ(7) | SPI_CTAR_PBR(1) | SPI_CTAR_BR(1) | SPI_CTAR_CSSCK(1);

  823. 		}

  824. 		if (!(val & (1<<SPE))) {

  825. 			SPI0_MCR |= SPI_MCR_MDIS; // TODO: use bitband for atomic access

  826. 		}

  827. 		ctar = SPI_CTAR_FMSZ(7) | SPI_CTAR_PBR(1);

  828. 		if (val & (1<<DORD))  ctar |= SPI_CTAR_LSBFE;

  829. 		if (val & (1<<CPOL))  ctar |= SPI_CTAR_CPOL;

  830. 		if (val & (1<<CPHA)) {

  831. 			ctar |= SPI_CTAR_CPHA;

  832. 			if ((val & 3) == 0) {

  833. 				ctar |= SPI_CTAR_BR(1) | SPI_CTAR_ASC(1);

  834. 			} else if ((val & 3) == 1) {

  835. 				ctar |= SPI_CTAR_BR(4) | SPI_CTAR_ASC(4);

  836. 			} else if ((val & 3) == 2) {

  837. 				ctar |= SPI_CTAR_BR(6) | SPI_CTAR_ASC(6);

  838. 			} else {

  839. 				ctar |= SPI_CTAR_BR(7) | SPI_CTAR_ASC(7);

  840. 			}

  841. 		} else {

  842. 			if ((val & 3) == 0) {

  843. 				ctar |= SPI_CTAR_BR(1) | SPI_CTAR_CSSCK(1);

  844. 			} else if ((val & 3) == 1) {

  845. 				ctar |= SPI_CTAR_BR(4) | SPI_CTAR_CSSCK(4);

  846. 			} else if ((val & 3) == 2) {

  847. 				ctar |= SPI_CTAR_BR(6) | SPI_CTAR_CSSCK(6);

  848. 			} else {

  849. 				ctar |= SPI_CTAR_BR(7) | SPI_CTAR_CSSCK(7);

  850. 			}

  851. 		}

  852. 		ctar |= (SPI0_CTAR0 & SPI_CTAR_DBR);

  853. 		update_ctar(ctar);

  854. 		mcr = SPI_MCR_DCONF(0) | SPI_MCR_PCSIS(0x1F);

  855. 		if (val & (1<<MSTR)) mcr |= SPI_MCR_MSTR;

  856. 		if (val & (1<<SPE)) {

  857. 			mcr &= ~(SPI_MCR_MDIS | SPI_MCR_HALT);

  858. 			SPI0_MCR = mcr;

  859. 			enable_pins();

  860. 		} else {

  861. 			mcr |= (SPI_MCR_MDIS | SPI_MCR_HALT);

  862. 			SPI0_MCR = mcr;

  863. 			disable_pins();

  864. 		}

  865. 		//serial_print("MCR:");

  866. 		//serial_phex32(SPI0_MCR);

  867. 		//serial_print(", CTAR0:");

  868. 		//serial_phex32(SPI0_CTAR0);

  869. 		//serial_print("\n");

  870. 		return *this;

  871. 	}

  872. 	inline SPCRemulation & operator |= (int val) __attribute__((always_inline)) {

  873. 		uint32_t sim6;

  874. 		//serial_print("SPCR |= ");

  875. 		//serial_phex(val);

  876. 		//serial_print("\n");

  877. 		sim6 = SIM_SCGC6;

  878. 		if (!(sim6 & SIM_SCGC6_SPI0)) {

  879. 			//serial_print("init2\n");

  880. 			SIM_SCGC6 = sim6 | SIM_SCGC6_SPI0;

  881. 			SPI0_CTAR0 = SPI_CTAR_FMSZ(7) | SPI_CTAR_PBR(1) | SPI_CTAR_BR(1);

  882. 		}

  883. 		if (val & ((1<<DORD)|(1<<CPOL)|(1<<CPHA)|3)) {

  884. 			uint32_t ctar = SPI0_CTAR0;

  885. 			if (val & (1<<DORD)) ctar |= SPI_CTAR_LSBFE; // TODO: use bitband

  886. 			if (val & (1<<CPOL)) ctar |= SPI_CTAR_CPOL;

  887. 			if (val & (1<<CPHA) && !(ctar & SPI_CTAR_CPHA)) {

  888. 				ctar |= SPI_CTAR_CPHA;

  889. 				ctar &= 0xFFFF00FF;

  890. 				ctar |= SPI_CTAR_ASC(ctar & 15);

  891. 			}

  892. 			if ((val & 3) != 0) {

  893. 				uint32_t br = ctar & 15;

  894. 				uint32_t priorval;

  895. 				if (br <= 1) priorval = 0;

  896. 				else if (br <= 4) priorval = 1;

  897. 				else if (br <= 6) priorval = 2;

  898. 				else priorval = 3;

  899. 				uint32_t newval = priorval | (val & 3);

  900. 				if (newval != priorval) {

  901. 					if (newval == 0) br = 1;

  902. 					else if (newval == 0) br = 4;

  903. 					else if (newval == 0) br = 6;

  904. 					else br = 7;

  905. 					ctar &= 0xFFFF00F0; // clear BR, ASC, CSSCK

  906. 					if ((ctar & SPI_CTAR_CPHA)) {

  907. 						ctar |= SPI_CTAR_BR(br) | SPI_CTAR_ASC(br);

  908. 					} else {

  909. 						ctar |= SPI_CTAR_BR(br) | SPI_CTAR_CSSCK(br);

  910. 					}

  911. 				}

  912. 			}

  913. 			update_ctar(ctar);

  914. 		}

  915. 		if (val & (1<<MSTR)) SPI0_MCR |= SPI_MCR_MSTR;

  916. 		if (val & (1<<SPE)) {

  917. 			SPI0_MCR &= ~(SPI_MCR_MDIS | SPI_MCR_HALT);

  918. 			enable_pins();

  919. 		}

  920. 		//serial_print("MCR:");

  921. 		//serial_phex32(SPI0_MCR);

  922. 		//serial_print(", CTAR0:");

  923. 		//serial_phex32(SPI0_CTAR0);

  924. 		//serial_print("\n");

  925. 		return *this;

  926. 	}

  927. 	inline SPCRemulation & operator &= (int val) __attribute__((always_inline)) {

  928. 		//serial_print("SPCR &= ");

  929. 		//serial_phex(val);

  930. 		//serial_print("\n");

  931. 		SIM_SCGC6 |= SIM_SCGC6_SPI0;

  932. 		if (!(val & (1<<SPE))) {

  933. 			SPI0_MCR |= (SPI_MCR_MDIS | SPI_MCR_HALT);

  934. 			disable_pins();

  935. 		}

  936. 		if ((val & ((1<<DORD)|(1<<CPOL)|(1<<CPHA)|3)) != ((1<<DORD)|(1<<CPOL)|(1<<CPHA)|3)) {

  937. 			uint32_t ctar = SPI0_CTAR0;

  938. 			if (!(val & (1<<DORD))) ctar &= ~SPI_CTAR_LSBFE; // TODO: use bitband

  939. 			if (!(val & (1<<CPOL))) ctar &= ~SPI_CTAR_CPOL;

  940. 			if (!(val & (1<<CPHA)) && (ctar & SPI_CTAR_CPHA)) {

  941. 				ctar &= ~SPI_CTAR_CPHA;

  942. 				ctar &= 0xFFFF00FF;

  943. 				ctar |= SPI_CTAR_CSSCK(ctar & 15);

  944. 			}

  945. 			if ((val & 3) != 3) {

  946. 				uint32_t br = ctar & 15;

  947. 				uint32_t priorval;

  948. 				if (br <= 1) priorval = 0;

  949. 				else if (br <= 4) priorval = 1;

  950. 				else if (br <= 6) priorval = 2;

  951. 				else priorval = 3;

  952. 				uint32_t newval = priorval & (val & 3);

  953. 				if (newval != priorval) {

  954. 					if (newval == 0) br = 1;

  955. 					else if (newval == 0) br = 4;

  956. 					else if (newval == 0) br = 6;

  957. 					else br = 7;

  958. 					ctar &= 0xFFFF00F0; // clear BR, ASC, CSSCK

  959. 					if ((ctar & SPI_CTAR_CPHA)) {

  960. 						ctar |= SPI_CTAR_BR(br) | SPI_CTAR_ASC(br);

  961. 					} else {

  962. 						ctar |= SPI_CTAR_BR(br) | SPI_CTAR_CSSCK(br);

  963. 					}

  964. 				}

  965. 			}

  966. 			update_ctar(ctar);

  967. 		}

  968. 		if (!(val & (1<<MSTR))) SPI0_MCR &= ~SPI_MCR_MSTR;

  969. 		return *this;

  970. 	}

  971. 	inline int operator & (int val) const __attribute__((always_inline)) {

  972. 		int ret = 0;

  973. 		//serial_print("SPCR & ");

  974. 		//serial_phex(val);

  975. 		//serial_print("\n");

  976. 		SIM_SCGC6 |= SIM_SCGC6_SPI0;

  977. 		if ((val & (1<<DORD)) && (SPI0_CTAR0 & SPI_CTAR_LSBFE)) ret |= (1<<DORD);

  978. 		if ((val & (1<<CPOL)) && (SPI0_CTAR0 & SPI_CTAR_CPOL)) ret |= (1<<CPOL);

  979. 		if ((val & (1<<CPHA)) && (SPI0_CTAR0 & SPI_CTAR_CPHA)) ret |= (1<<CPHA);

  980. 		if ((val & 3) != 0) {

  981. 			uint32_t dbr = SPI0_CTAR0 & 15;

  982. 			uint32_t spr10;

  983. 			if (dbr <= 1) {

  984. 				spr10 = 0;

  985. 			} else if (dbr <= 4) {

  986. 				spr10 |= (1<<SPR0);

  987. 			} else if (dbr <= 6) {

  988. 				spr10 |= (1<<SPR1);

  989. 			} else {

  990. 				spr10 |= (1<<SPR1)|(1<<SPR0);

  991. 			}

  992. 			ret |= spr10 & (val & 3);

  993. 		}

  994. 		if (val & (1<<SPE) && (!(SPI0_MCR & SPI_MCR_MDIS))) ret |= (1<<SPE);

  995. 		if (val & (1<<MSTR) && (SPI0_MCR & SPI_MCR_MSTR)) ret |= (1<<MSTR);

  996. 		//serial_print("ret = ");

  997. 		//serial_phex(ret);

  998. 		//serial_print("\n");

  999. 		return ret;

  1000. 	}

  1001. 	operator int () const __attribute__((always_inline)) {

  1002. 		int ret = 0;

  1003. 		if ((SIM_SCGC6 & SIM_SCGC6_SPI0)) {

  1004. 			int ctar = SPI0_CTAR0;

  1005. 			if (ctar & SPI_CTAR_LSBFE) ret |= (1<<DORD);

  1006. 			if (ctar & SPI_CTAR_CPOL) ret |= (1<<CPOL);

  1007. 			if (ctar & SPI_CTAR_CPHA) ret |= (1<<CPHA);

  1008. 			ctar &= 15;

  1009. 			if (ctar <= 1) {

  1010. 			} else if (ctar <= 4) {

  1011. 				ret |= (1<<SPR0);

  1012. 			} else if (ctar <= 6) {

  1013. 				ret |= (1<<SPR1);

  1014. 			} else {

  1015. 				ret |= (1<<SPR1)|(1<<SPR0);

  1016. 			}

  1017. 			int mcr = SPI0_MCR;

  1018. 			if (!(mcr & SPI_MCR_MDIS)) ret |= (1<<SPE);

  1019. 			if (mcr & SPI_MCR_MSTR) ret |= (1<<MSTR);

  1020. 		}

  1021. 		return ret;

  1022. 	}

  1023. 	inline void setMOSI(uint8_t pin) __attribute__((always_inline)) {

  1024. #if defined(__MK64FX512__) || defined(__MK66FX1M0__)

  1025. 		uint8_t newpinout = pinout;

  1026. 		// More than two options so now 2 bits

  1027. 		if (pin == 11) newpinout &= ~3;

  1028. 		if (pin == 7) newpinout  =(newpinout & ~0x3) | 1;

  1029. 		if (pin == 28) newpinout = (newpinout & ~0x3) | 2;

  1030. 		if ((SIM_SCGC6 & SIM_SCGC6_SPI0) && newpinout != pinout) {

  1031. 			// First unconfigure previous pin

  1032. 			switch (pinout & 3) {

  1033. 				case 0: CORE_PIN11_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1); break;

  1034. 				case 1: CORE_PIN7_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1); break;

  1035. 				default: CORE_PIN28_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1036. 			}

  1037. 			switch (newpinout & 3) {

  1038. 				case 0: CORE_PIN11_CONFIG = PORT_PCR_DSE | PORT_PCR_MUX(2); break;

  1039. 				case 1: CORE_PIN7_CONFIG = PORT_PCR_MUX(2); break;

  1040. 				default: CORE_PIN28_CONFIG = PORT_PCR_MUX(2);

  1041. 			}

  1042. 		}

  1043. 		pinout = newpinout;

  1044. #else

  1045. 		uint8_t newpinout = pinout;

  1046. 		if (pin == 11) newpinout &= ~1;

  1047. 		if (pin == 7) newpinout |= 1;

  1048. 		if ((SIM_SCGC6 & SIM_SCGC6_SPI0) && newpinout != pinout) {

  1049. 			if ((newpinout & 1) == 0) {

  1050. 				CORE_PIN7_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1051. 				CORE_PIN11_CONFIG = PORT_PCR_DSE | PORT_PCR_MUX(2);

  1052. 			} else {

  1053. 				CORE_PIN11_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1054. 				CORE_PIN7_CONFIG = PORT_PCR_MUX(2);

  1055. 			}

  1056. 		}

  1057. 		pinout = newpinout;

  1058. #endif

  1059. 	}

  1060. 	inline void setMOSI_soft(uint8_t pin) __attribute__((always_inline)) {

  1061. #if defined(__MK64FX512__) || defined(__MK66FX1M0__)

  1062. 		if (pin == 11) pinout &= ~3;

  1063. 		if (pin == 7)  pinout = (pinout & ~0x3) | 1;

  1064. 		if (pin == 28) pinout = (pinout & ~0x3) | 2;

  1065. #else

  1066. 		if (pin == 11) pinout &= ~1;

  1067. 		if (pin == 7)  pinout |= 1;

  1068. #endif

  1069. 	}

  1070. 	inline void setMISO(uint8_t pin) __attribute__((always_inline)) {

  1071. #if defined(__MK64FX512__) || defined(__MK66FX1M0__)

  1072. 		uint8_t newpinout = pinout;

  1073. 		// More than two options so now 2 bits

  1074. 		if (pin == 12) newpinout &= ~0xc;

  1075. 		if (pin == 8) newpinout  =(newpinout & ~0xc) | 4;

  1076. 		if (pin == 39) newpinout = (newpinout & ~0xc) | 8;

  1077. 		if ((SIM_SCGC6 & SIM_SCGC6_SPI0) && newpinout != pinout) {

  1078. 			// First unconfigure previous pin

  1079. 			switch (pinout & 0xc) {

  1080. 				case 0: CORE_PIN12_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1); break;

  1081. 				case 0x4: CORE_PIN8_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1); break;

  1082. 				default: CORE_PIN39_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1083. 			}

  1084. 			switch (newpinout & 0xc) {

  1085. 				case 0: CORE_PIN12_CONFIG = PORT_PCR_MUX(2); break;

  1086. 				case 0x4: CORE_PIN8_CONFIG = PORT_PCR_MUX(2); break;

  1087. 				default: CORE_PIN39_CONFIG = PORT_PCR_MUX(2);

  1088. 			}

  1089. 		}

  1090. 		pinout = newpinout;

  1091. #else

  1092. 		uint8_t newpinout = pinout;

  1093. 		if (pin == 12) newpinout &= ~2;

  1094. 		if (pin == 8) newpinout |= 2;

  1095. 		if ((SIM_SCGC6 & SIM_SCGC6_SPI0) && newpinout != pinout) {

  1096. 			if ((newpinout & 2) == 0) {

  1097. 				CORE_PIN8_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1098. 				CORE_PIN12_CONFIG = PORT_PCR_MUX(2);

  1099. 			} else {

  1100. 				CORE_PIN12_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1101. 				CORE_PIN8_CONFIG = PORT_PCR_MUX(2);

  1102. 			}

  1103. 		}

  1104. 		pinout = newpinout;

  1105. #endif

  1106. 	}

  1107. 	inline void setMISO_soft(uint8_t pin) __attribute__((always_inline)) {

  1108. #if defined(__MK64FX512__) || defined(__MK66FX1M0__)

  1109. 		if (pin == 12) pinout &= ~0xc;

  1110. 		if (pin == 8)  pinout = (pinout & ~0xc) | 4;

  1111. 		if (pin == 39) pinout = (pinout & ~0xc) | 8;

  1112. #else

  1113. 		if (pin == 12) pinout &= ~2;

  1114. 		if (pin == 8)  pinout |= 2;

  1115. #endif

  1116. 	}

  1117. 	inline void setSCK(uint8_t pin) __attribute__((always_inline)) {

  1118. #if defined(__MK64FX512__) || defined(__MK66FX1M0__)

  1119. 		uint8_t newpinout = pinout;

  1120. 		// More than two options so now 2 bits

  1121. 		if (pin == 13) newpinout &= ~0x30;

  1122. 		if (pin == 14) newpinout  =(newpinout & ~0x30) | 0x10;

  1123. 		if (pin == 27) newpinout = (newpinout & ~0x30) | 0x20;

  1124. 		if ((SIM_SCGC6 & SIM_SCGC6_SPI0) && newpinout != pinout) {

  1125. 			// First unconfigure previous pin

  1126. 			switch (pinout & 0x30) {

  1127. 				case 0: CORE_PIN13_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1); break;

  1128. 				case 0x10: CORE_PIN14_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1); break;

  1129. 				default: CORE_PIN27_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1130. 			}

  1131. 			switch (newpinout & 0x30) {

  1132. 				case 0: CORE_PIN13_CONFIG =  PORT_PCR_DSE | PORT_PCR_MUX(2); break;

  1133. 				case 0x10: CORE_PIN14_CONFIG = PORT_PCR_MUX(2); break;

  1134. 				default: CORE_PIN27_CONFIG = PORT_PCR_MUX(2);

  1135. 			}

  1136. 		}

  1137. 		pinout = newpinout;

  1138. #else

  1139. 		uint8_t newpinout = pinout;

  1140. 		if (pin == 13) newpinout &= ~4;

  1141. 		if (pin == 14) newpinout |= 4;

  1142. 		if ((SIM_SCGC6 & SIM_SCGC6_SPI0) && newpinout != pinout) {

  1143. 			if ((newpinout & 4) == 0) {

  1144. 				CORE_PIN14_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1145. 				CORE_PIN13_CONFIG = PORT_PCR_DSE | PORT_PCR_MUX(2);

  1146. 			} else {

  1147. 				CORE_PIN13_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1148. 				CORE_PIN14_CONFIG = PORT_PCR_MUX(2);

  1149. 			}

  1150. 		}

  1151. 		pinout = newpinout;

  1152. #endif

  1153. 	}

  1154. 	inline void setSCK_soft(uint8_t pin) __attribute__((always_inline)) {

  1155. #if defined(__MK64FX512__) || defined(__MK66FX1M0__)

  1156. 		if (pin == 13) pinout &= ~0x30;

  1157. 		if (pin == 14) pinout = (pinout & ~0x30) | 0x10;

  1158. 		if (pin == 27) pinout = (pinout & ~0x30) | 0x20;

  1159. #else

  1160. 		if (pin == 13) pinout &= ~4;

  1161. 		if (pin == 14) pinout |= 4;

  1162. #endif

  1163. 	}

  1164. 	friend class SPSRemulation;

  1165. 	friend class SPIFIFOclass;

  1166. private:

  1167. 	static inline void update_ctar(uint32_t ctar) __attribute__((always_inline)) {

  1168. 		if (SPI0_CTAR0 == ctar) return;

  1169. 		uint32_t mcr = SPI0_MCR;

  1170. 		if (mcr & SPI_MCR_MDIS) {

  1171. 			SPI0_CTAR0 = ctar;

  1172. 		} else {

  1173. 			SPI0_MCR = mcr | SPI_MCR_MDIS | SPI_MCR_HALT;

  1174. 			SPI0_CTAR0 = ctar;

  1175. 			SPI0_MCR = mcr;

  1176. 		}

  1177. 	}

  1178. 	static uint8_t pinout;

  1179. public:

  1180. 	inline void enable_pins(void) __attribute__((always_inline)) {

  1181. 		//serial_print("enable_pins\n");

  1182. #if defined(__MK64FX512__) || defined(__MK66FX1M0__)

  1183. 		switch (pinout & 3) {

  1184. 			case 0: CORE_PIN11_CONFIG = PORT_PCR_DSE | PORT_PCR_MUX(2); break;

  1185. 			case 1: CORE_PIN7_CONFIG = PORT_PCR_MUX(2); break;

  1186. 			default: CORE_PIN28_CONFIG = PORT_PCR_MUX(2);

  1187. 		}

  1188. 		switch (pinout & 0xc) {

  1189. 			case 0: CORE_PIN12_CONFIG = PORT_PCR_MUX(2); break;

  1190. 			case 0x4: CORE_PIN8_CONFIG = PORT_PCR_MUX(2); break;

  1191. 			default: CORE_PIN39_CONFIG = PORT_PCR_MUX(2);

  1192. 		}

  1193. 		switch (pinout & 0x30) {

  1194. 			case 0: CORE_PIN13_CONFIG =  PORT_PCR_DSE | PORT_PCR_MUX(2); break;

  1195. 			case 0x10: CORE_PIN14_CONFIG = PORT_PCR_MUX(2); break;

  1196. 			default: CORE_PIN27_CONFIG = PORT_PCR_MUX(2);

  1197. 		}

  1198. #else

  1199. 		if ((pinout & 1) == 0) {

  1200. 			CORE_PIN11_CONFIG = PORT_PCR_DSE | PORT_PCR_MUX(2); // DOUT/MOSI = 11 (PTC6)

  1201. 		} else {

  1202. 			CORE_PIN7_CONFIG = PORT_PCR_MUX(2); // DOUT/MOSI = 7 (PTD2)

  1203. 		}

  1204. 		if ((pinout & 2) == 0) {

  1205. 			CORE_PIN12_CONFIG = PORT_PCR_MUX(2);  // DIN/MISO = 12 (PTC7)

  1206. 		} else {

  1207. 			CORE_PIN8_CONFIG = PORT_PCR_MUX(2);  // DIN/MISO = 8 (PTD3)

  1208. 		}

  1209. 		if ((pinout & 4) == 0) {

  1210. 			CORE_PIN13_CONFIG = PORT_PCR_DSE | PORT_PCR_MUX(2); // SCK = 13 (PTC5)

  1211. 		} else {

  1212. 			CORE_PIN14_CONFIG = PORT_PCR_MUX(2); // SCK = 14 (PTD1)

  1213. 		}

  1214. #endif

  1215. 	}

  1216. 	inline void disable_pins(void) __attribute__((always_inline)) {

  1217. #if defined(__MK64FX512__) || defined(__MK66FX1M0__)

  1218. 		switch (pinout & 3) {

  1219. 			case 0: CORE_PIN11_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1); break;

  1220. 			case 1: CORE_PIN7_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1); break;

  1221. 			default: CORE_PIN28_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1222. 		}

  1223. 

  1224. 		switch (pinout & 0xc) {

  1225. 			case 0: CORE_PIN12_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1); break;

  1226. 			case 0x4: CORE_PIN8_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1); break;

  1227. 			default: CORE_PIN39_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1228. 		}

  1229. 		switch (pinout & 0x30) {

  1230. 			case 0: CORE_PIN13_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1); break;

  1231. 			case 0x10: CORE_PIN14_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1); break;

  1232. 			default: CORE_PIN27_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1233. 		}

  1234. #else

  1235. 		//serial_print("disable_pins\n");

  1236. 		if ((pinout & 1) == 0) {

  1237. 			CORE_PIN11_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1238. 		} else {

  1239. 			CORE_PIN7_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1240. 		}

  1241. 		if ((pinout & 2) == 0) {

  1242. 			CORE_PIN12_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1243. 		} else {

  1244. 			CORE_PIN8_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1245. 		}

  1246. 		if ((pinout & 4) == 0) {

  1247. 			CORE_PIN13_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1248. 		} else {

  1249. 			CORE_PIN14_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1250. 		}

  1251. #endif

  1252. 	}

  1253. };

  1254. extern SPCRemulation SPCR;

  1255. 

  1256. #if defined(__MK64FX512__) || defined(__MK66FX1M0__)

  1257. class SPCR1emulation

  1258. {

  1259. public:

  1260. 	inline SPCR1emulation & operator = (int val) __attribute__((always_inline)) {

  1261. 		uint32_t ctar, mcr, sim6;

  1262. 		//serial_print("SPCR=");

  1263. 		//serial_phex(val);

  1264. 		//serial_print("\n");

  1265. 		sim6 = SIM_SCGC6;

  1266. 		if (!(sim6 & SIM_SCGC6_SPI1)) {

  1267. 			//serial_print("init1\n");

  1268. 			SIM_SCGC6 = sim6 | SIM_SCGC6_SPI1;

  1269. 			SPI1_CTAR0 = SPI_CTAR_FMSZ(7) | SPI_CTAR_PBR(1) | SPI_CTAR_BR(1) | SPI_CTAR_CSSCK(1);

  1270. 		}

  1271. 		if (!(val & (1<<SPE))) {

  1272. 			SPI1_MCR |= SPI_MCR_MDIS; // TODO: use bitband for atomic access

  1273. 		}

  1274. 		ctar = SPI_CTAR_FMSZ(7) | SPI_CTAR_PBR(1);

  1275. 		if (val & (1<<DORD))  ctar |= SPI_CTAR_LSBFE;

  1276. 		if (val & (1<<CPOL))  ctar |= SPI_CTAR_CPOL;

  1277. 		if (val & (1<<CPHA)) {

  1278. 			ctar |= SPI_CTAR_CPHA;

  1279. 			if ((val & 3) == 0) {

  1280. 				ctar |= SPI_CTAR_BR(1) | SPI_CTAR_ASC(1);

  1281. 			} else if ((val & 3) == 1) {

  1282. 				ctar |= SPI_CTAR_BR(4) | SPI_CTAR_ASC(4);

  1283. 			} else if ((val & 3) == 2) {

  1284. 				ctar |= SPI_CTAR_BR(6) | SPI_CTAR_ASC(6);

  1285. 			} else {

  1286. 				ctar |= SPI_CTAR_BR(7) | SPI_CTAR_ASC(7);

  1287. 			}

  1288. 		} else {

  1289. 			if ((val & 3) == 0) {

  1290. 				ctar |= SPI_CTAR_BR(1) | SPI_CTAR_CSSCK(1);

  1291. 			} else if ((val & 3) == 1) {

  1292. 				ctar |= SPI_CTAR_BR(4) | SPI_CTAR_CSSCK(4);

  1293. 			} else if ((val & 3) == 2) {

  1294. 				ctar |= SPI_CTAR_BR(6) | SPI_CTAR_CSSCK(6);

  1295. 			} else {

  1296. 				ctar |= SPI_CTAR_BR(7) | SPI_CTAR_CSSCK(7);

  1297. 			}

  1298. 		}

  1299. 		ctar |= (SPI1_CTAR0 & SPI_CTAR_DBR);

  1300. 		update_ctar(ctar);

  1301. 		mcr = SPI_MCR_DCONF(0) | SPI_MCR_PCSIS(0x1F);

  1302. 		if (val & (1<<MSTR)) mcr |= SPI_MCR_MSTR;

  1303. 		if (val & (1<<SPE)) {

  1304. 			mcr &= ~(SPI_MCR_MDIS | SPI_MCR_HALT);

  1305. 			SPI1_MCR = mcr;

  1306. 			enable_pins();

  1307. 		} else {

  1308. 			mcr |= (SPI_MCR_MDIS | SPI_MCR_HALT);

  1309. 			SPI1_MCR = mcr;

  1310. 			disable_pins();

  1311. 		}

  1312. 		//serial_print("MCR:");

  1313. 		//serial_phex32(SPI1_MCR);

  1314. 		//serial_print(", CTAR0:");

  1315. 		//serial_phex32(SPI1_CTAR0);

  1316. 		//serial_print("\n");

  1317. 		return *this;

  1318. 	}

  1319. 	inline SPCR1emulation & operator |= (int val) __attribute__((always_inline)) {

  1320. 		uint32_t sim6;

  1321. 		//serial_print("SPCR |= ");

  1322. 		//serial_phex(val);

  1323. 		//serial_print("\n");

  1324. 		sim6 = SIM_SCGC6;

  1325. 		if (!(sim6 & SIM_SCGC6_SPI1)) {

  1326. 			//serial_print("init2\n");

  1327. 			SIM_SCGC6 = sim6 | SIM_SCGC6_SPI1;

  1328. 			SPI1_CTAR0 = SPI_CTAR_FMSZ(7) | SPI_CTAR_PBR(1) | SPI_CTAR_BR(1);

  1329. 		}

  1330. 		if (val & ((1<<DORD)|(1<<CPOL)|(1<<CPHA)|3)) {

  1331. 			uint32_t ctar = SPI1_CTAR0;

  1332. 			if (val & (1<<DORD)) ctar |= SPI_CTAR_LSBFE; // TODO: use bitband

  1333. 			if (val & (1<<CPOL)) ctar |= SPI_CTAR_CPOL;

  1334. 			if ((val & 3) == 1) {

  1335. 				// TODO: implement - is this ever really needed

  1336. 			} else if ((val & 3) == 2) {

  1337. 				// TODO: implement - is this ever really needed

  1338. 			} else if ((val & 3) == 3) {

  1339. 				// TODO: implement - is this ever really needed

  1340. 			}

  1341. 			if (val & (1<<CPHA) && !(ctar & SPI_CTAR_CPHA)) {

  1342. 				ctar |= SPI_CTAR_CPHA;

  1343. 				// TODO: clear SPI_CTAR_CSSCK, set SPI_CTAR_ASC

  1344. 			}

  1345. 			update_ctar(ctar);

  1346. 		}

  1347. 		if (val & (1<<MSTR)) SPI1_MCR |= SPI_MCR_MSTR;

  1348. 		if (val & (1<<SPE)) {

  1349. 			SPI1_MCR &= ~(SPI_MCR_MDIS | SPI_MCR_HALT);

  1350. 			enable_pins();

  1351. 		}

  1352. 		//serial_print("MCR:");

  1353. 		//serial_phex32(SPI1_MCR);

  1354. 		//serial_print(", CTAR0:");

  1355. 		//serial_phex32(SPI1_CTAR0);

  1356. 		//serial_print("\n");

  1357. 		return *this;

  1358. 	}

  1359. 	inline SPCR1emulation & operator &= (int val) __attribute__((always_inline)) {

  1360. 		//serial_print("SPCR &= ");

  1361. 		//serial_phex(val);

  1362. 		//serial_print("\n");

  1363. 		SIM_SCGC6 |= SIM_SCGC6_SPI1;

  1364. 		if (!(val & (1<<SPE))) {

  1365. 			SPI1_MCR |= (SPI_MCR_MDIS | SPI_MCR_HALT);

  1366. 			disable_pins();

  1367. 		}

  1368. 		if ((val & ((1<<DORD)|(1<<CPOL)|(1<<CPHA)|3)) != ((1<<DORD)|(1<<CPOL)|(1<<CPHA)|3)) {

  1369. 			uint32_t ctar = SPI1_CTAR0;

  1370. 			if (!(val & (1<<DORD))) ctar &= ~SPI_CTAR_LSBFE; // TODO: use bitband

  1371. 			if (!(val & (1<<CPOL))) ctar &= ~SPI_CTAR_CPOL;

  1372. 			if ((val & 3) == 0) {

  1373. 				// TODO: implement - is this ever really needed

  1374. 			} else if ((val & 3) == 1) {

  1375. 				// TODO: implement - is this ever really needed

  1376. 			} else if ((val & 3) == 2) {

  1377. 				// TODO: implement - is this ever really needed

  1378. 			}

  1379. 			if (!(val & (1<<CPHA)) && (ctar & SPI_CTAR_CPHA)) {

  1380. 				ctar &= ~SPI_CTAR_CPHA;

  1381. 				// TODO: set SPI_CTAR_ASC, clear SPI_CTAR_CSSCK

  1382. 			}

  1383. 			update_ctar(ctar);

  1384. 		}

  1385. 		if (!(val & (1<<MSTR))) SPI1_MCR &= ~SPI_MCR_MSTR;

  1386. 		return *this;

  1387. 	}

  1388. 	inline int operator & (int val) const __attribute__((always_inline)) {

  1389. 		int ret = 0;

  1390. 		//serial_print("SPCR & ");

  1391. 		//serial_phex(val);

  1392. 		//serial_print(" MCR:");

  1393. 		//serial_phex32(SPI1_MCR);

  1394. 		//serial_print(", CTAR0:");

  1395. 		//serial_phex32(SPI1_CTAR0);

  1396. 		//serial_print("\n");

  1397. 

  1398. 		//serial_print("\n");

  1399. 		SIM_SCGC6 |= SIM_SCGC6_SPI1;

  1400. 		if ((val & (1<<DORD)) && (SPI1_CTAR0 & SPI_CTAR_LSBFE)) ret |= (1<<DORD);

  1401. 		if ((val & (1<<CPOL)) && (SPI1_CTAR0 & SPI_CTAR_CPOL)) ret |= (1<<CPOL);

  1402. 		if ((val & (1<<CPHA)) && (SPI1_CTAR0 & SPI_CTAR_CPHA)) ret |= (1<<CPHA);

  1403. 		if ((val & 3) == 3) {

  1404. 			uint32_t dbr = SPI1_CTAR0 & 15;

  1405. 			if (dbr <= 1) {

  1406. 			} else if (dbr <= 4) {

  1407. 				ret |= (1<<SPR0);

  1408. 			} else if (dbr <= 6) {

  1409. 				ret |= (1<<SPR1);

  1410. 			} else {

  1411. 				ret |= (1<<SPR1)|(1<<SPR0);

  1412. 			}

  1413. 		} else if ((val & 3) == 1) {

  1414. 			// TODO: implement - is this ever really needed

  1415. 		} else if ((val & 3) == 2) {

  1416. 			// TODO: implement - is this ever really needed

  1417. 		}

  1418. 		if (val & (1<<SPE) && (!(SPI1_MCR & SPI_MCR_MDIS))) ret |= (1<<SPE);

  1419. 		if (val & (1<<MSTR) && (SPI1_MCR & SPI_MCR_MSTR)) ret |= (1<<MSTR);

  1420. 		//serial_print("ret = ");

  1421. 		//serial_phex(ret);

  1422. 		//serial_print("\n");

  1423. 		return ret;

  1424. 	}

  1425. 	inline void setMOSI(uint8_t pin) __attribute__((always_inline)) {

  1426. 		// More options, so 2 bits

  1427. 		pinout &= ~3;

  1428. 		switch (pin) {

  1429. 			case 0: break;

  1430. 			case 21: pinout |= 1; break; 

  1431. 			case 61: pinout |= 2; break;

  1432. 			case 59: pinout |= 3; break;

  1433. 		}

  1434. 	}

  1435. 	inline void setMISO(uint8_t pin) __attribute__((always_inline)) {

  1436. 		// More options, so 2 bits

  1437. 		pinout &= ~0xc;

  1438. 		switch (pin) {

  1439. 			case 1: break;

  1440. 			case 5: pinout |= 0x4; break; 

  1441. 			case 61: pinout |= 0x8; break;

  1442. 			case 59: pinout |= 0xc; break;

  1443. 		}

  1444. 	}

  1445. 	inline void setSCK(uint8_t pin) __attribute__((always_inline)) {

  1446. 		// More options, so 2 bits

  1447. 		pinout &= ~0x30;

  1448. 		switch (pin) {

  1449. 			case 32: break;

  1450. 			case 20: pinout |= 0x10; break; 

  1451. 			case 60: pinout |= 0x20; break;

  1452. 		}

  1453. 	}

  1454. 	inline void enable_pins(void) __attribute__((always_inline)) {

  1455. 		//serial_print("enable_pins\n");

  1456. 		// MOSI (SOUT)

  1457. 		switch (pinout & 0x3) {

  1458. 			case 0: CORE_PIN0_CONFIG = PORT_PCR_MUX(2); break;

  1459. 			case 1: CORE_PIN21_CONFIG = PORT_PCR_MUX(7); break;

  1460. 			case 2: CORE_PIN61_CONFIG = PORT_PCR_MUX(7); break;

  1461. 			case 3: CORE_PIN59_CONFIG = PORT_PCR_MUX(2); break;

  1462. 		}

  1463. 		// MISO (SIN)

  1464. 		switch (pinout & 0xc) {

  1465. 			case 0x0: CORE_PIN1_CONFIG = PORT_PCR_MUX(2); break;

  1466. 			case 0x4: CORE_PIN5_CONFIG = PORT_PCR_MUX(7); break;

  1467. 			case 0x8: CORE_PIN61_CONFIG = PORT_PCR_MUX(2); break;

  1468. 			case 0xc: CORE_PIN59_CONFIG = PORT_PCR_MUX(7); break;

  1469. 		}

  1470. 		// SCK

  1471. 		switch (pinout & 0x30) {

  1472. 			case 0x0: CORE_PIN32_CONFIG = PORT_PCR_MUX(2); break;

  1473. 			case 0x10: CORE_PIN20_CONFIG = PORT_PCR_MUX(7); break;

  1474. 			case 0x20: CORE_PIN60_CONFIG = PORT_PCR_MUX(2); break;

  1475. 		}

  1476. 	}

  1477. 	inline void disable_pins(void) __attribute__((always_inline)) {

  1478. 		switch (pinout & 0x3) {

  1479. 			case 0: CORE_PIN0_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1); break;

  1480. 			case 1: CORE_PIN21_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1); break;

  1481. 			case 2: CORE_PIN61_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1); break;

  1482. 			case 3: CORE_PIN59_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1); break;

  1483. 		}

  1484. 		switch (pinout & 0xc) {

  1485. 			case 0x0: CORE_PIN1_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1); break;

  1486. 			case 0x4: CORE_PIN5_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1); break;

  1487. 			case 0x8: CORE_PIN61_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1); break;

  1488. 			case 0xc: CORE_PIN59_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1); break;

  1489. 		}

  1490. 		switch (pinout & 0x30) {

  1491. 			case 0x0: CORE_PIN32_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1); break;

  1492. 			case 0x10: CORE_PIN20_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1); break;

  1493. 			case 0x20: CORE_PIN60_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1); break;

  1494. 		}

  1495. 	}

  1496. 	friend class SPIFIFO1class;

  1497. private:

  1498. 	static uint8_t pinout;

  1499. 	static inline void update_ctar(uint32_t ctar) __attribute__((always_inline)) {

  1500. 		if (SPI1_CTAR0 == ctar) return;

  1501. 		uint32_t mcr = SPI1_MCR;

  1502. 		if (mcr & SPI_MCR_MDIS) {

  1503. 			SPI1_CTAR0 = ctar;

  1504. 		} else {

  1505. 			SPI1_MCR = mcr | SPI_MCR_MDIS | SPI_MCR_HALT;

  1506. 			SPI1_CTAR0 = ctar;

  1507. 			SPI1_MCR = mcr;

  1508. 		}

  1509. 	}

  1510. };

  1511. extern SPCR1emulation SPCR1;

  1512. 

  1513. ////////////////////

  1514. // SPI2

  1515. class SPCR2emulation

  1516. {

  1517. public:

  1518. 	inline SPCR2emulation & operator = (int val) __attribute__((always_inline)) {

  1519. 		uint32_t ctar, mcr, sim3;

  1520. 		//serial_print("SPCR=");

  1521. 		//serial_phex(val);

  1522. 		//serial_print("\n");

  1523. 		sim3 = SIM_SCGC3;

  1524. 		if (!(sim3 & SIM_SCGC3_SPI2)) {

  1525. 			//serial_print("init1\n");

  1526. 			SIM_SCGC3 = sim3 | SIM_SCGC3_SPI2;

  1527. 			SPI2_CTAR0 = SPI_CTAR_FMSZ(7) | SPI_CTAR_PBR(1) | SPI_CTAR_BR(1) | SPI_CTAR_CSSCK(1);

  1528. 		}

  1529. 		if (!(val & (1<<SPE))) {

  1530. 			SPI2_MCR |= SPI_MCR_MDIS; // TODO: use bitband for atomic access

  1531. 		}

  1532. 		ctar = SPI_CTAR_FMSZ(7) | SPI_CTAR_PBR(1);

  1533. 		if (val & (1<<DORD))  ctar |= SPI_CTAR_LSBFE;

  1534. 		if (val & (1<<CPOL))  ctar |= SPI_CTAR_CPOL;

  1535. 		if (val & (1<<CPHA)) {

  1536. 			ctar |= SPI_CTAR_CPHA;

  1537. 			if ((val & 3) == 0) {

  1538. 				ctar |= SPI_CTAR_BR(1) | SPI_CTAR_ASC(1);

  1539. 			} else if ((val & 3) == 1) {

  1540. 				ctar |= SPI_CTAR_BR(4) | SPI_CTAR_ASC(4);

  1541. 			} else if ((val & 3) == 2) {

  1542. 				ctar |= SPI_CTAR_BR(6) | SPI_CTAR_ASC(6);

  1543. 			} else {

  1544. 				ctar |= SPI_CTAR_BR(7) | SPI_CTAR_ASC(7);

  1545. 			}

  1546. 		} else {

  1547. 			if ((val & 3) == 0) {

  1548. 				ctar |= SPI_CTAR_BR(1) | SPI_CTAR_CSSCK(1);

  1549. 			} else if ((val & 3) == 1) {

  1550. 				ctar |= SPI_CTAR_BR(4) | SPI_CTAR_CSSCK(4);

  1551. 			} else if ((val & 3) == 2) {

  1552. 				ctar |= SPI_CTAR_BR(6) | SPI_CTAR_CSSCK(6);

  1553. 			} else {

  1554. 				ctar |= SPI_CTAR_BR(7) | SPI_CTAR_CSSCK(7);

  1555. 			}

  1556. 		}

  1557. 		ctar |= (SPI2_CTAR0 & SPI_CTAR_DBR);

  1558. 		update_ctar(ctar);

  1559. 		mcr = SPI_MCR_DCONF(0) | SPI_MCR_PCSIS(0x1F);

  1560. 		if (val & (1<<MSTR)) mcr |= SPI_MCR_MSTR;

  1561. 		if (val & (1<<SPE)) {

  1562. 			mcr &= ~(SPI_MCR_MDIS | SPI_MCR_HALT);

  1563. 			SPI2_MCR = mcr;

  1564. 			enable_pins();

  1565. 		} else {

  1566. 			mcr |= (SPI_MCR_MDIS | SPI_MCR_HALT);

  1567. 			SPI2_MCR = mcr;

  1568. 			disable_pins();

  1569. 		}

  1570. 		//serial_print("MCR:");

  1571. 		//serial_phex32(SPI2_MCR);

  1572. 		//serial_print(", CTAR0:");

  1573. 		//serial_phex32(SPI2_CTAR0);

  1574. 		//serial_print("\n");

  1575. 		return *this;

  1576. 	}

  1577. 	inline SPCR2emulation & operator |= (int val) __attribute__((always_inline)) {

  1578. 		uint32_t sim3;

  1579. 		//serial_print("SPCR |= ");

  1580. 		//serial_phex(val);

  1581. 		//serial_print("\n");

  1582. 		sim3 = SIM_SCGC3;

  1583. 		if (!(sim3 & SIM_SCGC3_SPI2)) {

  1584. 			//serial_print("init2\n");

  1585. 			SIM_SCGC6 = sim3 | SIM_SCGC3_SPI2;

  1586. 			SPI2_CTAR0 = SPI_CTAR_FMSZ(7) | SPI_CTAR_PBR(1) | SPI_CTAR_BR(1);

  1587. 		}

  1588. 		if (val & ((1<<DORD)|(1<<CPOL)|(1<<CPHA)|3)) {

  1589. 			uint32_t ctar = SPI2_CTAR0;

  1590. 			if (val & (1<<DORD)) ctar |= SPI_CTAR_LSBFE; // TODO: use bitband

  1591. 			if (val & (1<<CPOL)) ctar |= SPI_CTAR_CPOL;

  1592. 			if ((val & 3) == 1) {

  1593. 				// TODO: implement - is this ever really needed

  1594. 			} else if ((val & 3) == 2) {

  1595. 				// TODO: implement - is this ever really needed

  1596. 			} else if ((val & 3) == 3) {

  1597. 				// TODO: implement - is this ever really needed

  1598. 			}

  1599. 			if (val & (1<<CPHA) && !(ctar & SPI_CTAR_CPHA)) {

  1600. 				ctar |= SPI_CTAR_CPHA;

  1601. 				// TODO: clear SPI_CTAR_CSSCK, set SPI_CTAR_ASC

  1602. 			}

  1603. 			update_ctar(ctar);

  1604. 		}

  1605. 		if (val & (1<<MSTR)) SPI2_MCR |= SPI_MCR_MSTR;

  1606. 		if (val & (1<<SPE)) {

  1607. 			SPI2_MCR &= ~(SPI_MCR_MDIS | SPI_MCR_HALT);

  1608. 			enable_pins();

  1609. 		}

  1610. 		//serial_print("MCR:");

  1611. 		//serial_phex32(SPI2_MCR);

  1612. 		//serial_print(", CTAR0:");

  1613. 		//serial_phex32(SPI2_CTAR0);

  1614. 		//serial_print("\n");

  1615. 		return *this;

  1616. 	}

  1617. 	inline SPCR2emulation & operator &= (int val) __attribute__((always_inline)) {

  1618. 		//serial_print("SPCR &= ");

  1619. 		//serial_phex(val);

  1620. 		//serial_print("\n");

  1621. 		SIM_SCGC3 |= SIM_SCGC3_SPI2;

  1622. 		if (!(val & (1<<SPE))) {

  1623. 			SPI2_MCR |= (SPI_MCR_MDIS | SPI_MCR_HALT);

  1624. 			disable_pins();

  1625. 		}

  1626. 		if ((val & ((1<<DORD)|(1<<CPOL)|(1<<CPHA)|3)) != ((1<<DORD)|(1<<CPOL)|(1<<CPHA)|3)) {

  1627. 			uint32_t ctar = SPI2_CTAR0;

  1628. 			if (!(val & (1<<DORD))) ctar &= ~SPI_CTAR_LSBFE; // TODO: use bitband

  1629. 			if (!(val & (1<<CPOL))) ctar &= ~SPI_CTAR_CPOL;

  1630. 			if ((val & 3) == 0) {

  1631. 				// TODO: implement - is this ever really needed

  1632. 			} else if ((val & 3) == 1) {

  1633. 				// TODO: implement - is this ever really needed

  1634. 			} else if ((val & 3) == 2) {

  1635. 				// TODO: implement - is this ever really needed

  1636. 			}

  1637. 			if (!(val & (1<<CPHA)) && (ctar & SPI_CTAR_CPHA)) {

  1638. 				ctar &= ~SPI_CTAR_CPHA;

  1639. 				// TODO: set SPI_CTAR_ASC, clear SPI_CTAR_CSSCK

  1640. 			}

  1641. 			update_ctar(ctar);

  1642. 		}

  1643. 		if (!(val & (1<<MSTR))) SPI2_MCR &= ~SPI_MCR_MSTR;

  1644. 		return *this;

  1645. 	}

  1646. 	inline int operator & (int val) const __attribute__((always_inline)) {

  1647. 		int ret = 0;

  1648. 		//serial_print("SPCR & ");

  1649. 		//serial_phex(val);

  1650. 		//serial_print(" MCR:");

  1651. 		//serial_phex32(SPI2_MCR);

  1652. 		//serial_print(", CTAR0:");

  1653. 		//serial_phex32(SPI2_CTAR0);

  1654. 		//serial_print("\n");

  1655. 

  1656. 		//serial_print("\n");

  1657. 		SIM_SCGC3 |= SIM_SCGC3_SPI2;

  1658. 		if ((val & (1<<DORD)) && (SPI2_CTAR0 & SPI_CTAR_LSBFE)) ret |= (1<<DORD);

  1659. 		if ((val & (1<<CPOL)) && (SPI2_CTAR0 & SPI_CTAR_CPOL)) ret |= (1<<CPOL);

  1660. 		if ((val & (1<<CPHA)) && (SPI2_CTAR0 & SPI_CTAR_CPHA)) ret |= (1<<CPHA);

  1661. 		if ((val & 3) == 3) {

  1662. 			uint32_t dbr = SPI2_CTAR0 & 15;

  1663. 			if (dbr <= 1) {

  1664. 			} else if (dbr <= 4) {

  1665. 				ret |= (1<<SPR0);

  1666. 			} else if (dbr <= 6) {

  1667. 				ret |= (1<<SPR1);

  1668. 			} else {

  1669. 				ret |= (1<<SPR1)|(1<<SPR0);

  1670. 			}

  1671. 		} else if ((val & 3) == 1) {

  1672. 			// TODO: implement - is this ever really needed

  1673. 		} else if ((val & 3) == 2) {

  1674. 			// TODO: implement - is this ever really needed

  1675. 		}

  1676. 		if (val & (1<<SPE) && (!(SPI2_MCR & SPI_MCR_MDIS))) ret |= (1<<SPE);

  1677. 		if (val & (1<<MSTR) && (SPI2_MCR & SPI_MCR_MSTR)) ret |= (1<<MSTR);

  1678. 		//serial_print("ret = ");

  1679. 		//serial_phex(ret);

  1680. 		//serial_print("\n");

  1681. 		return ret;

  1682. 	}

  1683. 	inline void setMOSI(uint8_t pin) __attribute__((always_inline)) {

  1684. 		if (pin == 44) pinout &= ~1; 

  1685. 		if (pin == 52) pinout |= 1; 

  1686. 	}

  1687. 	inline void setMISO(uint8_t pin) __attribute__((always_inline)) {

  1688. 		if (pin == 45) pinout &= ~2; 

  1689. 		if (pin == 51) pinout |= 2; 

  1690. 	}

  1691. 	inline void setSCK(uint8_t pin) __attribute__((always_inline)) {

  1692. 		if (pin == 46) pinout &= ~4; 

  1693. 		if (pin == 53) pinout |= 4; 

  1694. 	}

  1695. 	inline void enable_pins(void) __attribute__((always_inline)) {

  1696. 		//serial_print("enable_pins\n");

  1697. 		if ((pinout & 1) == 0) {

  1698. 			CORE_PIN44_CONFIG = PORT_PCR_MUX(2);

  1699. 		} else {

  1700. 			CORE_PIN52_CONFIG = PORT_PCR_MUX(2); 

  1701. 		}

  1702. 		if ((pinout & 2) == 0) {

  1703. 			CORE_PIN45_CONFIG = PORT_PCR_MUX(2); 

  1704. 		} else {

  1705. 			CORE_PIN51_CONFIG = PORT_PCR_MUX(2); 

  1706. 		}

  1707. 		if ((pinout & 4) == 0) {

  1708. 			CORE_PIN46_CONFIG = PORT_PCR_MUX(2); 

  1709. 		} else {

  1710. 			CORE_PIN53_CONFIG = PORT_PCR_MUX(2); 

  1711. 		}

  1712. 	}

  1713. 	inline void disable_pins(void) __attribute__((always_inline)) {

  1714. 		//serial_print("disable_pins\n");

  1715. 		if ((pinout & 1) == 0) {

  1716. 			CORE_PIN44_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  1717. 		} else {

  1718. 			CORE_PIN52_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  1719. 		}

  1720. 		if ((pinout & 2) == 0) {

  1721. 			CORE_PIN45_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  1722. 		} else {

  1723. 			CORE_PIN51_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  1724. 		}

  1725. 		if ((pinout & 4) == 0) {

  1726. 			CORE_PIN46_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1); 

  1727. 		} else {

  1728. 			CORE_PIN53_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1); 

  1729. 		}

  1730. 	}

  1731. 	friend class SPIFIFO1class;

  1732. private:

  1733. 	static uint8_t pinout;

  1734. 	static inline void update_ctar(uint32_t ctar) __attribute__((always_inline)) {

  1735. 		if (SPI2_CTAR0 == ctar) return;

  1736. 		uint32_t mcr = SPI2_MCR;

  1737. 		if (mcr & SPI_MCR_MDIS) {

  1738. 			SPI2_CTAR0 = ctar;

  1739. 		} else {

  1740. 			SPI2_MCR = mcr | SPI_MCR_MDIS | SPI_MCR_HALT;

  1741. 			SPI2_CTAR0 = ctar;

  1742. 			SPI2_MCR = mcr;

  1743. 		}

  1744. 	}

  1745. };

  1746. extern SPCR2emulation SPCR2;

  1747. 

  1748. 

  1749. 

  1750. #endif

  1751. 

  1752. class SPSRemulation

  1753. {

  1754. public:

  1755. 	inline SPSRemulation & operator = (int val) __attribute__((always_inline)) {

  1756. 		//serial_print("SPSR=");

  1757. 		//serial_phex(val);

  1758. 		//serial_print("\n");

  1759. 		uint32_t ctar = SPI0_CTAR0;

  1760. 		if (val & (1<<SPI2X)) {

  1761. 			ctar |= SPI_CTAR_DBR;

  1762. 		} else {

  1763. 			ctar &= ~SPI_CTAR_DBR;

  1764. 		}

  1765. 		SPCRemulation::update_ctar(ctar);

  1766. 		//serial_print("MCR:");

  1767. 		//serial_phex32(SPI0_MCR);

  1768. 		//serial_print(", CTAR0:");

  1769. 		//serial_phex32(SPI0_CTAR0);

  1770. 		//serial_print("\n");

  1771. 		return *this;

  1772. 	}

  1773. 	inline SPSRemulation & operator |= (int val) __attribute__((always_inline)) {

  1774. 		//serial_print("SPSR |= ");

  1775. 		//serial_phex(val);

  1776. 		//serial_print("\n");

  1777. 		if (val & (1<<SPI2X)) SPCRemulation::update_ctar(SPI0_CTAR0 |= SPI_CTAR_DBR);

  1778. 		return *this;

  1779. 	}

  1780. 	inline SPSRemulation & operator &= (int val) __attribute__((always_inline)) {

  1781. 		//serial_print("SPSR &= ");

  1782. 		//serial_phex(val);

  1783. 		//serial_print("\n");

  1784. 		if (!(val & (1<<SPI2X))) SPCRemulation::update_ctar(SPI0_CTAR0 &= ~SPI_CTAR_DBR);

  1785. 		return *this;

  1786. 	}

  1787. 	inline int operator & (int val) const __attribute__((always_inline)) {

  1788. 		int ret = 0;

  1789. 		//serial_print("SPSR & ");

  1790. 		//serial_phex(val);

  1791. 		//serial_print("\n");

  1792. 		// TODO: using SPI_SR_TCF isn't quite right.  Control returns to the

  1793. 		// caller after the final edge that captures data, which is 1/2 cycle

  1794. 		// sooner than AVR returns.  At 500 kHz and slower SPI, this can make

  1795. 		// a difference when digitalWrite is used to manually control the CS

  1796. 		// pin, and perhaps it could matter at high clocks if faster register

  1797. 		// access is used?  But does it really matter?  Do any SPI chips in

  1798. 		// practice really perform differently if CS negates early, after the

  1799. 		// final bit is clocked, but before the end of the whole clock cycle?

  1800. 		if ((val & (1<<SPIF)) && (SPI0_SR & SPI_SR_TCF)) ret = (1<<SPIF);

  1801. 		if ((val & (1<<SPI2X)) && (SPI0_CTAR0 & SPI_CTAR_DBR)) ret |= (1<<SPI2X);

  1802. 		//delayMicroseconds(50000);

  1803. 		return ret;

  1804. 	}

  1805. 	operator int () const __attribute__((always_inline)) {

  1806. 		int ret = 0;

  1807. 		//serial_print("SPSR (int)\n");

  1808. 		if (SPI0_SR & SPI_SR_TCF) ret = (1<<SPIF);

  1809. 		if (SPI0_CTAR0 & SPI_CTAR_DBR) ret |= (1<<SPI2X);

  1810. 		return ret;

  1811. 	}

  1812. };

  1813. extern SPSRemulation SPSR;

  1814. 

  1815. class SPDRemulation

  1816. {

  1817. public:

  1818. 	inline SPDRemulation & operator = (int val) __attribute__((always_inline)) {

  1819. 		//serial_print("SPDR = ");

  1820. 		//serial_phex(val);

  1821. 		//serial_print("\n");

  1822. 		SPI0_MCR |= SPI_MCR_CLR_RXF; // discard any received data

  1823. 		SPI0_SR = SPI_SR_TCF;

  1824. 		//SPI0_SR = SPI_SR_EOQF;

  1825. 		//SPI0_PUSHR = (val & 255) | SPI0_PUSHR_EOQ;

  1826. 		SPI0_PUSHR = (val & 255);

  1827. 		return *this;

  1828. 	}

  1829. 	operator int () const __attribute__((always_inline)) {

  1830. 		uint32_t val;

  1831. 		val = SPI0_POPR & 255;

  1832. 		//serial_print("SPDR (int) ");

  1833. 		//serial_phex(val);

  1834. 		//serial_print("\n");

  1835. 		return val;

  1836. 	}

  1837. };

  1838. extern SPDRemulation SPDR;

  1839. 

  1840. 

  1841. 

  1842. 

  1843. 

  1844. #elif defined(KINETISL)

  1845. 

  1846. // SPI Control Register ­ SPCR

  1847. //#define SPIE	7	// SPI Interrupt Enable - not supported

  1848. //#define SPE	6	// SPI Enable

  1849. //#define DORD	5	// DORD: Data Order

  1850. //#define MSTR	4	// MSTR: Master/Slave Select

  1851. //#define CPOL	3	// CPOL: Clock Polarity

  1852. //#define CPHA	2	// CPHA: Clock Phase

  1853. //#define SPR1	1	// Clock: 3 = 125 kHz, 2 = 250 kHz, 1 = 1 MHz, 0->4 MHz

  1854. //#define SPR0	0

  1855. // SPI Status Register ­ SPSR

  1856. //#define SPIF	7	// SPIF: SPI Interrupt Flag

  1857. //#define WCOL	6	// WCOL: Write COLlision Flag - not implemented

  1858. //#define SPI2X	0	// SPI2X: Double SPI Speed Bit

  1859. // SPI Data Register ­ SPDR

  1860. 

  1861. 

  1862. class SPCRemulation

  1863. {

  1864. public:

  1865. 	inline SPCRemulation & operator = (int val) __attribute__((always_inline)) {

  1866. 		uint32_t sim4 = SIM_SCGC4;

  1867. 		if (!(sim4 & SIM_SCGC4_SPI0)) {

  1868. 			SIM_SCGC4 = sim4 | SIM_SCGC4_SPI0;

  1869. 			SPI0_BR = SPI_BR_SPR(0) | SPI_BR_SPPR(1);

  1870. 		}

  1871. 		uint32_t c1 = 0;

  1872. 		if (val & (1<<DORD))  c1 |= SPI_C1_LSBFE;

  1873. 		if (val & (1<<CPOL))  c1 |= SPI_C1_CPOL;

  1874. 		if (val & (1<<CPHA))  c1 |= SPI_C1_CPHA;

  1875. 		if (val & (1<<MSTR))  c1 |= SPI_C1_MSTR;

  1876. 		if (val & (1<<SPE))   c1 |= SPI_C1_SPE;

  1877. 		SPI0_C1 = c1;

  1878. 		SPI0_C2 = 0;

  1879. 		uint32_t br = SPI0_BR & 0x10;

  1880. 		switch (val & 3) {

  1881. 		  case 0:  SPI0_BR = br | SPI_BR_SPR(0); break;

  1882. 		  case 1:  SPI0_BR = br | SPI_BR_SPR(2); break;

  1883. 		  case 2:  SPI0_BR = br | SPI_BR_SPR(4); break;

  1884. 		  default: SPI0_BR = br | SPI_BR_SPR(5); break;

  1885. 		}

  1886. 		if (val & (1<<SPE)) enable_pins();

  1887. 		else disable_pins();

  1888. 		return *this;

  1889. 	}

  1890. 	inline SPCRemulation & operator |= (int val) __attribute__((always_inline)) {

  1891. 		uint32_t sim4 = SIM_SCGC4;

  1892. 		if (!(sim4 & SIM_SCGC4_SPI0)) {

  1893. 			SIM_SCGC4 = sim4 | SIM_SCGC4_SPI0;

  1894. 			SPI0_BR = SPI_BR_SPR(0) | SPI_BR_SPPR(1);

  1895. 		}

  1896. 		uint32_t c1 = SPI0_C1;

  1897. 		if (val & (1<<DORD))  c1 |= SPI_C1_LSBFE;

  1898. 		if (val & (1<<CPOL))  c1 |= SPI_C1_CPOL;

  1899. 		if (val & (1<<CPHA))  c1 |= SPI_C1_CPHA;

  1900. 		if (val & (1<<MSTR))  c1 |= SPI_C1_MSTR;

  1901. 		if (val & (1<<SPE)) {

  1902. 			enable_pins();

  1903. 			c1 |= SPI_C1_SPE;

  1904. 		}

  1905. 		SPI0_C1 = c1;

  1906. 		SPI0_C2 = 0;

  1907. 		val &= 3;

  1908. 		if (val) {

  1909. 			uint32_t br = SPI0_BR;

  1910. 			uint32_t bits = baud2avr(br) | val;

  1911. 			br &= 0x10;

  1912. 			switch (bits) {

  1913. 			  case 0:  SPI0_BR = br | SPI_BR_SPR(0); break;

  1914. 			  case 1:  SPI0_BR = br | SPI_BR_SPR(2); break;

  1915. 			  case 2:  SPI0_BR = br | SPI_BR_SPR(4); break;

  1916. 			  default: SPI0_BR = br | SPI_BR_SPR(5); break;

  1917. 			}

  1918. 		}

  1919. 		return *this;

  1920. 	}

  1921. 	inline SPCRemulation & operator &= (int val) __attribute__((always_inline)) {

  1922. 		uint32_t sim4 = SIM_SCGC4;

  1923. 		if (!(sim4 & SIM_SCGC4_SPI0)) {

  1924. 			SIM_SCGC4 = sim4 | SIM_SCGC4_SPI0;

  1925. 			SPI0_BR = SPI_BR_SPR(0) | SPI_BR_SPPR(1);

  1926. 		}

  1927. 		uint32_t c1 = SPI0_C1;

  1928. 		if (!(val & (1<<DORD)))  c1 &= ~SPI_C1_LSBFE;

  1929. 		if (!(val & (1<<CPOL)))  c1 &= ~SPI_C1_CPOL;

  1930. 		if (!(val & (1<<CPHA)))  c1 &= ~SPI_C1_CPHA;

  1931. 		if (!(val & (1<<MSTR)))  c1 &= ~SPI_C1_MSTR;

  1932. 		if (!(val & (1<<SPE))) {

  1933. 			disable_pins();

  1934. 			c1 &= ~SPI_C1_SPE;

  1935. 		}

  1936. 		SPI0_C1 = c1;

  1937. 		SPI0_C2 = 0;

  1938. 		val &= 3;

  1939. 		if (val < 3) {

  1940. 			uint32_t br = SPI0_BR;

  1941. 			uint32_t bits = baud2avr(br) & val;

  1942. 			br &= 0x10;

  1943. 			switch (bits) {

  1944. 			  case 0:  SPI0_BR = br | SPI_BR_SPR(0); break;

  1945. 			  case 1:  SPI0_BR = br | SPI_BR_SPR(2); break;

  1946. 			  case 2:  SPI0_BR = br | SPI_BR_SPR(4); break;

  1947. 			  default: SPI0_BR = br | SPI_BR_SPR(5); break;

  1948. 			}

  1949. 		}

  1950. 		return *this;

  1951. 	}

  1952. 	inline int operator & (int val) const __attribute__((always_inline)) {

  1953. 		int ret = 0;

  1954. 		uint32_t sim4 = SIM_SCGC4;

  1955. 		if (!(sim4 & SIM_SCGC4_SPI0)) {

  1956. 			SIM_SCGC4 = sim4 | SIM_SCGC4_SPI0;

  1957. 			SPI0_BR = SPI_BR_SPR(0) | SPI_BR_SPPR(1);

  1958. 		}

  1959. 		uint32_t c1 = SPI0_C1;

  1960. 		if ((val & (1<<DORD)) && (c1 & SPI_C1_LSBFE)) ret |= (1<<DORD);

  1961. 		if ((val & (1<<CPOL)) && (c1 & SPI_C1_CPOL))  ret |= (1<<CPOL);

  1962. 		if ((val & (1<<CPHA)) && (c1 & SPI_C1_CPHA))  ret |= (1<<CPHA);

  1963. 		if ((val & (1<<MSTR)) && (c1 & SPI_C1_MSTR))  ret |= (1<<MSTR);

  1964. 		if ((val & (1<<SPE))  && (c1 & SPI_C1_SPE))   ret |= (1<<SPE);

  1965. 		uint32_t bits = baud2avr(SPI0_BR);

  1966. 		if ((val & (1<<SPR1)) && (bits & (1<<SPR1)))  ret |= (1<<SPR1);

  1967. 		if ((val & (1<<SPR0)) && (bits & (1<<SPR0)))  ret |= (1<<SPR0);

  1968. 		return ret;

  1969. 	}

  1970. 	operator int () const __attribute__((always_inline)) {

  1971. 		int ret = 0;

  1972. 		uint32_t sim4 = SIM_SCGC4;

  1973. 		if (!(sim4 & SIM_SCGC4_SPI0)) {

  1974. 			SIM_SCGC4 = sim4 | SIM_SCGC4_SPI0;

  1975. 			SPI0_BR = SPI_BR_SPR(0) | SPI_BR_SPPR(1);

  1976. 		}

  1977. 		uint32_t c1 = SPI0_C1;

  1978. 		if ((c1 & SPI_C1_LSBFE)) ret |= (1<<DORD);

  1979. 		if ((c1 & SPI_C1_CPOL))  ret |= (1<<CPOL);

  1980. 		if ((c1 & SPI_C1_CPHA))  ret |= (1<<CPHA);

  1981. 		if ((c1 & SPI_C1_MSTR))  ret |= (1<<MSTR);

  1982. 		if ((c1 & SPI_C1_SPE))   ret |= (1<<SPE);

  1983. 		ret |= baud2avr(SPI0_BR);

  1984. 		return ret;

  1985. 	}

  1986. 	inline void setMOSI(uint8_t pin) __attribute__((always_inline)) {

  1987. 		uint8_t newpinout = pinout;

  1988. 		if (pin == 11) newpinout &= ~1;

  1989. 		if (pin == 7) newpinout |= 1;

  1990. 		if ((SIM_SCGC4 & SIM_SCGC4_SPI0) && newpinout != pinout) {

  1991. 			if ((newpinout & 1) == 0) {

  1992. 				CORE_PIN7_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1993. 				CORE_PIN11_CONFIG = PORT_PCR_DSE | PORT_PCR_MUX(2);

  1994. 			} else {

  1995. 				CORE_PIN11_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  1996. 				CORE_PIN7_CONFIG = PORT_PCR_MUX(2);

  1997. 			}

  1998. 		}

  1999. 		pinout = newpinout;

  2000. 	}

  2001. 	inline void setMISO(uint8_t pin) __attribute__((always_inline)) {

  2002. 		uint8_t newpinout = pinout;

  2003. 		if (pin == 12) newpinout &= ~2;

  2004. 		if (pin == 8) newpinout |= 2;

  2005. 		if ((SIM_SCGC4 & SIM_SCGC4_SPI0) && newpinout != pinout) {

  2006. 			if ((newpinout & 2) == 0) {

  2007. 				CORE_PIN8_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  2008. 				CORE_PIN12_CONFIG = PORT_PCR_MUX(2);

  2009. 			} else {

  2010. 				CORE_PIN12_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  2011. 				CORE_PIN8_CONFIG = PORT_PCR_MUX(2);

  2012. 			}

  2013. 		}

  2014. 		pinout = newpinout;

  2015. 	}

  2016. 	inline void setSCK(uint8_t pin) __attribute__((always_inline)) {

  2017. 		uint8_t newpinout = pinout;

  2018. 		if (pin == 13) newpinout &= ~4;

  2019. 		if (pin == 14) newpinout |= 4;

  2020. 		if ((SIM_SCGC4 & SIM_SCGC4_SPI0) && newpinout != pinout) {

  2021. 			if ((newpinout & 4) == 0) {

  2022. 				CORE_PIN14_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  2023. 				CORE_PIN13_CONFIG = PORT_PCR_DSE | PORT_PCR_MUX(2);

  2024. 			} else {

  2025. 				CORE_PIN13_CONFIG = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1);

  2026. 				CORE_PIN14_CONFIG = PORT_PCR_MUX(2);

  2027. 			}

  2028. 		}

  2029. 		pinout = newpinout;

  2030. 	}

  2031. 	friend class SPSRemulation;

  2032. 	friend class SPIFIFOclass;

  2033. private:

  2034. 	static inline uint32_t baud2avr(uint32_t br) __attribute__((always_inline)) {

  2035. 		br &= 15;

  2036. 		if (br == 0) return 0;

  2037. 		if (br <= 2) return 1;

  2038. 		if (br <= 4) return 2;

  2039. 		return 3;

  2040. 	}

  2041. 	static uint8_t pinout;

  2042. public:

  2043. 	inline void enable_pins(void) __attribute__((always_inline)) {

  2044. 		//serial_print("enable_pins\n");

  2045. 		if ((pinout & 1) == 0) {

  2046. 			CORE_PIN11_CONFIG = PORT_PCR_DSE | PORT_PCR_MUX(2); // MOSI0 = 11 (PTC6)

  2047. 		} else {

  2048. 			CORE_PIN7_CONFIG = PORT_PCR_MUX(2); // MOSI0 = 7 (PTD2)

  2049. 		}

  2050. 		if ((pinout & 2) == 0) {

  2051. 			CORE_PIN12_CONFIG = PORT_PCR_MUX(2);  // MISO0 = 12 (PTC7)

  2052. 		} else {

  2053. 			CORE_PIN8_CONFIG = PORT_PCR_MUX(2);  // MISO0 = 8 (PTD3)

  2054. 		}

  2055. 		if ((pinout & 4) == 0) {

  2056. 			CORE_PIN13_CONFIG = PORT_PCR_DSE | PORT_PCR_MUX(2); // SCK0 = 13 (PTC5)

  2057. 		} else {

  2058. 			CORE_PIN14_CONFIG = PORT_PCR_MUX(2); // SCK0 = 14 (PTD1)

  2059. 		}

  2060. 	}

  2061. 	inline void disable_pins(void) __attribute__((always_inline)) {

  2062. 		//serial_print("disable_pins\n");

  2063. 		if ((pinout & 1) == 0) {

  2064. 			CORE_PIN11_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  2065. 		} else {

  2066. 			CORE_PIN7_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  2067. 		}

  2068. 		if ((pinout & 2) == 0) {

  2069. 			CORE_PIN12_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  2070. 		} else {

  2071. 			CORE_PIN8_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  2072. 		}

  2073. 		if ((pinout & 4) == 0) {

  2074. 			CORE_PIN13_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  2075. 		} else {

  2076. 			CORE_PIN14_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  2077. 		}

  2078. 	}

  2079. };

  2080. extern SPCRemulation SPCR;

  2081. 

  2082. 

  2083. class SPCR1emulation

  2084. {

  2085. public:

  2086. 	inline void setMOSI(uint8_t pin) __attribute__((always_inline)) {

  2087. 		if (pin == 0) pinout &= ~1; // MOSI1 = 0  (PTB16)

  2088. 		if (pin == 21) pinout |= 1; // MOSI1 = 21 (PTD6)

  2089. 	}

  2090. 	inline void setMISO(uint8_t pin) __attribute__((always_inline)) {

  2091. 		if (pin == 1) pinout &= ~2; // MISO1 = 1  (PTB17)

  2092. 		if (pin == 5) pinout |= 2;  // MISO1 = 5  (PTD7)

  2093. 	}

  2094. 	inline void setSCK(uint8_t pin) __attribute__((always_inline)) {

  2095. 		// SCK1 = 20 (PTD5) - no alternative pin

  2096. 	}

  2097. 	inline void enable_pins(void) __attribute__((always_inline)) {

  2098. 		//serial_print("enable_pins\n");

  2099. 		if ((pinout & 1) == 0) {

  2100. 			CORE_PIN0_CONFIG = PORT_PCR_MUX(2);  // MOSI1 = 0  (PTB16)

  2101. 		} else {

  2102. 			CORE_PIN21_CONFIG = PORT_PCR_MUX(2); // MOSI1 = 21 (PTD6)

  2103. 		}

  2104. 		if ((pinout & 2) == 0) {

  2105. 			CORE_PIN1_CONFIG = PORT_PCR_MUX(2);  // MISO1 = 1  (PTB17)

  2106. 		} else {

  2107. 			CORE_PIN5_CONFIG = PORT_PCR_MUX(2);  // MISO1 = 5  (PTD7)

  2108. 		}

  2109. 		CORE_PIN20_CONFIG = PORT_PCR_MUX(2); // SCK1 = 20 (PTD5)

  2110. 	}

  2111. 	inline void disable_pins(void) __attribute__((always_inline)) {

  2112. 		//serial_print("disable_pins\n");

  2113. 		if ((pinout & 1) == 0) {

  2114. 			CORE_PIN0_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  2115. 		} else {

  2116. 			CORE_PIN21_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  2117. 		}

  2118. 		if ((pinout & 2) == 0) {

  2119. 			CORE_PIN1_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  2120. 		} else {

  2121. 			CORE_PIN5_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  2122. 		}

  2123. 		CORE_PIN20_CONFIG = PORT_PCR_SRE | PORT_PCR_MUX(1);

  2124. 	}

  2125. 	friend class SPIFIFO1class;

  2126. private:

  2127. 	static uint8_t pinout;

  2128. };

  2129. extern SPCR1emulation SPCR1;

  2130. 

  2131. 

  2132. class SPSRemulation

  2133. {

  2134. public:

  2135. 	inline SPSRemulation & operator = (int val) __attribute__((always_inline)) {

  2136. 		if (val & (1<<SPI2X)) {

  2137. 			SPI0_BR &= ~0x10;

  2138. 		} else {

  2139. 			SPI0_BR |= 0x10;

  2140. 		}

  2141. 		return *this;

  2142. 	}

  2143. 	inline SPSRemulation & operator |= (int val) __attribute__((always_inline)) {

  2144. 		if (val & (1<<SPI2X)) SPI0_BR &= ~0x10;

  2145. 		return *this;

  2146. 	}

  2147. 	inline SPSRemulation & operator &= (int val) __attribute__((always_inline)) {

  2148. 		if (!(val & (1<<SPI2X))) SPI0_BR |= 0x10;

  2149. 		return *this;

  2150. 	}

  2151. 	inline int operator & (int val) const __attribute__((always_inline)) {

  2152. 		int ret = 0;

  2153. 		if ((val & (1<<SPIF)) && (SPI0_S & SPI_S_SPRF)) ret = (1<<SPIF);

  2154. 		if ((val & (1<<SPI2X)) && (!(SPI0_BR & 0x10))) ret |= (1<<SPI2X);

  2155. 		return ret;

  2156. 	}

  2157. 	operator int () const __attribute__((always_inline)) {

  2158. 		int ret = 0;

  2159. 		if ((SPI0_S & SPI_S_SPRF)) ret = (1<<SPIF);

  2160. 		if (!(SPI0_BR & 0x10)) ret |= (1<<SPI2X);

  2161. 		return ret;

  2162. 	}

  2163. };

  2164. extern SPSRemulation SPSR;

  2165. 

  2166. 

  2167. class SPDRemulation

  2168. {

  2169. public:

  2170. 	inline SPDRemulation & operator = (int val) __attribute__((always_inline)) {

  2171. 		if ((SPI0_S & SPI_S_SPTEF)) {

  2172. 			uint32_t tmp __attribute__((unused)) = SPI0_DL;

  2173. 		}

  2174. 		SPI0_DL = val;

  2175. 		return *this;

  2176. 	}

  2177. 	operator int () const __attribute__((always_inline)) {

  2178. 		return SPI0_DL & 255;

  2179. 	}

  2180. };

  2181. extern SPDRemulation SPDR;

  2182. 

  2183. 

  2184. #endif // KINETISK

  2185. 

  2186. 

  2187. 

  2188. 

  2189. 

  2190. 

  2191. 

  2192. 

  2193. class SREGemulation

  2194. {

  2195. public:

  2196. 	operator int () const __attribute__((always_inline)) {

  2197. 		uint32_t primask;

  2198. 		asm volatile("mrs %0, primask\n" : "=r" (primask)::);

  2199. 		if (primask) return 0;

  2200. 		return (1<<7);

  2201. 	}

  2202. 	inline SREGemulation & operator = (int val) __attribute__((always_inline)) {

  2203. 		if (val & (1<<7)) {

  2204. 			__enable_irq();

  2205. 		} else {

  2206. 			__disable_irq();

  2207. 		}

  2208. 		return *this;

  2209. 	}

  2210. };

  2211. extern SREGemulation SREG;

  2212. 

  2213. 

  2214. 		// 22211

  2215. 		// 84062840

  2216. 		// 322111

  2217. 		// 17395173

  2218. #if defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)

  2219. 

  2220. #if defined(__MK20DX128__) || defined(__MK20DX256__)

  2221. #define EIMSK_pA 0x01000018 // pins 3, 4, 24

  2222. #define EIMSK_pB 0x020F0003 // pins 0, 1, 16-19, 25

  2223. #define EIMSK_pC 0x78C0BE00 // pins 9-13, 15, 22, 23, 27-30

  2224. #define EIMSK_pD 0x003041E4 // pins 2, 5-8, 14, 20, 21

  2225. #define EIMSK_pE 0x84000000 // pins 26, 31

  2226. #elif defined(__MK64FX512__) || defined(__MK66FX1M0__)

  2227. #define EIMSK_pA 0x1E000018 // pins 3, 4, 25-28

  2228. #define EIMSK_pB 0xE00F0003 // pins 0, 1, 16-19, 29-31

  2229. #define EIMSK_pC 0x00C0BE00 // pins 9-13, 15, 22, 23

  2230. #define EIMSK_pD 0x003041E4 // pins 2, 5-8, 14, 20, 21

  2231. #define EIMSK_pE 0x01000000 // pins 24

  2232. #endif

  2233. 

  2234. class EIMSKemulation  // used by Adafruit_nRF8001 (only supports INT for pins 0 to 31)

  2235. {

  2236. public:

  2237. 	operator int () const __attribute__((always_inline)) {

  2238. 		int mask = 0;

  2239. 		volatile const uint32_t *icer = &NVIC_ICER0;

  2240. 		if (icer[IRQ_PORTA >> 5] & (1 << (IRQ_PORTA & 31))) mask |= EIMSK_pA;

  2241. 		if (icer[IRQ_PORTB >> 5] & (1 << (IRQ_PORTB & 31))) mask |= EIMSK_pB;

  2242. 		if (icer[IRQ_PORTC >> 5] & (1 << (IRQ_PORTC & 31))) mask |= EIMSK_pC;

  2243. 		if (icer[IRQ_PORTD >> 5] & (1 << (IRQ_PORTD & 31))) mask |= EIMSK_pD;

  2244. 		if (icer[IRQ_PORTE >> 5] & (1 << (IRQ_PORTE & 31))) mask |= EIMSK_pE;

  2245. 		return mask;

  2246. 	}

  2247. 	inline EIMSKemulation & operator |= (int val) __attribute__((always_inline)) {

  2248. 		if (val & EIMSK_pA) NVIC_ENABLE_IRQ(IRQ_PORTA);

  2249. 		if (val & EIMSK_pB) NVIC_ENABLE_IRQ(IRQ_PORTB);

  2250. 		if (val & EIMSK_pC) NVIC_ENABLE_IRQ(IRQ_PORTC);

  2251. 		if (val & EIMSK_pD) NVIC_ENABLE_IRQ(IRQ_PORTD);

  2252. 		if (val & EIMSK_pE) NVIC_ENABLE_IRQ(IRQ_PORTE);

  2253. 		return *this;

  2254. 	}

  2255. 	inline EIMSKemulation & operator &= (int val) __attribute__((always_inline)) {

  2256. 		uint32_t n = val;

  2257. 		if ((n | ~EIMSK_pA) != 0xFFFFFFFF) NVIC_DISABLE_IRQ(IRQ_PORTA);

  2258. 		if ((n | ~EIMSK_pB) != 0xFFFFFFFF) NVIC_DISABLE_IRQ(IRQ_PORTB);

  2259. 		if ((n | ~EIMSK_pC) != 0xFFFFFFFF) NVIC_DISABLE_IRQ(IRQ_PORTC);

  2260. 		if ((n | ~EIMSK_pD) != 0xFFFFFFFF) NVIC_DISABLE_IRQ(IRQ_PORTD);

  2261. 		if ((n | ~EIMSK_pE) != 0xFFFFFFFF) NVIC_DISABLE_IRQ(IRQ_PORTE);

  2262. 		return *this;

  2263. 	}

  2264. };

  2265. extern EIMSKemulation EIMSK;

  2266. 

  2267. #elif defined(__MKL26Z64__)

  2268. 

  2269. #define EIMSK_pA 0x00000018 // pins 3, 4, 24

  2270. #define EIMSK_pC 0x00C0BE00 // pins 9-13, 15, 22, 23

  2271. #define EIMSK_pD 0x003041E4 // pins 2, 5-8, 14, 20, 21

  2272. 

  2273. class EIMSKemulation  // used by Adafruit_nRF8001

  2274. {

  2275. public:

  2276. 	operator int () const __attribute__((always_inline)) {

  2277. 		int mask = 0;

  2278. 		volatile const uint32_t *icer = &NVIC_ICER0;

  2279. 		if (icer[IRQ_PORTA >> 5] & (1 << (IRQ_PORTA & 31))) mask |= EIMSK_pA;

  2280. 		if (icer[IRQ_PORTCD >> 5] & (1 << (IRQ_PORTCD & 31))) mask |= (EIMSK_pC | EIMSK_pD);

  2281. 		return mask;

  2282. 	}

  2283. 	inline EIMSKemulation & operator |= (int val) __attribute__((always_inline)) {

  2284. 		if (val & EIMSK_pA) NVIC_ENABLE_IRQ(IRQ_PORTA);

  2285. 		if (val & (EIMSK_pC | EIMSK_pD)) NVIC_ENABLE_IRQ(IRQ_PORTCD);

  2286. 		return *this;

  2287. 	}

  2288. 	inline EIMSKemulation & operator &= (int val) __attribute__((always_inline)) {

  2289. 		uint32_t n = val;

  2290. 		if ((n | ~EIMSK_pA) != 0xFFFFFFFF) NVIC_DISABLE_IRQ(IRQ_PORTA);

  2291. 		if ((n | ~(EIMSK_pC | EIMSK_pD)) != 0xFFFFFFFF) NVIC_DISABLE_IRQ(IRQ_PORTCD);

  2292. 		return *this;

  2293. 	}

  2294. };

  2295. extern EIMSKemulation EIMSK;

  2296. 

  2297. #endif

  2298. 

  2299. 

  2300. // these are not intended for public consumption...

  2301. #undef GPIO_BITBAND_ADDR

  2302. #undef CONFIG_PULLUP

  2303. #undef CONFIG_NOPULLUP

  2304. #undef GPIO_SETBIT_ATOMIC

  2305. #undef GPIO_CLRBIT_ATOMIC

  2306. 

  2307. #endif // __cplusplus

  2308. 

  2309. #endif