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