[arm] Flash programming supported on Nucleo-C031C6 board

The STM32C series chips are unlike the F0 and F3 parts in the way that
they deal with erasing the flash. Instead of using an address - the
address of the first byte of the page of flash to erase - they use an
*index*.

The C031 has 32 KiB of flash, divided into 2 KiB pages (or sectors).
Thus the index is from 0 to 15.

The flash i/o registers are laid out like the F407, which also uses
indices to erase the flash, but it has non-uniform sector sizes, and
they are quite large: I think the smallest one is 16 KiB.

So the C031 falls in between. It uses small uniform pages, like the F0
and F3 parts, but erases (and programs) them more like the F407.

Go figure. Something always has to change!

Author: nimblemachines

mu/target/ARM/board/nucleo-c031c6.mu4

@@ -7,3 +7,12 @@ loading Nucleo-C031C6 board
 ld! target/ARM/stm32/c0/31_6.mu4
 ld target/ARM/debug/stlink-v2.mu4
 ld target/ARM/debug/stlink-v2-interact.mu4
+
+( Let's load the Forth kernel into flash, above the example code that is
+  pre-programmed onto the board.)
+
+hex
+flash  @flash 4000 +  dup region!
+ld target/ARM/v6-m/kernel-itc.mu4
+__meta
+ram

mu/target/ARM/debug/stlink-v2-interact.mu4

@@ -7,12 +7,11 @@ loading ST-LINK debug (interact)
 hex
 
 ( Load the flash programming routines into ram.)
-.ndef #flashbuf  .ndef no-flash-programming  .and .if
-   .ifdef /page  ( chip has flash with uniform page size)
-      ld target/ARM/stm32/flash-programming.mu4
-   .else  ( chip has sectored flash)
-      ld target/ARM/stm32/flash-programming-sectored.mu4
-   .then
+
+.equates. .contains FLASH_AR .if  ( chip uses *addresses* for erasing flash)
+   ld target/ARM/stm32/flash-programming.mu4
+.else  ( chip uses sector/page *indexes* for erasing flash)
+   ld target/ARM/stm32/flash-programming-sectored.mu4
 .then
 
 ( Skip the rest of the file if no ST-LINK was found.)
