Newer 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_APB2ENR_IOPAEN      0x00000004
185 #define RCC_APB2RSTR_IOPARST    0x00000004
186 #define RCC_APB2ENR_IOPBEN      0x00000008
187 #define RCC_APB2RSTR_IOPBRST    0x00000008
188 #define RCC_APB2ENR_IOPCEN      0x00000010
189 #define RCC_APB2RSTR_IOPCRST    0x00000010
190 #define RCC_APB2ENR_IOPDEN      0x00000020
191 #define RCC_APB2RSTR_IOPDRST    0x00000020
192
193
194 struct GPIO {
195   volatile uint32_t CRL;
196   volatile uint32_t CRH;
197   volatile uint32_t IDR;
198   volatile uint32_t ODR;
199   volatile uint32_t BSRR;
200   volatile uint32_t BRR;
201   volatile uint32_t LCKR;
202 };
203
204 #define GPIOA_BASE      (APB2PERIPH_BASE + 0x0800)
205 #define GPIOA           ((struct GPIO *) GPIOA_BASE)
206 #define GPIOB_BASE      (APB2PERIPH_BASE + 0x0C00)
207 #define GPIOB           ((struct GPIO *) GPIOB_BASE)
208 #define GPIOC_BASE      (APB2PERIPH_BASE + 0x1000)
209 #define GPIOC           ((struct GPIO *) GPIOC_BASE)
210 #define GPIOD_BASE      (APB2PERIPH_BASE + 0x1400)
211 #define GPIOD           ((struct GPIO *) GPIOD_BASE)
212 #define GPIOE_BASE      (APB2PERIPH_BASE + 0x1800)
213 #define GPIOE           ((struct GPIO *) GPIOE_BASE)
214
215 static struct GPIO *const GPIO_USB = ((struct GPIO *const) GPIO_USB_BASE);
216 static struct GPIO *const GPIO_LED = ((struct GPIO *const) GPIO_LED_BASE);
217
218 static void
219 gpio_init (void)
220 {
221   /* Enable GPIO clock. */
222   RCC->APB2ENR |= RCC_APB2ENR_IOP_EN;
223   RCC->APB2RSTR = RCC_APB2RSTR_IOP_RST;
224   RCC->APB2RSTR = 0;
225
226   GPIO_USB->ODR = VAL_GPIO_ODR;
227   GPIO_USB->CRH = VAL_GPIO_CRH;
228   GPIO_USB->CRL = VAL_GPIO_CRL;
229
230 #if GPIO_USB_BASE != GPIO_LED_BASE
231   GPIO_LED->ODR = VAL_GPIO_LED_ODR;
232   GPIO_LED->CRH = VAL_GPIO_LED_CRH;
233   GPIO_LED->CRL = VAL_GPIO_LED_CRL;
234 #endif
235 }
236
237 static void
238 usb_cable_config (int enable)
239 {
240 #if defined(GPIO_USB_SET_TO_ENABLE)
241   if (enable)
242     GPIO_USB->BSRR = (1 << GPIO_USB_SET_TO_ENABLE);
243   else
244     GPIO_USB->BRR = (1 << GPIO_USB_SET_TO_ENABLE);
245 #elif defined(GPIO_USB_CLEAR_TO_ENABLE)
246   if (enable)
247     GPIO_USB->BRR = (1 << GPIO_USB_CLEAR_TO_ENABLE);
248   else
249     GPIO_USB->BSRR = (1 << GPIO_USB_CLEAR_TO_ENABLE);
250 #else
251   (void)enable;
252 #endif
253 }
254
255 void
256 set_led (int on)
257 {
258 #if defined(GPIO_LED_CLEAR_TO_EMIT)
259   if (on)
260     GPIO_LED->BRR = (1 << GPIO_LED_CLEAR_TO_EMIT);
261   else
262     GPIO_LED->BSRR = (1 << GPIO_LED_CLEAR_TO_EMIT);
263 #else
264   if (on)
265     GPIO_LED->BSRR = (1 << GPIO_LED_SET_TO_EMIT);
266   else
267     GPIO_LED->BRR = (1 << GPIO_LED_SET_TO_EMIT);
268 #endif
269 }
270
271 static void wait (int count)
272 {
273   int i;
274
275   for (i = 0; i < count; i++)
276     asm volatile ("" : : "r" (i) : "memory");
277 }
278
279 #define USB_IRQ 20
280 #define USB_IRQ_PRIORITY ((11) << 4)
281
282 static void
283 usb_lld_sys_shutdown (void)
284 {
285   RCC->APB1ENR &= ~RCC_APB1ENR_USBEN;
286   RCC->APB1RSTR = RCC_APB1RSTR_USBRST;
287   usb_cable_config (0);
288 }
289
290 static void
291 usb_lld_sys_init (void)
292 {
293   if ((RCC->APB1ENR & RCC_APB1ENR_USBEN)
294       && (RCC->APB1RSTR & RCC_APB1RSTR_USBRST) == 0)
295     /* Make sure the device is disconnected, even after core reset.  */
296     {
297       usb_lld_sys_shutdown ();
298       /* Disconnect requires SE0 (>= 2.5uS).  */
299       wait (300);
300     }
301
302   usb_cable_config (1);
303   RCC->APB1ENR |= RCC_APB1ENR_USBEN;
304   nvic_enable_vector (USB_LP_CAN1_RX0_IRQn,
305                       CORTEX_PRIORITY_MASK (STM32_USB_IRQ_PRIORITY));
306   /*
307    * Note that we also have other IRQ(s):
308    *    USB_HP_CAN1_TX_IRQn (for double-buffered or isochronous)
309    *    USBWakeUp_IRQn (suspend/resume)
310    */
311   RCC->APB1RSTR = RCC_APB1RSTR_USBRST;
312   RCC->APB1RSTR = 0;
313 }
314
315 #define FLASH_KEY1               0x45670123UL
316 #define FLASH_KEY2               0xCDEF89ABUL
317
318 enum flash_status
319 {
320   FLASH_BUSY = 1,
321   FLASH_ERROR_PG,
322   FLASH_ERROR_WRP,
323   FLASH_COMPLETE,
324   FLASH_TIMEOUT
325 };
326
327 static void __attribute__ ((used))
328 flash_unlock (void)
329 {
330   FLASH->KEYR = FLASH_KEY1;
331   FLASH->KEYR = FLASH_KEY2;
332 }
333
334
335 #define intr_disable()  asm volatile ("cpsid   i" : : : "memory")
336 #define intr_enable()  asm volatile ("cpsie   i" : : : "memory")
337
338 #define FLASH_SR_BSY            0x01
339 #define FLASH_SR_PGERR          0x04
340 #define FLASH_SR_WRPRTERR       0x10
341 #define FLASH_SR_EOP            0x20
342
343 #define FLASH_CR_PG     0x0001
344 #define FLASH_CR_PER    0x0002
345 #define FLASH_CR_MER    0x0004
346 #define FLASH_CR_OPTPG  0x0010
347 #define FLASH_CR_OPTER  0x0020
348 #define FLASH_CR_STRT   0x0040
349 #define FLASH_CR_LOCK   0x0080
350 #define FLASH_CR_OPTWRE 0x0200
351 #define FLASH_CR_ERRIE  0x0400
352 #define FLASH_CR_EOPIE  0x1000
353
354 static int
355 flash_wait_for_last_operation (uint32_t timeout)
356 {
357   int status;
358
359   do
360     {
361       status = FLASH->SR;
362       if (--timeout == 0)
363         break;
364     }
365   while ((status & FLASH_SR_BSY) != 0);
366
367   return status & (FLASH_SR_BSY|FLASH_SR_PGERR|FLASH_SR_WRPRTERR);
368 }
369
370 #define FLASH_PROGRAM_TIMEOUT 0x00010000
371 #define FLASH_ERASE_TIMEOUT   0x01000000
372
373 static int
374 flash_program_halfword (uint32_t addr, uint16_t data)
375 {
376   int status;
377
378   status = flash_wait_for_last_operation (FLASH_PROGRAM_TIMEOUT);
379
380   intr_disable ();
381   if (status == 0)
382     {
383       FLASH->CR |= FLASH_CR_PG;
384
385       *(volatile uint16_t *)addr = data;
386
387       status = flash_wait_for_last_operation (FLASH_PROGRAM_TIMEOUT);
388       FLASH->CR &= ~FLASH_CR_PG;
389     }
390   intr_enable ();
391
392   return status;
393 }
394
395 static int
396 flash_erase_page (uint32_t addr)
397 {
398   int status;
399
400   status = flash_wait_for_last_operation (FLASH_ERASE_TIMEOUT);
401
402   intr_disable ();
403   if (status == 0)
404     {
405       FLASH->CR |= FLASH_CR_PER;
406       FLASH->AR = addr;
407       FLASH->CR |= FLASH_CR_STRT;
408
409       status = flash_wait_for_last_operation (FLASH_ERASE_TIMEOUT);
410       FLASH->CR &= ~FLASH_CR_PER;
411     }
412   intr_enable ();
413
414   return status;
415 }
416
417 static int
418 flash_check_blank (const uint8_t *p_start, size_t size)
419 {
420   const uint8_t *p;
421
422   for (p = p_start; p < p_start + size; p++)
423     if (*p != 0xff)
424       return 0;
425
426   return 1;
427 }
428
429 extern uint8_t __flash_start__, __flash_end__;
430
431 static int
432 flash_write (uint32_t dst_addr, const uint8_t *src, size_t len)
433 {
434   int status;
435   uint32_t flash_start = (uint32_t)&__flash_start__;
436   uint32_t flash_end = (uint32_t)&__flash_end__;
437
438   if (dst_addr < flash_start || dst_addr + len > flash_end)
439     return 0;
440
441   while (len)
442     {
443       uint16_t hw = *src++;
444
445       hw |= (*src++ << 8);
446       status = flash_program_halfword (dst_addr, hw);
447       if (status != 0)
448         return 0;               /* error return */
449
450       dst_addr += 2;
451       len -= 2;
452     }
453
454   return 1;
455 }
456
457 #define OPTION_BYTES_ADDR 0x1ffff800
458
459 static int
460 flash_protect (void)
461 {
462   int status;
463   uint32_t option_bytes_value;
464
465   status = flash_wait_for_last_operation (FLASH_ERASE_TIMEOUT);
466
467   intr_disable ();
468   if (status == 0)
469     {
470       FLASH->OPTKEYR = FLASH_KEY1;
471       FLASH->OPTKEYR = FLASH_KEY2;
472
473       FLASH->CR |= FLASH_CR_OPTER;
474       FLASH->CR |= FLASH_CR_STRT;
475
476       status = flash_wait_for_last_operation (FLASH_ERASE_TIMEOUT);
477       FLASH->CR &= ~FLASH_CR_OPTER;
478     }
479   intr_enable ();
480
481   if (status != 0)
482     return 0;
483
484   option_bytes_value = *(uint32_t *)OPTION_BYTES_ADDR;
485   return (option_bytes_value & 0xff) == 0xff ? 1 : 0;
486 }
487
488 static void __attribute__((naked))
489 flash_erase_all_and_exec (void (*entry)(void))
490 {
491   uint32_t addr = (uint32_t)&__flash_start__;
492   uint32_t end = (uint32_t)&__flash_end__;
493   int r;
494
495   while (addr < end)
496     {
497       r = flash_erase_page (addr);
498       if (r != 0)
499         break;
500
501       addr += FLASH_PAGE_SIZE;
502     }
503
504   if (addr >= end)
505     (*entry) ();
506
507   for (;;);
508 }
509
510 struct SCB
511 {
512   volatile uint32_t CPUID;
513   volatile uint32_t ICSR;
514   volatile uint32_t VTOR;
515   volatile uint32_t AIRCR;
516   volatile uint32_t SCR;
517   volatile uint32_t CCR;
518   volatile uint8_t  SHP[12];
519   volatile uint32_t SHCSR;
520   volatile uint32_t CFSR;
521   volatile uint32_t HFSR;
522   volatile uint32_t DFSR;
523   volatile uint32_t MMFAR;
524   volatile uint32_t BFAR;
525   volatile uint32_t AFSR;
526   volatile uint32_t PFR[2];
527   volatile uint32_t DFR;
528   volatile uint32_t ADR;
529   volatile uint32_t MMFR[4];
530   volatile uint32_t ISAR[5];
531 };
532
533 #define SCS_BASE        (0xE000E000)
534 #define SCB_BASE        (SCS_BASE +  0x0D00)
535 static struct SCB *const SCB = ((struct SCB *const) SCB_BASE);
536
537 #define SYSRESETREQ 0x04
538 static void
539 nvic_system_reset (void)
540 {
541   SCB->AIRCR = (0x05FA0000 | (SCB->AIRCR & 0x70) | SYSRESETREQ);
542   asm volatile ("dsb");
543   for (;;);
544 }
545
546 static void __attribute__ ((naked))
547 reset (void)
548 {
549   extern const unsigned long *FT0, *FT1, *FT2;
550
551   asm volatile ("cpsid  i\n\t"          /* Mask all interrupts. */
552                 "mov.w  r0, #0xed00\n\t" /* r0 = SCR */
553                 "movt   r0, #0xe000\n\t"
554                 "mov    r1, pc\n\t"      /* r1 = (PC + 0x1000) & ~0x0fff */
555                 "mov    r2, #0x1000\n\t"
556                 "add    r1, r1, r2\n\t"
557                 "sub    r2, r2, #1\n\t"
558                 "bic    r1, r1, r2\n\t"
559                 "str    r1, [r0, #8]\n\t"       /* Set SCR->VCR */
560                 "ldr    r0, [r1], #4\n\t"
561                 "msr    MSP, r0\n\t"    /* Main (exception handler) stack. */
562                 "ldr    r0, [r1]\n\t"   /* Reset handler.                  */
563                 "bx     r0\n"
564                 : /* no output */ : /* no input */ : "memory");
565
566   /* Never reach here. */
567   /* Artificial entry to refer FT0, FT1, and FT2.  */
568   asm volatile (""
569                 : : "r" (&FT0), "r" (&FT1), "r" (&FT2));
570 }
571
572 typedef void (*handler)(void);
573 extern uint8_t __ram_end__;
574
575 handler vector[] __attribute__ ((section(".vectors"))) = {
576   (handler)&__ram_end__,
577   reset,
578   (handler)set_led,
579   flash_unlock,
580   (handler)flash_program_halfword,
581   (handler)flash_erase_page,
582   (handler)flash_check_blank,
583   (handler)flash_write,
584   (handler)flash_protect,
585   (handler)flash_erase_all_and_exec,
586   usb_lld_sys_init,
587   usb_lld_sys_shutdown,
588   nvic_system_reset,
589   clock_init,
590   gpio_init,
591   NULL,
592 };
593
594 const uint8_t sys_version[8] __attribute__((section(".sys.version"))) = {
595   3*2+2,             /* bLength */
596   0x03,              /* bDescriptorType = USB_STRING_DESCRIPTOR_TYPE*/
597   /* sys version: "2.0" */
598   '2', 0, '.', 0, '0', 0,
599 };