Upgrade to new chopstx
[gnuk/neug.git] / src / sys.c
1 /*
2  * sys.c - system routines for the initial page for STM32F103.
3  *
4  * Copyright (C) 2013 Flying Stone Technology
5  * Author: NIIBE Yutaka <gniibe@fsij.org>
6  *
7  * Copying and distribution of this file, with or without modification,
8  * are permitted in any medium without royalty provided the copyright
9  * notice and this notice are preserved.  This file is offered as-is,
10  * without any warranty.
11  *
12  * When the flash ROM is protected, we cannot modify the initial page.
13  * We put some system routines (which is useful for any program) here.
14  */
15
16 #include <stdint.h>
17 #include <stdlib.h>
18 #include "board.h"
19
20
21 #define CORTEX_PRIORITY_BITS    4
22 #define CORTEX_PRIORITY_MASK(n)  ((n) << (8 - CORTEX_PRIORITY_BITS))
23 #define USB_LP_CAN1_RX0_IRQn     20
24 #define STM32_USB_IRQ_PRIORITY   11
25
26
27 #define STM32_SW_PLL            (2 << 0)
28 #define STM32_PLLSRC_HSE        (1 << 16)
29
30 #define STM32_PLLXTPRE_DIV1     (0 << 17)
31 #define STM32_PLLXTPRE_DIV2     (1 << 17)
32
33 #define STM32_HPRE_DIV1         (0 << 4)
34
35 #define STM32_PPRE1_DIV2        (4 << 8)
36
37 #define STM32_PPRE2_DIV1        (0 << 11)
38 #define STM32_PPRE2_DIV2        (4 << 11)
39
40 #define STM32_ADCPRE_DIV4       (1 << 14)
41 #define STM32_ADCPRE_DIV6       (2 << 14)
42
43 #define STM32_USBPRE_DIV1P5     (0 << 22)
44
45 #define STM32_MCO_NOCLOCK       (0 << 24)
46
47 #define STM32_SW                STM32_SW_PLL
48 #define STM32_PLLSRC            STM32_PLLSRC_HSE
49 #define STM32_HPRE              STM32_HPRE_DIV1
50 #define STM32_PPRE1             STM32_PPRE1_DIV2
51 #define STM32_PPRE2             STM32_PPRE2_DIV1
52 #define STM32_ADCPRE            STM32_ADCPRE_DIV6
53 #define STM32_MCOSEL            STM32_MCO_NOCLOCK
54 #define STM32_USBPRE            STM32_USBPRE_DIV1P5
55
56 #define STM32_PLLCLKIN          (STM32_HSECLK / 1)
57 #define STM32_PLLMUL            ((STM32_PLLMUL_VALUE - 2) << 18)
58 #define STM32_PLLCLKOUT         (STM32_PLLCLKIN * STM32_PLLMUL_VALUE)
59 #define STM32_SYSCLK            STM32_PLLCLKOUT
60 #define STM32_HCLK              (STM32_SYSCLK / 1)
61
62 #define STM32_FLASHBITS         0x00000012
63
64 struct NVIC {
65   uint32_t ISER[8];
66   uint32_t unused1[24];
67   uint32_t ICER[8];
68   uint32_t unused2[24];
69   uint32_t ISPR[8];
70   uint32_t unused3[24];
71   uint32_t ICPR[8];
72   uint32_t unused4[24];
73   uint32_t IABR[8];
74   uint32_t unused5[56];
75   uint32_t IPR[60];
76 };
77
78 static struct NVIC *const NVICBase = ((struct NVIC *const)0xE000E100);
79 #define NVIC_ISER(n)    (NVICBase->ISER[n >> 5])
80 #define NVIC_ICPR(n)    (NVICBase->ICPR[n >> 5])
81 #define NVIC_IPR(n)     (NVICBase->IPR[n >> 2])
82
83 static void
84 nvic_enable_vector (uint32_t n, uint32_t prio)
85 {
86   unsigned int sh = (n & 3) << 3;
87
88   NVIC_IPR (n) = (NVIC_IPR(n) & ~(0xFF << sh)) | (prio << sh);
89   NVIC_ICPR (n) = 1 << (n & 0x1F);
90   NVIC_ISER (n) = 1 << (n & 0x1F);
91 }
92
93
94 #define PERIPH_BASE     0x40000000
95 #define APB2PERIPH_BASE (PERIPH_BASE + 0x10000)
96 #define AHBPERIPH_BASE  (PERIPH_BASE + 0x20000)
97
98 struct RCC {
99   volatile uint32_t CR;
100   volatile uint32_t CFGR;
101   volatile uint32_t CIR;
102   volatile uint32_t APB2RSTR;
103   volatile uint32_t APB1RSTR;
104   volatile uint32_t AHBENR;
105   volatile uint32_t APB2ENR;
106   volatile uint32_t APB1ENR;
107   volatile uint32_t BDCR;
108   volatile uint32_t CSR;
109 };
110
111 #define RCC_BASE                (AHBPERIPH_BASE + 0x1000)
112 static struct RCC *const RCC = ((struct RCC *const)RCC_BASE);
113
114 #define RCC_APB1ENR_USBEN       0x00800000
115 #define RCC_APB1RSTR_USBRST     0x00800000
116
117 #define RCC_CR_HSION            0x00000001
118 #define RCC_CR_HSIRDY           0x00000002
119 #define RCC_CR_HSITRIM          0x000000F8
120 #define RCC_CR_HSEON            0x00010000
121 #define RCC_CR_HSERDY           0x00020000
122 #define RCC_CR_PLLON            0x01000000
123 #define RCC_CR_PLLRDY           0x02000000
124
125 #define RCC_CFGR_SWS            0x0000000C
126 #define RCC_CFGR_SWS_HSI        0x00000000
127
128 #define RCC_AHBENR_CRCEN        0x0040
129
130 struct FLASH {
131   volatile uint32_t ACR;
132   volatile uint32_t KEYR;
133   volatile uint32_t OPTKEYR;
134   volatile uint32_t SR;
135   volatile uint32_t CR;
136   volatile uint32_t AR;
137   volatile uint32_t RESERVED;
138   volatile uint32_t OBR;
139   volatile uint32_t WRPR;
140 };
141
142 #define FLASH_R_BASE    (AHBPERIPH_BASE + 0x2000)
143 static struct FLASH *const FLASH = ((struct FLASH *const) FLASH_R_BASE);
144
145 static void
146 clock_init (void)
147 {
148   /* HSI setup */
149   RCC->CR |= RCC_CR_HSION;
150   while (!(RCC->CR & RCC_CR_HSIRDY))
151     ;
152   RCC->CR &= RCC_CR_HSITRIM | RCC_CR_HSION;
153   RCC->CFGR = 0;
154   while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_HSI)
155     ;
156
157   /* HSE setup */
158   RCC->CR |= RCC_CR_HSEON;
159   while (!(RCC->CR & RCC_CR_HSERDY))
160     ;
161
162   /* PLL setup */
163   RCC->CFGR |= STM32_PLLMUL | STM32_PLLXTPRE | STM32_PLLSRC;
164   RCC->CR   |= RCC_CR_PLLON;
165   while (!(RCC->CR & RCC_CR_PLLRDY))
166     ;
167
168   /* Clock settings */
169   RCC->CFGR = STM32_MCOSEL | STM32_USBPRE | STM32_PLLMUL | STM32_PLLXTPRE
170     | STM32_PLLSRC | STM32_ADCPRE | STM32_PPRE2 | STM32_PPRE1 | STM32_HPRE;
171
172   /* Flash setup */
173   FLASH->ACR = STM32_FLASHBITS;
174
175   /* CRC */
176   RCC->AHBENR |= RCC_AHBENR_CRCEN;
177
178   /* Switching on the configured clock source. */
179   RCC->CFGR |= STM32_SW;
180   while ((RCC->CFGR & RCC_CFGR_SWS) != (STM32_SW << 2))
181     ;
182 }
183
184 #define RCC_APB2RSTR_AFIORST    0x00000001
185 #define RCC_APB2RSTR_IOPARST    0x00000004
186 #define RCC_APB2RSTR_IOPBRST    0x00000008
187 #define RCC_APB2RSTR_IOPCRST    0x00000010
188 #define RCC_APB2RSTR_IOPDRST    0x00000020
189
190 #define RCC_APB2ENR_AFIOEN      0x00000001
191 #define RCC_APB2ENR_IOPAEN      0x00000004
192 #define RCC_APB2ENR_IOPBEN      0x00000008
193 #define RCC_APB2ENR_IOPCEN      0x00000010
194 #define RCC_APB2ENR_IOPDEN      0x00000020
195
196
197 struct AFIO
198 {
199   volatile uint32_t EVCR;
200   volatile uint32_t MAPR;
201   volatile uint32_t EXTICR[4];
202   uint32_t RESERVED0;
203   volatile uint32_t MAPR2;
204 };
205
206 #define AFIO_BASE 0x40010000
207 static struct AFIO *const AFIO = (struct AFIO *const)AFIO_BASE;
208
209 #define AFIO_MAPR_TIM3_REMAP_PARTIALREMAP 0x00000800
210
211
212 struct GPIO {
213   volatile uint32_t CRL;
214   volatile uint32_t CRH;
215   volatile uint32_t IDR;
216   volatile uint32_t ODR;
217   volatile uint32_t BSRR;
218   volatile uint32_t BRR;
219   volatile uint32_t LCKR;
220 };
221
222 #define GPIOA_BASE      (APB2PERIPH_BASE + 0x0800)
223 #define GPIOA           ((struct GPIO *) GPIOA_BASE)
224 #define GPIOB_BASE      (APB2PERIPH_BASE + 0x0C00)
225 #define GPIOB           ((struct GPIO *) GPIOB_BASE)
226 #define GPIOC_BASE      (APB2PERIPH_BASE + 0x1000)
227 #define GPIOC           ((struct GPIO *) GPIOC_BASE)
228 #define GPIOD_BASE      (APB2PERIPH_BASE + 0x1400)
229 #define GPIOD           ((struct GPIO *) GPIOD_BASE)
230 #define GPIOE_BASE      (APB2PERIPH_BASE + 0x1800)
231 #define GPIOE           ((struct GPIO *) GPIOE_BASE)
232
233 static struct GPIO *const GPIO_USB = ((struct GPIO *const) GPIO_USB_BASE);
234 static struct GPIO *const GPIO_LED = ((struct GPIO *const) GPIO_LED_BASE);
235 #ifdef GPIO_OTHER_BASE
236 static struct GPIO *const GPIO_OTHER = ((struct GPIO *const) GPIO_OTHER_BASE);
237 #endif
238
239 static void
240 gpio_init (void)
241 {
242   /* Enable GPIO clock. */
243   RCC->APB2ENR |= RCC_APB2ENR_IOP_EN;
244   RCC->APB2RSTR = RCC_APB2RSTR_IOP_RST;
245   RCC->APB2RSTR = 0;
246
247 #ifdef AFIO_MAPR_SOMETHING
248   AFIO->MAPR |= AFIO_MAPR_SOMETHING;
249 #endif
250
251   GPIO_USB->ODR = VAL_GPIO_ODR;
252   GPIO_USB->CRH = VAL_GPIO_CRH;
253   GPIO_USB->CRL = VAL_GPIO_CRL;
254
255 #if GPIO_USB_BASE != GPIO_LED_BASE
256   GPIO_LED->ODR = VAL_GPIO_LED_ODR;
257   GPIO_LED->CRH = VAL_GPIO_LED_CRH;
258   GPIO_LED->CRL = VAL_GPIO_LED_CRL;
259 #endif
260
261 #ifdef GPIO_OTHER_BASE
262   GPIO_OTHER->ODR = VAL_GPIO_OTHER_ODR;
263   GPIO_OTHER->CRH = VAL_GPIO_OTHER_CRH;
264   GPIO_OTHER->CRL = VAL_GPIO_OTHER_CRL;
265 #endif
266 }
267
268 static void
269 usb_cable_config (int enable)
270 {
271 #if defined(GPIO_USB_SET_TO_ENABLE)
272   if (enable)
273     GPIO_USB->BSRR = (1 << GPIO_USB_SET_TO_ENABLE);
274   else
275     GPIO_USB->BRR = (1 << GPIO_USB_SET_TO_ENABLE);
276 #elif defined(GPIO_USB_CLEAR_TO_ENABLE)
277   if (enable)
278     GPIO_USB->BRR = (1 << GPIO_USB_CLEAR_TO_ENABLE);
279   else
280     GPIO_USB->BSRR = (1 << GPIO_USB_CLEAR_TO_ENABLE);
281 #else
282   (void)enable;
283 #endif
284 }
285
286 void
287 set_led (int on)
288 {
289 #if defined(GPIO_LED_CLEAR_TO_EMIT)
290   if (on)
291     GPIO_LED->BRR = (1 << GPIO_LED_CLEAR_TO_EMIT);
292   else
293     GPIO_LED->BSRR = (1 << GPIO_LED_CLEAR_TO_EMIT);
294 #else
295   if (on)
296     GPIO_LED->BSRR = (1 << GPIO_LED_SET_TO_EMIT);
297   else
298     GPIO_LED->BRR = (1 << GPIO_LED_SET_TO_EMIT);
299 #endif
300 }
301
302 static void wait (int count)
303 {
304   int i;
305
306   for (i = 0; i < count; i++)
307     asm volatile ("" : : "r" (i) : "memory");
308 }
309
310
311 static void
312 usb_lld_sys_shutdown (void)
313 {
314   RCC->APB1ENR &= ~RCC_APB1ENR_USBEN;
315   RCC->APB1RSTR = RCC_APB1RSTR_USBRST;
316   usb_cable_config (0);
317 }
318
319 static void
320 usb_lld_sys_init (void)
321 {
322   if ((RCC->APB1ENR & RCC_APB1ENR_USBEN)
323       && (RCC->APB1RSTR & RCC_APB1RSTR_USBRST) == 0)
324     /* Make sure the device is disconnected, even after core reset.  */
325     {
326       usb_lld_sys_shutdown ();
327       /* Disconnect requires SE0 (>= 2.5uS).  */
328       wait (300);
329     }
330
331   usb_cable_config (1);
332   RCC->APB1ENR |= RCC_APB1ENR_USBEN;
333   nvic_enable_vector (USB_LP_CAN1_RX0_IRQn,
334                       CORTEX_PRIORITY_MASK (STM32_USB_IRQ_PRIORITY));
335   /*
336    * Note that we also have other IRQ(s):
337    *    USB_HP_CAN1_TX_IRQn (for double-buffered or isochronous)
338    *    USBWakeUp_IRQn (suspend/resume)
339    */
340   RCC->APB1RSTR = RCC_APB1RSTR_USBRST;
341   RCC->APB1RSTR = 0;
342 }
343
344 #define FLASH_KEY1               0x45670123UL
345 #define FLASH_KEY2               0xCDEF89ABUL
346
347 enum flash_status
348 {
349   FLASH_BUSY = 1,
350   FLASH_ERROR_PG,
351   FLASH_ERROR_WRP,
352   FLASH_COMPLETE,
353   FLASH_TIMEOUT
354 };
355
356 static void __attribute__ ((used))
357 flash_unlock (void)
358 {
359   FLASH->KEYR = FLASH_KEY1;
360   FLASH->KEYR = FLASH_KEY2;
361 }
362
363
364 #define intr_disable()  asm volatile ("cpsid   i" : : : "memory")
365 #define intr_enable()  asm volatile ("cpsie   i" : : : "memory")
366
367 #define FLASH_SR_BSY            0x01
368 #define FLASH_SR_PGERR          0x04
369 #define FLASH_SR_WRPRTERR       0x10
370 #define FLASH_SR_EOP            0x20
371
372 #define FLASH_CR_PG     0x0001
373 #define FLASH_CR_PER    0x0002
374 #define FLASH_CR_MER    0x0004
375 #define FLASH_CR_OPTPG  0x0010
376 #define FLASH_CR_OPTER  0x0020
377 #define FLASH_CR_STRT   0x0040
378 #define FLASH_CR_LOCK   0x0080
379 #define FLASH_CR_OPTWRE 0x0200
380 #define FLASH_CR_ERRIE  0x0400
381 #define FLASH_CR_EOPIE  0x1000
382
383 static int
384 flash_wait_for_last_operation (uint32_t timeout)
385 {
386   int status;
387
388   do
389     {
390       status = FLASH->SR;
391       if (--timeout == 0)
392         break;
393     }
394   while ((status & FLASH_SR_BSY) != 0);
395
396   return status & (FLASH_SR_BSY|FLASH_SR_PGERR|FLASH_SR_WRPRTERR);
397 }
398
399 #define FLASH_PROGRAM_TIMEOUT 0x00010000
400 #define FLASH_ERASE_TIMEOUT   0x01000000
401
402 static int
403 flash_program_halfword (uint32_t addr, uint16_t data)
404 {
405   int status;
406
407   status = flash_wait_for_last_operation (FLASH_PROGRAM_TIMEOUT);
408
409   intr_disable ();
410   if (status == 0)
411     {
412       FLASH->CR |= FLASH_CR_PG;
413
414       *(volatile uint16_t *)addr = data;
415
416       status = flash_wait_for_last_operation (FLASH_PROGRAM_TIMEOUT);
417       FLASH->CR &= ~FLASH_CR_PG;
418     }
419   intr_enable ();
420
421   return status;
422 }
423
424 static int
425 flash_erase_page (uint32_t addr)
426 {
427   int status;
428
429   status = flash_wait_for_last_operation (FLASH_ERASE_TIMEOUT);
430
431   intr_disable ();
432   if (status == 0)
433     {
434       FLASH->CR |= FLASH_CR_PER;
435       FLASH->AR = addr;
436       FLASH->CR |= FLASH_CR_STRT;
437
438       status = flash_wait_for_last_operation (FLASH_ERASE_TIMEOUT);
439       FLASH->CR &= ~FLASH_CR_PER;
440     }
441   intr_enable ();
442
443   return status;
444 }
445
446 static int
447 flash_check_blank (const uint8_t *p_start, size_t size)
448 {
449   const uint8_t *p;
450
451   for (p = p_start; p < p_start + size; p++)
452     if (*p != 0xff)
453       return 0;
454
455   return 1;
456 }
457
458 extern uint8_t __flash_start__, __flash_end__;
459
460 static int
461 flash_write (uint32_t dst_addr, const uint8_t *src, size_t len)
462 {
463   int status;
464   uint32_t flash_start = (uint32_t)&__flash_start__;
465   uint32_t flash_end = (uint32_t)&__flash_end__;
466
467   if (dst_addr < flash_start || dst_addr + len > flash_end)
468     return 0;
469
470   while (len)
471     {
472       uint16_t hw = *src++;
473
474       hw |= (*src++ << 8);
475       status = flash_program_halfword (dst_addr, hw);
476       if (status != 0)
477         return 0;               /* error return */
478
479       dst_addr += 2;
480       len -= 2;
481     }
482
483   return 1;
484 }
485
486 #define OPTION_BYTES_ADDR 0x1ffff800
487
488 static int
489 flash_protect (void)
490 {
491   int status;
492   uint32_t option_bytes_value;
493
494   status = flash_wait_for_last_operation (FLASH_ERASE_TIMEOUT);
495
496   intr_disable ();
497   if (status == 0)
498     {
499       FLASH->OPTKEYR = FLASH_KEY1;
500       FLASH->OPTKEYR = FLASH_KEY2;
501
502       FLASH->CR |= FLASH_CR_OPTER;
503       FLASH->CR |= FLASH_CR_STRT;
504
505       status = flash_wait_for_last_operation (FLASH_ERASE_TIMEOUT);
506       FLASH->CR &= ~FLASH_CR_OPTER;
507     }
508   intr_enable ();
509
510   if (status != 0)
511     return 0;
512
513   option_bytes_value = *(uint32_t *)OPTION_BYTES_ADDR;
514   return (option_bytes_value & 0xff) == 0xff ? 1 : 0;
515 }
516
517 static void __attribute__((naked))
518 flash_erase_all_and_exec (void (*entry)(void))
519 {
520   uint32_t addr = (uint32_t)&__flash_start__;
521   uint32_t end = (uint32_t)&__flash_end__;
522   int r;
523
524   while (addr < end)
525     {
526       r = flash_erase_page (addr);
527       if (r != 0)
528         break;
529
530       addr += FLASH_PAGE_SIZE;
531     }
532
533   if (addr >= end)
534     (*entry) ();
535
536   for (;;);
537 }
538
539 struct SCB
540 {
541   volatile uint32_t CPUID;
542   volatile uint32_t ICSR;
543   volatile uint32_t VTOR;
544   volatile uint32_t AIRCR;
545   volatile uint32_t SCR;
546   volatile uint32_t CCR;
547   volatile uint8_t  SHP[12];
548   volatile uint32_t SHCSR;
549   volatile uint32_t CFSR;
550   volatile uint32_t HFSR;
551   volatile uint32_t DFSR;
552   volatile uint32_t MMFAR;
553   volatile uint32_t BFAR;
554   volatile uint32_t AFSR;
555   volatile uint32_t PFR[2];
556   volatile uint32_t DFR;
557   volatile uint32_t ADR;
558   volatile uint32_t MMFR[4];
559   volatile uint32_t ISAR[5];
560 };
561
562 #define SCS_BASE        (0xE000E000)
563 #define SCB_BASE        (SCS_BASE +  0x0D00)
564 static struct SCB *const SCB = ((struct SCB *const) SCB_BASE);
565
566 #define SYSRESETREQ 0x04
567 static void
568 nvic_system_reset (void)
569 {
570   SCB->AIRCR = (0x05FA0000 | (SCB->AIRCR & 0x70) | SYSRESETREQ);
571   asm volatile ("dsb");
572   for (;;);
573 }
574
575 static void __attribute__ ((naked))
576 reset (void)
577 {
578   extern const unsigned long *FT0, *FT1, *FT2;
579
580   asm volatile ("cpsid  i\n\t"          /* Mask all interrupts. */
581                 "mov.w  r0, #0xed00\n\t" /* r0 = SCR */
582                 "movt   r0, #0xe000\n\t"
583                 "mov    r1, pc\n\t"      /* r1 = (PC + 0x1000) & ~0x0fff */
584                 "mov    r2, #0x1000\n\t"
585                 "add    r1, r1, r2\n\t"
586                 "sub    r2, r2, #1\n\t"
587                 "bic    r1, r1, r2\n\t"
588                 "str    r1, [r0, #8]\n\t"       /* Set SCR->VCR */
589                 "ldr    r0, [r1], #4\n\t"
590                 "msr    MSP, r0\n\t"    /* Main (exception handler) stack. */
591                 "ldr    r0, [r1]\n\t"   /* Reset handler.                  */
592                 "bx     r0\n"
593                 : /* no output */ : /* no input */ : "memory");
594
595   /* Never reach here. */
596   /* Artificial entry to refer FT0, FT1, and FT2.  */
597   asm volatile (""
598                 : : "r" (FT0), "r" (FT1), "r" (FT2));
599 }
600
601 typedef void (*handler)(void);
602 extern uint8_t __ram_end__;
603
604 handler vector[] __attribute__ ((section(".vectors"))) = {
605   (handler)&__ram_end__,
606   reset,
607   (handler)set_led,
608   flash_unlock,
609   (handler)flash_program_halfword,
610   (handler)flash_erase_page,
611   (handler)flash_check_blank,
612   (handler)flash_write,
613   (handler)flash_protect,
614   (handler)flash_erase_all_and_exec,
615   usb_lld_sys_init,
616   usb_lld_sys_shutdown,
617   nvic_system_reset,
618   clock_init,
619   gpio_init,
620   NULL,
621 };
622
623 const uint8_t sys_version[8] __attribute__((section(".sys.version"))) = {
624   3*2+2,             /* bLength */
625   0x03,              /* bDescriptorType = USB_STRING_DESCRIPTOR_TYPE*/
626   /* sys version: "2.0" */
627   '2', 0, '.', 0, '0', 0,
628 };