@@ -59,26 +58,28 @@ hex
    st.connect  dbg.halt
    [ h @  ram  @flash-routines image+  swap h ! #]  ( address in ram image)
    @flash-routines #flash-routines st.write  ( copy code to ram)
-   #flashbuf ;  ( size of RAM flash buffer)
+   #flashbuf ;  ( return size of RAM flash buffer as chunk-size)
 
 ( Write unlock keys to FLASH_KEYR.)
 : st.flash-begin
-   cdef_89ab  4567_0123  \m unlock rx ;
+   cdef_89ab  4567_0123  \m stm32-flash-unlock rx ;
 
 ( Re-lock flash controller registers.)
-: st.flash-end   \m lock rx ;
+: st.flash-end   \m stm32-flash-lock rx ;
 
 ( stm32-erase takes a flash address for uniform page devices, and a sector
   number, for sectored devices. target/ARM/v6-m/flash.mu4 has already
   figured this out for us.)
 
-: st.erase  ( a | sector#)  \m stm32-erase rx ;
+: st.erase  ( a | sector#)  \m stm32-flash-erase rx ;
 
 ( Copy buf contents to ram buffer, then write to flash from there.)
 : st.program  ( buf a u)
    push ( u)
-   swap @flashbuf r@  ( a buf flashbuf u)  st.write  ( copy chunk to target ram)
-   @flashbuf swap pop  ( flashbuf a u)  \m stm32-flash-chunk rx ;
+   ( copy chunk to target ram, aligning copied data by 8 for STM32C parts)
+   swap @flashbuf r@  ( a buf flashbuf u)  8 aligned-by  st.write
+   ( program chunk into flash)
+   @flashbuf swap pop  ( flashbuf a u)  \m stm32-flash-program rx ;
 
 .then  ( def no-flash-programming)
 

mu/target/ARM/stm32/c0/31_6.mu4

@@ -13,11 +13,37 @@ loading STM32C031x6 chip
 "2000_0000 constant @ram
      12 Ki constant #ram
 
-      2 Ki constant #bl-ram  ( ram consumed by bootloader)
+      -- 2 Ki constant #bl-ram  ( ram consumed by bootloader)
 
-( Flash programming doesn't use FLASH_AR; currently unsupported.)
--d no-flash-programming
-      1 Ki constant /page  ( erase page size)
+( Programming the C031 flash is like programming the F407, except that the
+  C031 has a uniform sector/page size of 2 KiB.)
+
+( Given a target flash address, return a sector# and true if address is on
+  a sector boundary, and return false otherwise.)
+
+( XXX should this be called map-flash-sector ?)
+: lookup-flash-sector  ( 'target - sector# -1 | 0)
+   @flash -  2 Ki /mod ( mod quot)
+   swap 0= if  -1 ^  then  drop 0  ;
+
+( We need to define #flashbuf for the chip. Should be at least 256 but no
+  more than 2 Ki, the page size. Since we don't have a lot of RAM on the
+  chip, let's keep it small.)
+
+256 constant #flashbuf
+
+.ifdef testing
+
+: test-sector  ( 'target)
+   dup lookup-flash-sector  if  swap  cr  u. ." sector " u. ^ then  drop ;
+
+( Test every 256 byte chunk of the flash to see where the sector boundaries
+  are. Make sure we get the correct values!)
+
+: test-sectors
+   @flash #flash over + swap do  i test-sector  256 +loop ;
+
+.then
 
 -- load peripheral equates etc
 ld target/ARM/stm32/c0/31_6-equates.mu4

mu/target/ARM/stm32/f4/07_g.mu4

@@ -36,6 +36,12 @@ loading STM32F407xG chip
    dup  64 Ki  = if    drop  4 -1 ^  then
        128 Ki -     128 5 sector? ;
 
+( We need to define #flashbuf for the chip. Should be at least 256 but no
+  more than the smallest sector. Since we have lots of RAM on the chip,
+  let's make it pretty big.)
+
+4 Ki constant #flashbuf
+
 .ifdef testing
 
 : test-sector  ( 'target)

mu/target/ARM/stm32/flash-programming-sectored.mu4

@@ -58,10 +58,14 @@ forth
 : asm-regs   [ #] is .reg ;   asm-regs
 
 
-( Any chip with sectored flash probably has lots of RAM, so let's use a
-  4 Ki ram flash buffer.)
+.ifndef #flashbuf
+   z"
 
-4 Ki constant #flashbuf
+Your chip is uses indices rather than addresses to specify the block of
+flash to erase. You need to define #flashbuf - the size of the RAM buffer
+used during flash programming. It should be no smaller than 256 bytes, and
+must be no bigger than the smallest sector or page in the flash."  abort
+.then
 
 ( Leave room for 64 cells on sp stack; room for 256 bytes of flash
   programming code; round down to multiple of 256, then leave #flashbuf
@@ -78,51 +82,76 @@ ram  here  ( we are going to return here after compiling the flash routines.)
 
 @flash-routines goto  ( starting address of flash routines)
 
-label unlock
-   FLASH_ACR fr lit
+label stm32-flash-unlock
+   FLASH_CR >iobase fr lit
    x w dpop2   FLASH_KEYR >io fr w str   FLASH_KEYR >io fr x str
    0 w movs    FLASH_CR   >io fr w str  ( clear any program/erase bits)
    lr bx  ;c
    pool,
 
-label lock
-   80 ( LOCK) w movs
-   FLASH_CR 3 + >io fr w strb
+label stm32-flash-lock
+   0          w movs   FLASH_CR     >io fr w str  ( clear any program/erase bits)
+   80 ( LOCK) w movs   FLASH_CR 3 + >io fr w strb  ( lock CR)
    lr bx  ;c
 
+( w is flash sector to erase)
+label stm32-flash-erase  ( sector#)
+   FLASH_SR >io fr w ldrh   FLASH_SR >io fr w strh  ( clear any error bits)
+   w dpop   3 w w lsls  ( shift sector# up 3 bits)
+   2 ( SER)  w w adds   FLASH_CR     >io fr w str  ( set SER + sector number)
+   1 ( STRT) w movs     FLASH_CR 2 + >io fr w strb ( set STRT bit)
+   ( fall thru)  ;c
+
+( Wait until flash command finishes.)
 label -busy
    x w rpush2
    1 ( BSY) w movs
    begin   FLASH_SR 2 + >io fr x ldrb   x w tst   0= until
    x w rpop2
    lr bx  ;c
 
-( w is flash sector to erase)
-label stm32-erase  ( sector#)
+.ifdef stm32c031
+
+( w is byte count, x is flash address,
+  y is ram buffer address, z is offset.)
+label stm32-flash-program  ( buf a u)
    lr rpush
-   w dpop   3 w w lsls  ( shift sector# up 3 bits)
-   2 ( SER)  w w adds   FLASH_CR     >io fr w str  ( set SER + sector number)
-   1 ( STRT) w movs     FLASH_CR 2 + >io fr w strb ( set STRT bit)
-   -busy bl
+   FLASH_SR >io fr w ldrh   FLASH_SR >io fr w strh  ( clear any error bits)
+   y x w dpop3
+   1 ( PG) z movs   FLASH_CR >io fr z str  ( set PG bit)
+   0 z movs  ( offset)
+   begin
+      ( unlike paged flash, we program by double-words!)
+      z y top ldr   z x top str   4 z z adds
+      z y top ldr   z x top str   4 z z adds
+      -busy bl
+      w z cmp
+   u>= until
    pc rpop  ;c
 
+.then  ( def stm32c031)
+
+.ifdef stm32f407
+
 ( w is byte count, x is flash address,
   y is ram buffer address, z is offset.)
-label stm32-flash-chunk  ( buf a u)
+label stm32-flash-program  ( buf a u)
    lr rpush
+   FLASH_SR >io fr w ldrh   FLASH_SR >io fr w strh  ( clear any error bits)
    y x w dpop3
    1 ( PG)    z movs   FLASH_CR    >io fr z str  ( set PG bit)
    2 ( psize) z movs   FLASH_CR 1+ >io fr z strb ( psize=2; program by 32bit word)
    0 z movs  ( offset)
    begin
-      ( unlike paged flash, we can program by words!)
-      z y top ldr   z x top str
-      4 z z adds
+      ( unlike paged flash, we program by words!)
+      z y top ldr   z x top str   4 z z adds
       -busy bl
       w z cmp
    u>= until
    pc rpop  ;c
 
+.then  ( def stm32f407)
+
 .ifdef testing
 
 ( w is byte count, x is dest address, y is src address, z is offset. Copy

mu/target/ARM/stm32/flash-programming.mu4

@@ -59,10 +59,14 @@ forth
 
 
 ( How much space do we want to use for the flashbuf? It can't be bigger
-  than /page, but we don't want it to be too much of a fraction of the
-  RAM.)
+  than /page, and we don't want to use too much of the RAM, since I don't
+  think the flash buf size is the limiting factor for programming speed.
 
-#ram 16 / /page min  constant #flashbuf
+  Let's use 256 if flash size is less than 32 KiB, and 1 KiB otherwise - or
+  /page if it is smaller.)
+
+#flash 32 Ki u< .if  256  .else  1 Ki  .then  /page min
+constant #flashbuf
 
 ( Leave room for 64 cells on sp stack; room for 256 bytes of flash
   programming code; round down to multiple of 256, then leave #flashbuf
@@ -79,40 +83,40 @@ ram  here  ( we are going to return here after compiling the flash routines.)
 
 @flash-routines goto  ( starting address of flash routines)
 
-label unlock
-   FLASH_ACR >iobase fr lit
+label stm32-flash-unlock
+   FLASH_CR >iobase fr lit
    x w dpop2   FLASH_KEYR >io fr w str   FLASH_KEYR >io fr x str
    0 w movs    FLASH_CR   >io fr w str  ( clear any program/erase bits)
    lr bx  ;c
    pool,
 
-label lock
+label stm32-flash-lock
+   0          w movs   FLASH_CR >io fr w str  ( clear any program/erase bits)
    80 ( LOCK) w movs   FLASH_CR >io fr w str
    lr bx  ;c
 
+( w is flash page address to erase)
+label stm32-flash-erase  ( flash-page-address)
+   FLASH_SR >io fr w ldrb   FLASH_SR >io fr w strb  ( clear any error bits)
+   w dpop
+    2 ( PER)      x movs   FLASH_CR >io fr x str ( set PER)
+                           FLASH_AR >io fr w str ( set page erase address)
+   42 ( STRT+PER) x movs   FLASH_CR >io fr x str ( set STRT+PER)
+   ( fall thru)  ;c
+
+( Wait until flash command finishes.)
 label -busy
    x w rpush2
    1 ( BSY) w movs
    begin   FLASH_SR >io fr x ldr   x w tst   0= until
    x w rpop2
    lr bx  ;c
 
-( w is flash page address to erase)
-label stm32-erase  ( flash-page-address)
-   lr rpush
-   w dpop
-    2 ( PER)      x movs   FLASH_CR >io fr x str ( set PER)
-                           FLASH_AR >io fr w str ( set page erase address)
-   42 ( STRT+PER) x movs   FLASH_CR >io fr x str ( set STRT+PER)
-   -busy bl
-   pc rpop  ;c
-
-label stm32-mass-erase
-   lr rpush
+label stm32-flash-mass-erase
+   FLASH_SR >io fr w ldrb   FLASH_SR >io fr w strb  ( clear any error bits)
     4 ( MER)      w movs   FLASH_CR >io fr w str ( set MER)
    44 ( STRT+MER) w movs   FLASH_CR >io fr w str ( set STRT+MER)
-   -busy bl
-   pc rpop  ;c
+   -busy b  ;c
 
 .ifdef bogus-and-untested
 
@@ -149,8 +153,9 @@ label remove-read-protect  ( key)
 
 ( w is byte count, x is flash address,
   y is ram buffer address, z is offset.)
-label stm32-flash-chunk  ( buf a u)
+label stm32-flash-program  ( buf a u)
    lr rpush
+   FLASH_SR >io fr w ldrb   FLASH_SR >io fr w strb  ( clear any error bits)
    y x w dpop3
    1 ( PG) z movs   FLASH_CR >io fr z str ( set PG bit)
    0 z movs  ( offset)