visus
/
teensy-core-4.1
Следить 1
В избранное 0
Форкнуть 0
Код Задачи 0 Pull Request'ы 0 Релизы 0 Вики Активность
Teensy 4.1 core updated for C++20
Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
1320 коммитов
2 Ветки
Дерево: 0bd7c42af1
Ветки Теги
${ item.name }
Создать ветку ${ searchTerm }
из '0bd7c42af1'
${ noResults }
teensy-core-4.1/teensy4/startup.c

853 lines
29KB
Исходник Blame История 

  1. #include "imxrt.h"

  2. #include "wiring.h"

  3. #include "usb_dev.h"

  4. #include "avr/pgmspace.h"

  5. 

  6. #include "debug/printf.h"

  7. 

  8. // from the linker

  9. extern unsigned long _stextload;

  10. extern unsigned long _stext;

  11. extern unsigned long _etext;

  12. extern unsigned long _sdataload;

  13. extern unsigned long _sdata;

  14. extern unsigned long _edata;

  15. extern unsigned long _sbss;

  16. extern unsigned long _ebss;

  17. extern unsigned long _flexram_bank_config;

  18. extern unsigned long _estack;

  19. 

  20. __attribute__ ((used, aligned(1024)))

  21. void (* _VectorsRam[NVIC_NUM_INTERRUPTS+16])(void);

  22. 

  23. static void memory_copy(uint32_t *dest, const uint32_t *src, uint32_t *dest_end);

  24. static void memory_clear(uint32_t *dest, uint32_t *dest_end);

  25. static void configure_systick(void);

  26. static void reset_PFD();

  27. extern void systick_isr(void);

  28. extern void pendablesrvreq_isr(void);

  29. void configure_cache(void);

  30. void configure_external_ram(void);

  31. void unused_interrupt_vector(void);

  32. void usb_pll_start();

  33. extern void analog_init(void); // analog.c

  34. extern void pwm_init(void); // pwm.c

  35. extern void tempmon_init(void);  //tempmon.c

  36. uint32_t set_arm_clock(uint32_t frequency); // clockspeed.c

  37. extern void __libc_init_array(void); // C++ standard library

  38. 

  39. uint8_t external_psram_size = 0;

  40. 

  41. extern int main (void);

  42. void startup_default_early_hook(void) {}

  43. void startup_early_hook(void)		__attribute__ ((weak, alias("startup_default_early_hook")));

  44. void startup_default_late_hook(void) {}

  45. void startup_late_hook(void)		__attribute__ ((weak, alias("startup_default_late_hook")));

  46. __attribute__((section(".startup"), optimize("no-tree-loop-distribute-patterns"), naked))

  47. void ResetHandler(void)

  48. {

  49. 	unsigned int i;

  50. 

  51. #if defined(__IMXRT1062__)

  52. 	IOMUXC_GPR_GPR17 = (uint32_t)&_flexram_bank_config;

  53. 	IOMUXC_GPR_GPR16 = 0x00200007;

  54. 	IOMUXC_GPR_GPR14 = 0x00AA0000;

  55. 	__asm__ volatile("mov sp, %0" : : "r" ((uint32_t)&_estack) : );

  56. #endif

  57. 	PMU_MISC0_SET = 1<<3; //Use bandgap-based bias currents for best performance (Page 1175)

  58. 	// pin 13 - if startup crashes, use this to turn on the LED early for troubleshooting

  59. 	//IOMUXC_SW_MUX_CTL_PAD_GPIO_B0_03 = 5;

  60. 	//IOMUXC_SW_PAD_CTL_PAD_GPIO_B0_03 = IOMUXC_PAD_DSE(7);

  61. 	//IOMUXC_GPR_GPR27 = 0xFFFFFFFF;

  62. 	//GPIO7_GDIR |= (1<<3);

  63. 	//GPIO7_DR_SET = (1<<3); // digitalWrite(13, HIGH);

  64. 

  65. 	// Initialize memory

  66. 	memory_copy(&_stext, &_stextload, &_etext);

  67. 	memory_copy(&_sdata, &_sdataload, &_edata);

  68. 	memory_clear(&_sbss, &_ebss);

  69. 

  70. 	// enable FPU

  71. 	SCB_CPACR = 0x00F00000;

  72. 

  73. 	// set up blank interrupt & exception vector table

  74. 	for (i=0; i < NVIC_NUM_INTERRUPTS + 16; i++) _VectorsRam[i] = &unused_interrupt_vector;

  75. 	for (i=0; i < NVIC_NUM_INTERRUPTS; i++) NVIC_SET_PRIORITY(i, 128);

  76. 	SCB_VTOR = (uint32_t)_VectorsRam;

  77. 

  78. 	reset_PFD();

  79. 	

  80. 	// Configure clocks

  81. 	// TODO: make sure all affected peripherals are turned off!

  82. 	// PIT & GPT timers to run from 24 MHz clock (independent of CPU speed)

  83. 	CCM_CSCMR1 = (CCM_CSCMR1 & ~CCM_CSCMR1_PERCLK_PODF(0x3F)) | CCM_CSCMR1_PERCLK_CLK_SEL;

  84. 	// UARTs run from 24 MHz clock (works if PLL3 off or bypassed)

  85. 	CCM_CSCDR1 = (CCM_CSCDR1 & ~CCM_CSCDR1_UART_CLK_PODF(0x3F)) | CCM_CSCDR1_UART_CLK_SEL;

  86. 

  87. #if defined(__IMXRT1062__)

  88. 	// Use fast GPIO6, GPIO7, GPIO8, GPIO9

  89. 	IOMUXC_GPR_GPR26 = 0xFFFFFFFF;

  90. 	IOMUXC_GPR_GPR27 = 0xFFFFFFFF;

  91. 	IOMUXC_GPR_GPR28 = 0xFFFFFFFF;

  92. 	IOMUXC_GPR_GPR29 = 0xFFFFFFFF;

  93. #endif

  94. 

  95. 	// must enable PRINT_DEBUG_STUFF in debug/print.h

  96. 	printf_debug_init();

  97. 	printf("\n***********IMXRT Startup**********\n");

  98. 	printf("test %d %d %d\n", 1, -1234567, 3);

  99. 

  100. 	configure_cache();

  101. 	configure_systick();

  102. 	usb_pll_start();	

  103. 	reset_PFD(); //TODO: is this really needed?

  104. #ifdef F_CPU

  105. 	set_arm_clock(F_CPU);

  106. #endif

  107. 

  108. 	asm volatile("nop\n nop\n nop\n nop": : :"memory"); // why oh why?

  109. 

  110. 	// Undo PIT timer usage by ROM startup

  111. 	CCM_CCGR1 |= CCM_CCGR1_PIT(CCM_CCGR_ON);

  112. 	PIT_MCR = 0;

  113. 	PIT_TCTRL0 = 0;

  114. 	PIT_TCTRL1 = 0;

  115. 	PIT_TCTRL2 = 0;

  116. 	PIT_TCTRL3 = 0;

  117. 

  118. 	// initialize RTC

  119. 	if (!(SNVS_LPCR & SNVS_LPCR_SRTC_ENV)) {

  120. 		// if SRTC isn't running, start it with default Jan 1, 2019

  121. 		SNVS_LPSRTCLR = 1546300800u << 15;

  122. 		SNVS_LPSRTCMR = 1546300800u >> 17;

  123. 		SNVS_LPCR |= SNVS_LPCR_SRTC_ENV;

  124. 	}

  125. 	SNVS_HPCR |= SNVS_HPCR_RTC_EN | SNVS_HPCR_HP_TS;

  126. 

  127. #ifdef ARDUINO_TEENSY41

  128. 	configure_external_ram();

  129. #endif

  130. 	startup_early_hook();

  131. 	while (millis() < 20) ; // wait at least 20ms before starting USB

  132. 	usb_init();

  133. 	analog_init();

  134. 	pwm_init();

  135. 	tempmon_init();

  136. 

  137. 	startup_late_hook();

  138. 	while (millis() < 300) ; // wait at least 300ms before calling user code

  139. 	//printf("before C++ constructors\n");

  140. 	__libc_init_array();

  141. 	//printf("after C++ constructors\n");

  142. 	//printf("before setup\n");

  143. 	main();

  144. 	

  145. 	while (1) ;

  146. }

  147. 

  148. 

  149. 

  150. 

  151. // ARM SysTick is used for most Ardiuno timing functions, delay(), millis(),

  152. // micros().  SysTick can run from either the ARM core clock, or from an

  153. // "external" clock.  NXP documents it as "24 MHz XTALOSC can be the external

  154. // clock source of SYSTICK" (RT1052 ref manual, rev 1, page 411).  However,

  155. // NXP actually hid an undocumented divide-by-240 circuit in the hardware, so

  156. // the external clock is really 100 kHz.  We use this clock rather than the

  157. // ARM clock, to allow SysTick to maintain correct timing even when we change

  158. // the ARM clock to run at different speeds.

  159. #define SYSTICK_EXT_FREQ 100000

  160. 

  161. extern volatile uint32_t systick_cycle_count;

  162. static void configure_systick(void)

  163. {

  164. 	_VectorsRam[14] = pendablesrvreq_isr;

  165. 	_VectorsRam[15] = systick_isr;

  166. 	SYST_RVR = (SYSTICK_EXT_FREQ / 1000) - 1;

  167. 	SYST_CVR = 0;

  168. 	SYST_CSR = SYST_CSR_TICKINT | SYST_CSR_ENABLE;

  169. 	SCB_SHPR3 = 0x20200000;  // Systick, pendablesrvreq_isr = priority 32;

  170. 	ARM_DEMCR |= ARM_DEMCR_TRCENA;

  171. 	ARM_DWT_CTRL |= ARM_DWT_CTRL_CYCCNTENA; // turn on cycle counter

  172. 	systick_cycle_count = ARM_DWT_CYCCNT; // compiled 0, corrected w/1st systick

  173. }

  174. 

  175. 

  176. // concise defines for SCB_MPU_RASR and SCB_MPU_RBAR, ARM DDI0403E, pg 696

  177. #define NOEXEC		SCB_MPU_RASR_XN

  178. #define READONLY	SCB_MPU_RASR_AP(7)

  179. #define READWRITE	SCB_MPU_RASR_AP(3)

  180. #define NOACCESS	SCB_MPU_RASR_AP(0)

  181. #define MEM_CACHE_WT	SCB_MPU_RASR_TEX(0) | SCB_MPU_RASR_C

  182. #define MEM_CACHE_WB	SCB_MPU_RASR_TEX(0) | SCB_MPU_RASR_C | SCB_MPU_RASR_B

  183. #define MEM_CACHE_WBWA	SCB_MPU_RASR_TEX(1) | SCB_MPU_RASR_C | SCB_MPU_RASR_B

  184. #define MEM_NOCACHE	SCB_MPU_RASR_TEX(1)

  185. #define DEV_NOCACHE	SCB_MPU_RASR_TEX(2)

  186. #define SIZE_32B	(SCB_MPU_RASR_SIZE(4) | SCB_MPU_RASR_ENABLE)

  187. #define SIZE_64B	(SCB_MPU_RASR_SIZE(5) | SCB_MPU_RASR_ENABLE)

  188. #define SIZE_128B	(SCB_MPU_RASR_SIZE(6) | SCB_MPU_RASR_ENABLE)

  189. #define SIZE_256B	(SCB_MPU_RASR_SIZE(7) | SCB_MPU_RASR_ENABLE)

  190. #define SIZE_512B	(SCB_MPU_RASR_SIZE(8) | SCB_MPU_RASR_ENABLE)

  191. #define SIZE_1K		(SCB_MPU_RASR_SIZE(9) | SCB_MPU_RASR_ENABLE)

  192. #define SIZE_2K		(SCB_MPU_RASR_SIZE(10) | SCB_MPU_RASR_ENABLE)

  193. #define SIZE_4K		(SCB_MPU_RASR_SIZE(11) | SCB_MPU_RASR_ENABLE)

  194. #define SIZE_8K		(SCB_MPU_RASR_SIZE(12) | SCB_MPU_RASR_ENABLE)

  195. #define SIZE_16K	(SCB_MPU_RASR_SIZE(13) | SCB_MPU_RASR_ENABLE)

  196. #define SIZE_32K	(SCB_MPU_RASR_SIZE(14) | SCB_MPU_RASR_ENABLE)

  197. #define SIZE_64K	(SCB_MPU_RASR_SIZE(15) | SCB_MPU_RASR_ENABLE)

  198. #define SIZE_128K	(SCB_MPU_RASR_SIZE(16) | SCB_MPU_RASR_ENABLE)

  199. #define SIZE_256K	(SCB_MPU_RASR_SIZE(17) | SCB_MPU_RASR_ENABLE)

  200. #define SIZE_512K	(SCB_MPU_RASR_SIZE(18) | SCB_MPU_RASR_ENABLE)

  201. #define SIZE_1M		(SCB_MPU_RASR_SIZE(19) | SCB_MPU_RASR_ENABLE)

  202. #define SIZE_2M		(SCB_MPU_RASR_SIZE(20) | SCB_MPU_RASR_ENABLE)

  203. #define SIZE_4M		(SCB_MPU_RASR_SIZE(21) | SCB_MPU_RASR_ENABLE)

  204. #define SIZE_8M		(SCB_MPU_RASR_SIZE(22) | SCB_MPU_RASR_ENABLE)

  205. #define SIZE_16M	(SCB_MPU_RASR_SIZE(23) | SCB_MPU_RASR_ENABLE)

  206. #define SIZE_32M	(SCB_MPU_RASR_SIZE(24) | SCB_MPU_RASR_ENABLE)

  207. #define SIZE_64M	(SCB_MPU_RASR_SIZE(25) | SCB_MPU_RASR_ENABLE)

  208. #define SIZE_128M	(SCB_MPU_RASR_SIZE(26) | SCB_MPU_RASR_ENABLE)

  209. #define SIZE_256M	(SCB_MPU_RASR_SIZE(27) | SCB_MPU_RASR_ENABLE)

  210. #define SIZE_512M	(SCB_MPU_RASR_SIZE(28) | SCB_MPU_RASR_ENABLE)

  211. #define SIZE_1G		(SCB_MPU_RASR_SIZE(29) | SCB_MPU_RASR_ENABLE)

  212. #define SIZE_2G		(SCB_MPU_RASR_SIZE(30) | SCB_MPU_RASR_ENABLE)

  213. #define SIZE_4G		(SCB_MPU_RASR_SIZE(31) | SCB_MPU_RASR_ENABLE)

  214. #define REGION(n)	(SCB_MPU_RBAR_REGION(n) | SCB_MPU_RBAR_VALID)

  215. 

  216. FLASHMEM void configure_cache(void)

  217. {

  218. 	//printf("MPU_TYPE = %08lX\n", SCB_MPU_TYPE);

  219. 	//printf("CCR = %08lX\n", SCB_CCR);

  220. 

  221. 	// TODO: check if caches already active - skip?

  222. 

  223. 	SCB_MPU_CTRL = 0; // turn off MPU

  224. 

  225. 	uint32_t i = 0;

  226. 	SCB_MPU_RBAR = 0x00000000 | REGION(i++); //https://developer.arm.com/docs/146793866/10/why-does-the-cortex-m7-initiate-axim-read-accesses-to-memory-addresses-that-do-not-fall-under-a-defined-mpu-region

  227. 	SCB_MPU_RASR = SCB_MPU_RASR_TEX(0) | NOACCESS | NOEXEC | SIZE_4G;

  228. 	

  229. 	SCB_MPU_RBAR = 0x00000000 | REGION(i++); // ITCM

  230. 	SCB_MPU_RASR = MEM_NOCACHE | READWRITE | SIZE_512K;

  231. 

  232. 	// TODO: trap regions should be created last, because the hardware gives

  233. 	//  priority to the higher number ones.

  234. 	SCB_MPU_RBAR = 0x00000000 | REGION(i++); // trap NULL pointer deref

  235. 	SCB_MPU_RASR =  DEV_NOCACHE | NOACCESS | SIZE_32B;

  236. 

  237. 	SCB_MPU_RBAR = 0x00200000 | REGION(i++); // Boot ROM

  238. 	SCB_MPU_RASR = MEM_CACHE_WT | READONLY | SIZE_128K;

  239. 

  240. 	SCB_MPU_RBAR = 0x20000000 | REGION(i++); // DTCM

  241. 	SCB_MPU_RASR = MEM_NOCACHE | READWRITE | NOEXEC | SIZE_512K;

  242. 	

  243. 	SCB_MPU_RBAR = ((uint32_t)&_ebss) | REGION(i++); // trap stack overflow

  244. 	SCB_MPU_RASR = SCB_MPU_RASR_TEX(0) | NOACCESS | NOEXEC | SIZE_32B;

  245. 

  246. 	SCB_MPU_RBAR = 0x20200000 | REGION(i++); // RAM (AXI bus)

  247. 	SCB_MPU_RASR = MEM_CACHE_WBWA | READWRITE | NOEXEC | SIZE_1M;

  248. 

  249. 	SCB_MPU_RBAR = 0x40000000 | REGION(i++); // Peripherals

  250. 	SCB_MPU_RASR = DEV_NOCACHE | READWRITE | NOEXEC | SIZE_64M;

  251. 

  252. 	SCB_MPU_RBAR = 0x60000000 | REGION(i++); // QSPI Flash

  253. 	SCB_MPU_RASR = MEM_CACHE_WBWA | READONLY | SIZE_16M;

  254. 

  255. 	SCB_MPU_RBAR = 0x70000000 | REGION(i++); // FlexSPI2

  256. 	SCB_MPU_RASR = MEM_CACHE_WBWA | READONLY | NOEXEC | SIZE_256M;

  257. 

  258. 	SCB_MPU_RBAR = 0x70000000 | REGION(i++); // FlexSPI2

  259. 	SCB_MPU_RASR = MEM_CACHE_WBWA | READWRITE | NOEXEC | SIZE_16M;

  260. 

  261. 	// TODO: protect access to power supply config

  262. 

  263. 	SCB_MPU_CTRL = SCB_MPU_CTRL_ENABLE;

  264. 

  265. 	// cache enable, ARM DDI0403E, pg 628

  266. 	asm("dsb");

  267. 	asm("isb");

  268. 	SCB_CACHE_ICIALLU = 0;

  269. 

  270. 	asm("dsb");

  271. 	asm("isb");

  272. 	SCB_CCR |= (SCB_CCR_IC | SCB_CCR_DC);

  273. }

  274. 

  275. #ifdef ARDUINO_TEENSY41

  276. 

  277. #define LUT0(opcode, pads, operand) (FLEXSPI_LUT_INSTRUCTION((opcode), (pads), (operand)))

  278. #define LUT1(opcode, pads, operand) (FLEXSPI_LUT_INSTRUCTION((opcode), (pads), (operand)) << 16)

  279. #define CMD_SDR         FLEXSPI_LUT_OPCODE_CMD_SDR

  280. #define ADDR_SDR        FLEXSPI_LUT_OPCODE_RADDR_SDR

  281. #define READ_SDR        FLEXSPI_LUT_OPCODE_READ_SDR

  282. #define WRITE_SDR       FLEXSPI_LUT_OPCODE_WRITE_SDR

  283. #define DUMMY_SDR       FLEXSPI_LUT_OPCODE_DUMMY_SDR

  284. #define PINS1           FLEXSPI_LUT_NUM_PADS_1

  285. #define PINS4           FLEXSPI_LUT_NUM_PADS_4

  286. 

  287. FLASHMEM static void flexspi2_command(uint32_t index, uint32_t addr)

  288. {

  289. 	FLEXSPI2_IPCR0 = addr;

  290. 	FLEXSPI2_IPCR1 = FLEXSPI_IPCR1_ISEQID(index);

  291. 	FLEXSPI2_IPCMD = FLEXSPI_IPCMD_TRG;

  292. 	while (!(FLEXSPI2_INTR & FLEXSPI_INTR_IPCMDDONE)); // wait

  293. 	FLEXSPI2_INTR = FLEXSPI_INTR_IPCMDDONE;

  294. }

  295. 

  296. FLASHMEM static uint32_t flexspi2_psram_id(uint32_t addr)

  297. {

  298. 	FLEXSPI2_IPCR0 = addr;

  299. 	FLEXSPI2_IPCR1 = FLEXSPI_IPCR1_ISEQID(3) | FLEXSPI_IPCR1_IDATSZ(4);

  300. 	FLEXSPI2_IPCMD = FLEXSPI_IPCMD_TRG;

  301. 	while (!(FLEXSPI2_INTR & FLEXSPI_INTR_IPCMDDONE)); // wait

  302. 	uint32_t id = FLEXSPI2_RFDR0;

  303. 	FLEXSPI2_INTR = FLEXSPI_INTR_IPCMDDONE | FLEXSPI_INTR_IPRXWA;

  304. 	return id & 0xFFFF;

  305. }

  306. 

  307. FLASHMEM void configure_external_ram()

  308. {

  309. 	// initialize pins

  310. 	IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_22 = 0x1B0F9; // 100K pullup, strong drive, max speed, hyst

  311. 	IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_23 = 0x110F9; // keeper, strong drive, max speed, hyst

  312. 	IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_24 = 0x1B0F9; // 100K pullup, strong drive, max speed, hyst

  313. 	IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_25 = 0x100F9; // strong drive, max speed, hyst

  314. 	IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_26 = 0x170F9; // 47K pullup, strong drive, max speed, hyst

  315. 	IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_27 = 0x170F9; // 47K pullup, strong drive, max speed, hyst

  316. 	IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_28 = 0x170F9; // 47K pullup, strong drive, max speed, hyst

  317. 	IOMUXC_SW_PAD_CTL_PAD_GPIO_EMC_29 = 0x170F9; // 47K pullup, strong drive, max speed, hyst

  318. 

  319. 	IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_22 = 8 | 0x10; // ALT1 = FLEXSPI2_A_SS1_B (Flash)

  320. 	IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_23 = 8 | 0x10; // ALT1 = FLEXSPI2_A_DQS

  321. 	IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_24 = 8 | 0x10; // ALT1 = FLEXSPI2_A_SS0_B (RAM)

  322. 	IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_25 = 8 | 0x10; // ALT1 = FLEXSPI2_A_SCLK

  323. 	IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_26 = 8 | 0x10; // ALT1 = FLEXSPI2_A_DATA0

  324. 	IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_27 = 8 | 0x10; // ALT1 = FLEXSPI2_A_DATA1

  325. 	IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_28 = 8 | 0x10; // ALT1 = FLEXSPI2_A_DATA2

  326. 	IOMUXC_SW_MUX_CTL_PAD_GPIO_EMC_29 = 8 | 0x10; // ALT1 = FLEXSPI2_A_DATA3

  327. 

  328. 	IOMUXC_FLEXSPI2_IPP_IND_DQS_FA_SELECT_INPUT = 1; // GPIO_EMC_23 for Mode: ALT8, pg 986

  329. 	IOMUXC_FLEXSPI2_IPP_IND_IO_FA_BIT0_SELECT_INPUT = 1; // GPIO_EMC_26 for Mode: ALT8

  330. 	IOMUXC_FLEXSPI2_IPP_IND_IO_FA_BIT1_SELECT_INPUT = 1; // GPIO_EMC_27 for Mode: ALT8

  331. 	IOMUXC_FLEXSPI2_IPP_IND_IO_FA_BIT2_SELECT_INPUT = 1; // GPIO_EMC_28 for Mode: ALT8

  332. 	IOMUXC_FLEXSPI2_IPP_IND_IO_FA_BIT3_SELECT_INPUT = 1; // GPIO_EMC_29 for Mode: ALT8

  333. 	IOMUXC_FLEXSPI2_IPP_IND_SCK_FA_SELECT_INPUT = 1; // GPIO_EMC_25 for Mode: ALT8

  334. 

  335. 	// turn on clock  (TODO: increase clock speed later, slow & cautious for first release)

  336. 	CCM_CBCMR = (CCM_CBCMR & ~(CCM_CBCMR_FLEXSPI2_PODF_MASK | CCM_CBCMR_FLEXSPI2_CLK_SEL_MASK))

  337. 		| CCM_CBCMR_FLEXSPI2_PODF(5) | CCM_CBCMR_FLEXSPI2_CLK_SEL(3); // 88 MHz

  338. 	CCM_CCGR7 |= CCM_CCGR7_FLEXSPI2(CCM_CCGR_ON);

  339. 

  340. 	FLEXSPI2_MCR0 |= FLEXSPI_MCR0_MDIS;

  341. 	FLEXSPI2_MCR0 = (FLEXSPI2_MCR0 & ~(FLEXSPI_MCR0_AHBGRANTWAIT_MASK

  342. 		 | FLEXSPI_MCR0_IPGRANTWAIT_MASK | FLEXSPI_MCR0_SCKFREERUNEN

  343. 		 | FLEXSPI_MCR0_COMBINATIONEN | FLEXSPI_MCR0_DOZEEN

  344. 		 | FLEXSPI_MCR0_HSEN | FLEXSPI_MCR0_ATDFEN | FLEXSPI_MCR0_ARDFEN

  345. 		 | FLEXSPI_MCR0_RXCLKSRC_MASK | FLEXSPI_MCR0_SWRESET))

  346. 		| FLEXSPI_MCR0_AHBGRANTWAIT(0xFF) | FLEXSPI_MCR0_IPGRANTWAIT(0xFF)

  347. 		| FLEXSPI_MCR0_RXCLKSRC(1) | FLEXSPI_MCR0_MDIS;

  348. 	FLEXSPI2_MCR1 = FLEXSPI_MCR1_SEQWAIT(0xFFFF) | FLEXSPI_MCR1_AHBBUSWAIT(0xFFFF);

  349. 	FLEXSPI2_MCR2 = (FLEXSPI_MCR2 & ~(FLEXSPI_MCR2_RESUMEWAIT_MASK

  350. 		 | FLEXSPI_MCR2_SCKBDIFFOPT | FLEXSPI_MCR2_SAMEDEVICEEN

  351. 		 | FLEXSPI_MCR2_CLRLEARNPHASE | FLEXSPI_MCR2_CLRAHBBUFOPT))

  352. 		| FLEXSPI_MCR2_RESUMEWAIT(0x20) /*| FLEXSPI_MCR2_SAMEDEVICEEN*/;

  353. 

  354. 	FLEXSPI2_AHBCR = FLEXSPI2_AHBCR & ~(FLEXSPI_AHBCR_READADDROPT | FLEXSPI_AHBCR_PREFETCHEN

  355. 		| FLEXSPI_AHBCR_BUFFERABLEEN | FLEXSPI_AHBCR_CACHABLEEN);

  356. 	uint32_t mask = (FLEXSPI_AHBRXBUFCR0_PREFETCHEN | FLEXSPI_AHBRXBUFCR0_PRIORITY_MASK

  357. 		| FLEXSPI_AHBRXBUFCR0_MSTRID_MASK | FLEXSPI_AHBRXBUFCR0_BUFSZ_MASK);

  358. 	FLEXSPI2_AHBRXBUF0CR0 = (FLEXSPI2_AHBRXBUF0CR0 & ~mask)

  359. 		| FLEXSPI_AHBRXBUFCR0_PREFETCHEN | FLEXSPI_AHBRXBUFCR0_BUFSZ(64);

  360. 	FLEXSPI2_AHBRXBUF1CR0 = (FLEXSPI2_AHBRXBUF0CR0 & ~mask)

  361. 		| FLEXSPI_AHBRXBUFCR0_PREFETCHEN | FLEXSPI_AHBRXBUFCR0_BUFSZ(64);

  362. 	FLEXSPI2_AHBRXBUF2CR0 = mask;

  363. 	FLEXSPI2_AHBRXBUF3CR0 = mask;

  364. 

  365. 	// RX watermark = one 64 bit line

  366. 	FLEXSPI2_IPRXFCR = (FLEXSPI_IPRXFCR & 0xFFFFFFC0) | FLEXSPI_IPRXFCR_CLRIPRXF;

  367. 	// TX watermark = one 64 bit line

  368. 	FLEXSPI2_IPTXFCR = (FLEXSPI_IPTXFCR & 0xFFFFFFC0) | FLEXSPI_IPTXFCR_CLRIPTXF;

  369. 

  370. 	FLEXSPI2_INTEN = 0;

  371. 	FLEXSPI2_FLSHA1CR0 = 0x2000; // 8 MByte

  372. 	FLEXSPI2_FLSHA1CR1 = FLEXSPI_FLSHCR1_CSINTERVAL(2)

  373. 		| FLEXSPI_FLSHCR1_TCSH(3) | FLEXSPI_FLSHCR1_TCSS(3);

  374. 	FLEXSPI2_FLSHA1CR2 = FLEXSPI_FLSHCR2_AWRSEQID(6) | FLEXSPI_FLSHCR2_AWRSEQNUM(0)

  375. 		| FLEXSPI_FLSHCR2_ARDSEQID(5) | FLEXSPI_FLSHCR2_ARDSEQNUM(0);

  376. 

  377. 	FLEXSPI2_FLSHA2CR0 = 0x2000; // 8 MByte

  378. 	FLEXSPI2_FLSHA2CR1 = FLEXSPI_FLSHCR1_CSINTERVAL(2)

  379. 		| FLEXSPI_FLSHCR1_TCSH(3) | FLEXSPI_FLSHCR1_TCSS(3);

  380. 	FLEXSPI2_FLSHA2CR2 = FLEXSPI_FLSHCR2_AWRSEQID(6) | FLEXSPI_FLSHCR2_AWRSEQNUM(0)

  381. 		| FLEXSPI_FLSHCR2_ARDSEQID(5) | FLEXSPI_FLSHCR2_ARDSEQNUM(0);

  382. 

  383. 	FLEXSPI2_MCR0 &= ~FLEXSPI_MCR0_MDIS;

  384. 

  385. 	FLEXSPI2_LUTKEY = FLEXSPI_LUTKEY_VALUE;

  386. 	FLEXSPI2_LUTCR = FLEXSPI_LUTCR_UNLOCK;

  387. 	volatile uint32_t *luttable = &FLEXSPI2_LUT0;

  388. 	for (int i=0; i < 64; i++) luttable[i] = 0;

  389. 	FLEXSPI2_MCR0 |= FLEXSPI_MCR0_SWRESET;

  390. 	while (FLEXSPI2_MCR0 & FLEXSPI_MCR0_SWRESET) ; // wait

  391. 

  392. 	FLEXSPI2_LUTKEY = FLEXSPI_LUTKEY_VALUE;

  393. 	FLEXSPI2_LUTCR = FLEXSPI_LUTCR_UNLOCK;

  394. 

  395. 	// cmd index 0 = exit QPI mode

  396. 	FLEXSPI2_LUT0 = LUT0(CMD_SDR, PINS4, 0xF5);

  397. 	// cmd index 1 = reset enable

  398. 	FLEXSPI2_LUT4 = LUT0(CMD_SDR, PINS1, 0x66);

  399. 	// cmd index 2 = reset

  400. 	FLEXSPI2_LUT8 = LUT0(CMD_SDR, PINS1, 0x99);

  401. 	// cmd index 3 = read ID bytes

  402. 	FLEXSPI2_LUT12 = LUT0(CMD_SDR, PINS1, 0x9F) | LUT1(DUMMY_SDR, PINS1, 24);

  403. 	FLEXSPI2_LUT13 = LUT0(READ_SDR, PINS1, 1);

  404. 	// cmd index 4 = enter QPI mode

  405. 	FLEXSPI2_LUT16 = LUT0(CMD_SDR, PINS1, 0x35);

  406. 	// cmd index 5 = read QPI

  407. 	FLEXSPI2_LUT20 = LUT0(CMD_SDR, PINS4, 0xEB) | LUT1(ADDR_SDR, PINS4, 24);

  408. 	FLEXSPI2_LUT21 = LUT0(DUMMY_SDR, PINS4, 6) | LUT1(READ_SDR, PINS4, 1);

  409. 	// cmd index 6 = write QPI

  410. 	FLEXSPI2_LUT24 = LUT0(CMD_SDR, PINS4, 0x38) | LUT1(ADDR_SDR, PINS4, 24);

  411. 	FLEXSPI2_LUT25 = LUT0(WRITE_SDR, PINS4, 1);

  412. 

  413. 	// look for the first PSRAM chip

  414. 	flexspi2_command(0, 0); // exit quad mode

  415. 	flexspi2_command(1, 0); // reset enable

  416. 	flexspi2_command(2, 0); // reset (is this really necessary?)

  417. 	if (flexspi2_psram_id(0) == 0x5D0D) {

  418. 		// first PSRAM chip is present, look for a second PSRAM chip

  419. 		flexspi2_command(4, 0);

  420. 		flexspi2_command(0, 0x800000); // exit quad mode

  421. 		flexspi2_command(1, 0x800000); // reset enable

  422. 		flexspi2_command(2, 0x800000); // reset (is this really necessary?)

  423. 		if (flexspi2_psram_id(0x800000) == 0x5D0D) {

  424. 			flexspi2_command(4, 0x800000);

  425. 			// Two PSRAM chips are present, 16 MByte

  426. 			external_psram_size = 16;

  427. 		} else {

  428. 			// One PSRAM chip is present, 8 MByte

  429. 			external_psram_size = 8;

  430. 		}

  431. 		// TODO: zero uninitialized EXTMEM variables

  432. 		// TODO: copy from flash to initialize EXTMEM variables

  433. 		// TODO: set up for malloc_extmem()

  434. 	} else {

  435. 		// No PSRAM

  436. 	}

  437. }

  438. 

  439. #endif // ARDUINO_TEENSY41

  440. 

  441. 

  442. FLASHMEM void usb_pll_start()

  443. {

  444. 	while (1) {

  445. 		uint32_t n = CCM_ANALOG_PLL_USB1; // pg 759

  446. 		printf("CCM_ANALOG_PLL_USB1=%08lX\n", n);

  447. 		if (n & CCM_ANALOG_PLL_USB1_DIV_SELECT) {

  448. 			printf("  ERROR, 528 MHz mode!\n"); // never supposed to use this mode!

  449. 			CCM_ANALOG_PLL_USB1_CLR = 0xC000;			// bypass 24 MHz

  450. 			CCM_ANALOG_PLL_USB1_SET = CCM_ANALOG_PLL_USB1_BYPASS;	// bypass

  451. 			CCM_ANALOG_PLL_USB1_CLR = CCM_ANALOG_PLL_USB1_POWER |	// power down

  452. 				CCM_ANALOG_PLL_USB1_DIV_SELECT |		// use 480 MHz

  453. 				CCM_ANALOG_PLL_USB1_ENABLE |			// disable

  454. 				CCM_ANALOG_PLL_USB1_EN_USB_CLKS;		// disable usb

  455. 			continue;

  456. 		}

  457. 		if (!(n & CCM_ANALOG_PLL_USB1_ENABLE)) {

  458. 			printf("  enable PLL\n");

  459. 			// TODO: should this be done so early, or later??

  460. 			CCM_ANALOG_PLL_USB1_SET = CCM_ANALOG_PLL_USB1_ENABLE;

  461. 			continue;

  462. 		}

  463. 		if (!(n & CCM_ANALOG_PLL_USB1_POWER)) {

  464. 			printf("  power up PLL\n");

  465. 			CCM_ANALOG_PLL_USB1_SET = CCM_ANALOG_PLL_USB1_POWER;

  466. 			continue;

  467. 		}

  468. 		if (!(n & CCM_ANALOG_PLL_USB1_LOCK)) {

  469. 			printf("  wait for lock\n");

  470. 			continue;

  471. 		}

  472. 		if (n & CCM_ANALOG_PLL_USB1_BYPASS) {

  473. 			printf("  turn off bypass\n");

  474. 			CCM_ANALOG_PLL_USB1_CLR = CCM_ANALOG_PLL_USB1_BYPASS;

  475. 			continue;

  476. 		}

  477. 		if (!(n & CCM_ANALOG_PLL_USB1_EN_USB_CLKS)) {

  478. 			printf("  enable USB clocks\n");

  479. 			CCM_ANALOG_PLL_USB1_SET = CCM_ANALOG_PLL_USB1_EN_USB_CLKS;

  480. 			continue;

  481. 		}

  482. 		return; // everything is as it should be  :-)

  483. 	}

  484. }

  485. 

  486. FLASHMEM void reset_PFD()

  487. {	

  488. 	//Reset PLL2 PFDs, set default frequencies:

  489. 	CCM_ANALOG_PFD_528_SET = (1 << 31) | (1 << 23) | (1 << 15) | (1 << 7);

  490. 	CCM_ANALOG_PFD_528 = 0x2018101B; // PFD0:352, PFD1:594, PFD2:396, PFD3:297 MHz 	

  491. 	//PLL3:

  492. 	CCM_ANALOG_PFD_480_SET = (1 << 31) | (1 << 23) | (1 << 15) | (1 << 7);	

  493. 	CCM_ANALOG_PFD_480 = 0x13110D0C; // PFD0:720, PFD1:664, PFD2:508, PFD3:454 MHz

  494. }

  495. 

  496. // Stack frame

  497. //  xPSR

  498. //  ReturnAddress

  499. //  LR (R14) - typically FFFFFFF9 for IRQ or Exception

  500. //  R12

  501. //  R3

  502. //  R2

  503. //  R1

  504. //  R0

  505. // Code from :: https://community.nxp.com/thread/389002

  506. __attribute__((naked))

  507. void unused_interrupt_vector(void)

  508. {

  509.   __asm( ".syntax unified\n"

  510.          "MOVS R0, #4 \n"

  511.          "MOV R1, LR \n"

  512.          "TST R0, R1 \n"

  513.          "BEQ _MSP \n"

  514.          "MRS R0, PSP \n"

  515.          "B HardFault_HandlerC \n"

  516.          "_MSP: \n"

  517.          "MRS R0, MSP \n"

  518.          "B HardFault_HandlerC \n"

  519.          ".syntax divided\n") ;

  520. }

  521. 

  522. __attribute__((weak))

  523. void HardFault_HandlerC(unsigned int *hardfault_args)

  524. {

  525.   volatile unsigned int nn ;

  526. #ifdef PRINT_DEBUG_STUFF

  527.   volatile unsigned int stacked_r0 ;

  528.   volatile unsigned int stacked_r1 ;

  529.   volatile unsigned int stacked_r2 ;

  530.   volatile unsigned int stacked_r3 ;

  531.   volatile unsigned int stacked_r12 ;

  532.   volatile unsigned int stacked_lr ;

  533.   volatile unsigned int stacked_pc ;

  534.   volatile unsigned int stacked_psr ;

  535.   volatile unsigned int _CFSR ;

  536.   volatile unsigned int _HFSR ;

  537.   volatile unsigned int _DFSR ;

  538.   volatile unsigned int _AFSR ;

  539.   volatile unsigned int _BFAR ;

  540.   volatile unsigned int _MMAR ;

  541.   volatile unsigned int addr ;

  542. 

  543.   stacked_r0 = ((unsigned int)hardfault_args[0]) ;

  544.   stacked_r1 = ((unsigned int)hardfault_args[1]) ;

  545.   stacked_r2 = ((unsigned int)hardfault_args[2]) ;

  546.   stacked_r3 = ((unsigned int)hardfault_args[3]) ;

  547.   stacked_r12 = ((unsigned int)hardfault_args[4]) ;

  548.   stacked_lr = ((unsigned int)hardfault_args[5]) ;

  549.   stacked_pc = ((unsigned int)hardfault_args[6]) ;

  550.   stacked_psr = ((unsigned int)hardfault_args[7]) ;

  551.   // Configurable Fault Status Register

  552.   // Consists of MMSR, BFSR and UFSR

  553.   //(n & ( 1 << k )) >> k

  554.   _CFSR = (*((volatile unsigned int *)(0xE000ED28))) ;  

  555.   // Hard Fault Status Register

  556.   _HFSR = (*((volatile unsigned int *)(0xE000ED2C))) ;

  557.   // Debug Fault Status Register

  558.   _DFSR = (*((volatile unsigned int *)(0xE000ED30))) ;

  559.   // Auxiliary Fault Status Register

  560.   _AFSR = (*((volatile unsigned int *)(0xE000ED3C))) ;

  561.   // Read the Fault Address Registers. These may not contain valid values.

  562.   // Check BFARVALID/MMARVALID to see if they are valid values

  563.   // MemManage Fault Address Register

  564.   _MMAR = (*((volatile unsigned int *)(0xE000ED34))) ;

  565.   // Bus Fault Address Register

  566.   _BFAR = (*((volatile unsigned int *)(0xE000ED38))) ;

  567.   //__asm("BKPT #0\n") ; // Break into the debugger // NO Debugger here.

  568. 

  569.   asm volatile("mrs %0, ipsr\n" : "=r" (addr)::);

  570.   printf("\nFault irq %d\n", addr & 0x1FF);

  571.   printf(" stacked_r0 ::  %x\n", stacked_r0);

  572.   printf(" stacked_r1 ::  %x\n", stacked_r1);

  573.   printf(" stacked_r2 ::  %x\n", stacked_r2);

  574.   printf(" stacked_r3 ::  %x\n", stacked_r3);

  575.   printf(" stacked_r12 ::  %x\n", stacked_r12);

  576.   printf(" stacked_lr ::  %x\n", stacked_lr);

  577.   printf(" stacked_pc ::  %x\n", stacked_pc);

  578.   printf(" stacked_psr ::  %x\n", stacked_psr);

  579.   printf(" _CFSR ::  %x\n", _CFSR);

  580.  

  581.   if(_CFSR > 0){

  582. 	  //Memory Management Faults

  583. 	  if((_CFSR & 1) == 1){

  584. 		printf("      (IACCVIOL) Instruction Access Violation\n");

  585. 	  } else  if(((_CFSR & (0x02))>>1) == 1){

  586. 		printf("      (DACCVIOL) Data Access Violation\n");

  587. 	  } else if(((_CFSR & (0x08))>>3) == 1){

  588. 		printf("      (MUNSTKERR) MemMange Fault on Unstacking\n");

  589. 	  } else if(((_CFSR & (0x10))>>4) == 1){

  590. 		printf("      (MSTKERR) MemMange Fault on stacking\n");

  591. 	  } else if(((_CFSR & (0x20))>>5) == 1){

  592. 		printf("      (MLSPERR) MemMange Fault on FP Lazy State\n");

  593. 	  }

  594. 	  if(((_CFSR & (0x80))>>7) == 1){

  595. 		printf("      (MMARVALID) MemMange Fault Address Valid\n");

  596. 	  }

  597. 	  //Bus Fault Status Register

  598. 	  if(((_CFSR & 0x100)>>8) == 1){

  599. 		printf("      (IBUSERR) Instruction Bus Error\n");

  600. 	  } else  if(((_CFSR & (0x200))>>9) == 1){

  601. 		printf("      (PRECISERR) Data bus error(address in BFAR)\n");

  602. 	  } else if(((_CFSR & (0x400))>>10) == 1){

  603. 		printf("      (IMPRECISERR) Data bus error but address not related to instruction\n");

  604. 	  } else if(((_CFSR & (0x800))>>11) == 1){

  605. 		printf("      (UNSTKERR) Bus Fault on unstacking for a return from exception \n");

  606. 	  } else if(((_CFSR & (0x1000))>>12) == 1){

  607. 		printf("      (STKERR) Bus Fault on stacking for exception entry\n");

  608. 	  } else if(((_CFSR & (0x2000))>>13) == 1){

  609. 		printf("      (LSPERR) Bus Fault on FP lazy state preservation\n");

  610. 	  }

  611. 	  if(((_CFSR & (0x8000))>>15) == 1){

  612. 		printf("      (BFARVALID) Bus Fault Address Valid\n");

  613. 	  }  

  614. 	  //Usuage Fault Status Register

  615. 	  if(((_CFSR & 0x10000)>>16) == 1){

  616. 		printf("      (UNDEFINSTR) Undefined instruction\n");

  617. 	  } else  if(((_CFSR & (0x20000))>>17) == 1){

  618. 		printf("      (INVSTATE) Instruction makes illegal use of EPSR)\n");

  619. 	  } else if(((_CFSR & (0x40000))>>18) == 1){

  620. 		printf("      (INVPC) Usage fault: invalid EXC_RETURN\n");

  621. 	  } else if(((_CFSR & (0x80000))>>19) == 1){

  622. 		printf("      (NOCP) No Coprocessor \n");

  623. 	  } else if(((_CFSR & (0x1000000))>>24) == 1){

  624. 		printf("      (UNALIGNED) Unaligned access UsageFault\n");

  625. 	  } else if(((_CFSR & (0x2000000))>>25) == 1){

  626. 		printf("      (DIVBYZERO) Divide by zero\n");

  627. 	  }

  628.   }

  629.   printf(" _HFSR ::  %x\n", _HFSR);

  630.   if(_HFSR > 0){

  631. 	  //Memory Management Faults

  632. 	  if(((_HFSR & (0x02))>>1) == 1){

  633. 		printf("      (VECTTBL) Bus Fault on Vec Table Read\n");

  634. 	  } else if(((_HFSR & (0x40000000))>>30) == 1){

  635. 		printf("      (FORCED) Forced Hard Fault\n");

  636. 	  } else if(((_HFSR & (0x80000000))>>31) == 31){

  637. 		printf("      (DEBUGEVT) Reserved for Debug\n");

  638. 	  } 

  639.   }

  640.   printf(" _DFSR ::  %x\n", _DFSR);

  641.   printf(" _AFSR ::  %x\n", _AFSR);

  642.   printf(" _BFAR ::  %x\n", _BFAR);

  643.   printf(" _MMAR ::  %x\n", _MMAR);

  644. #endif

  645. 

  646.   IOMUXC_SW_MUX_CTL_PAD_GPIO_B0_03 = 5; // pin 13

  647.   IOMUXC_SW_PAD_CTL_PAD_GPIO_B0_03 = IOMUXC_PAD_DSE(7);

  648.   GPIO2_GDIR |= (1 << 3);

  649.   GPIO2_DR_SET = (1 << 3);

  650.   GPIO2_DR_CLEAR = (1 << 3); //digitalWrite(13, LOW);

  651. 

  652.   if ( F_CPU_ACTUAL >= 600000000 )

  653.     set_arm_clock(300000000);

  654. 

  655.   while (1)

  656.   {

  657.     GPIO2_DR_SET = (1 << 3); //digitalWrite(13, HIGH);

  658.     // digitalWrite(13, HIGH);

  659.     for (nn = 0; nn < 2000000/2; nn++) ;

  660.     GPIO2_DR_CLEAR = (1 << 3); //digitalWrite(13, LOW);

  661.     // digitalWrite(13, LOW);

  662.     for (nn = 0; nn < 18000000/2; nn++) ;

  663.   }

  664. }

  665. 

  666. __attribute__((weak))

  667. void userDebugDump(){

  668. 	volatile unsigned int nn;

  669. 	printf("\nuserDebugDump() in startup.c ___ \n");

  670. 

  671.   while (1)

  672.   {

  673.     GPIO2_DR_SET = (1 << 3); //digitalWrite(13, HIGH);

  674.     // digitalWrite(13, HIGH);

  675.     for (nn = 0; nn < 2000000; nn++) ;

  676.     GPIO2_DR_CLEAR = (1 << 3); //digitalWrite(13, LOW);

  677. 	// digitalWrite(13, LOW);

  678.     for (nn = 0; nn < 18000000; nn++) ;

  679.     GPIO2_DR_SET = (1 << 3); //digitalWrite(13, HIGH);

  680.     // digitalWrite(13, HIGH);

  681.     for (nn = 0; nn < 20000000; nn++) ;

  682.     GPIO2_DR_CLEAR = (1 << 3); //digitalWrite(13, LOW);

  683. 	// digitalWrite(13, LOW);

  684.     for (nn = 0; nn < 10000000; nn++) ;

  685.   }

  686. }

  687. 

  688. __attribute__((weak))

  689. void PJRCunused_interrupt_vector(void)

  690. {

  691. 	// TODO: polling Serial to complete buffered transmits

  692. #ifdef PRINT_DEBUG_STUFF

  693. 	uint32_t addr;

  694. 	asm volatile("mrs %0, ipsr\n" : "=r" (addr)::);

  695. 	printf("\nirq %d\n", addr & 0x1FF);

  696. 	asm("ldr %0, [sp, #52]" : "=r" (addr) ::);

  697. 	printf(" %x\n", addr);

  698. 	asm("ldr %0, [sp, #48]" : "=r" (addr) ::);

  699. 	printf(" %x\n", addr);

  700. 	asm("ldr %0, [sp, #44]" : "=r" (addr) ::);

  701. 	printf(" %x\n", addr);

  702. 	asm("ldr %0, [sp, #40]" : "=r" (addr) ::);

  703. 	printf(" %x\n", addr);

  704. 	asm("ldr %0, [sp, #36]" : "=r" (addr) ::);

  705. 	printf(" %x\n", addr);

  706. 	asm("ldr %0, [sp, #33]" : "=r" (addr) ::);

  707. 	printf(" %x\n", addr);

  708. 	asm("ldr %0, [sp, #34]" : "=r" (addr) ::);

  709. 	printf(" %x\n", addr);

  710. 	asm("ldr %0, [sp, #28]" : "=r" (addr) ::);

  711. 	printf(" %x\n", addr);

  712. 	asm("ldr %0, [sp, #24]" : "=r" (addr) ::);

  713. 	printf(" %x\n", addr);

  714. 	asm("ldr %0, [sp, #20]" : "=r" (addr) ::);

  715. 	printf(" %x\n", addr);

  716. 	asm("ldr %0, [sp, #16]" : "=r" (addr) ::);

  717. 	printf(" %x\n", addr);

  718. 	asm("ldr %0, [sp, #12]" : "=r" (addr) ::);

  719. 	printf(" %x\n", addr);

  720. 	asm("ldr %0, [sp, #8]" : "=r" (addr) ::);

  721. 	printf(" %x\n", addr);

  722. 	asm("ldr %0, [sp, #4]" : "=r" (addr) ::);

  723. 	printf(" %x\n", addr);

  724. 	asm("ldr %0, [sp, #0]" : "=r" (addr) ::);

  725. 	printf(" %x\n", addr);

  726. #endif

  727. #if 1

  728. 	if ( F_CPU_ACTUAL >= 600000000 )

  729. 		set_arm_clock(100000000);

  730. 	IOMUXC_SW_MUX_CTL_PAD_GPIO_B0_03 = 5; // pin 13

  731. 	IOMUXC_SW_PAD_CTL_PAD_GPIO_B0_03 = IOMUXC_PAD_DSE(7);

  732. 	GPIO2_GDIR |= (1<<3);

  733. 	GPIO2_DR_SET = (1<<3);

  734. 	while (1) {

  735. 		volatile uint32_t n;

  736. 		GPIO2_DR_SET = (1<<3); //digitalWrite(13, HIGH);

  737. 		for (n=0; n < 2000000/6; n++) ;

  738. 		GPIO2_DR_CLEAR = (1<<3); //digitalWrite(13, LOW);

  739. 		for (n=0; n < 1500000/6; n++) ;

  740. 	}

  741. #else

  742. 	if ( F_CPU_ACTUAL >= 600000000 )

  743. 		set_arm_clock(100000000);

  744. 	while (1) asm ("WFI");

  745. #endif

  746. }

  747. 

  748. __attribute__((section(".startup"), optimize("no-tree-loop-distribute-patterns")))

  749. static void memory_copy(uint32_t *dest, const uint32_t *src, uint32_t *dest_end)

  750. {

  751. 	if (dest == src) return;

  752. 	while (dest < dest_end) {

  753. 		*dest++ = *src++;

  754. 	}

  755. }

  756. 

  757. __attribute__((section(".startup"), optimize("no-tree-loop-distribute-patterns")))

  758. static void memory_clear(uint32_t *dest, uint32_t *dest_end)

  759. {

  760. 	while (dest < dest_end) {

  761. 		*dest++ = 0;

  762. 	}

  763. }

  764. 

  765. 

  766. 

  767. // syscall functions need to be in the same C file as the entry point "ResetVector"

  768. // otherwise the linker will discard them in some cases.

  769. 

  770. #include <errno.h>

  771. 

  772. // from the linker script

  773. extern unsigned long _heap_start;

  774. extern unsigned long _heap_end;

  775. 

  776. char *__brkval = (char *)&_heap_start;

  777. 

  778. void * _sbrk(int incr)

  779. {

  780.         char *prev = __brkval;

  781.         if (incr != 0) {

  782.                 if (prev + incr > (char *)&_heap_end) {

  783.                         errno = ENOMEM;

  784.                         return (void *)-1;

  785.                 }

  786.                 __brkval = prev + incr;

  787.         }

  788.         return prev;

  789. }

  790. 

  791. __attribute__((weak))

  792. int _read(int file, char *ptr, int len)

  793. {

  794. 	return 0;

  795. }

  796. 

  797. __attribute__((weak))

  798. int _close(int fd)

  799. {

  800. 	return -1;

  801. }

  802. 

  803. #include <sys/stat.h>

  804. 

  805. __attribute__((weak))

  806. int _fstat(int fd, struct stat *st)

  807. {

  808. 	st->st_mode = S_IFCHR;

  809. 	return 0;

  810. }

  811. 

  812. __attribute__((weak))

  813. int _isatty(int fd)

  814. {

  815. 	return 1;

  816. }

  817. 

  818. __attribute__((weak))

  819. int _lseek(int fd, long long offset, int whence)

  820. {

  821. 	return -1;

  822. }

  823. 

  824. __attribute__((weak))

  825. void _exit(int status)

  826. {

  827. 	while (1) asm ("WFI");

  828. }

  829. 

  830. __attribute__((weak))

  831. void __cxa_pure_virtual()

  832. {

  833. 	while (1) asm ("WFI");

  834. }

  835. 

  836. __attribute__((weak))

  837. int __cxa_guard_acquire (char *g)

  838. {

  839. 	return !(*g);

  840. }

  841. 

  842. __attribute__((weak))

  843. void __cxa_guard_release(char *g)

  844. {

  845. 	*g = 1;

  846. }

  847. 

  848. __attribute__((weak))

  849. void abort(void)

  850. {

  851. 	while (1) asm ("WFI");

  852. }