gdbflasher 1.0.0

data/helper_sources/stm32l1xx.S

@@ -0,0 +1,101 @@
+.set PAGE_SIZE, 256
+
+.set FLASH_BASE, 0x40023C00
+
+.set FLASH_ACR, 0x00
+.set FLASH_PECR, 0x04
+.set FLASH_PDKEYR, 0x08
+.set FLASH_PEKEYR, 0x0C
+.set FLASH_PRGKEYR, 0x10
+.set FLASH_OPTKEYR, 0x14
+.set FLASH_SR, 0x18
+
+.globl trap
+.globl initialize
+.globl finalize
+.globl erase
+.globl program
+.globl page_buffer
+.globl PAGE_SIZE
+
+.arch armv7-m
+.syntax unified
+.thumb
+.text
+
+trap:
+  nop
+
+initialize:
+  ldr R7, =FLASH_BASE
+
+  ldr R0, =0x89ABCDEF
+  str R0, [R7, #FLASH_PEKEYR]
+  ldr R0, =0x02030405
+  str R0, [R7, #FLASH_PEKEYR]
+
+  ldr R0, =0x8C9DAEBF
+  str R0, [R7, #FLASH_PRGKEYR]
+  ldr R0, =0x13141516
+  str R0, [R7, #FLASH_PRGKEYR]
+
+  bx LR
+
+finalize:
+  mov R0, #7
+  str R0, [R7, #FLASH_PECR]
+
+  bx LR
+
+erase:
+  mov R1, #0x20C
+  str R1, [R7, #FLASH_PECR]
+
+1:ldr R1, [R7, #FLASH_SR]
+  tst R1, #1
+  bne 1b
+
+  mov R1, #0
+  str R1, [R0]
+
+1:ldr R1, [R7, #FLASH_SR]
+  tst R1, #1
+  bne 1b
+  and R0, R1, #0xF00
+
+  mov R1, #4
+  str R1, [R7, #FLASH_PECR]
+
+  bx LR
+
+program:
+  ldr R1, [R7, #FLASH_SR]
+  tst R1, #1
+  bne program
+
+  ldr R4, =page_buffer
+  mov R2, #0
+
+1:
+  ldr R3, [R4, R2]
+  str R3, [R0, R2]
+
+2:ldr R1, [R7, #FLASH_SR]
+  tst R1, #1
+  bne 2b
+  ands R1, R1, #0xF00
+  bne 1f
+
+  add R2, #4
+  cmp R2, #PAGE_SIZE
+  blo 1b
+
+1:
+  mov R0, R1
+  bx  LR
+
+
+.bss
+page_buffer:
+.fill PAGE_SIZE, 1
+.size page_buffer, . - page_buffer

data/helper_sources/stm32l1xx.lds

@@ -0,0 +1,25 @@
+OUTPUT_FORMAT(elf32-littlearm)
+
+MEMORY
+{
+  sram : ORIGIN = 0x20000000, LENGTH = 10K
+}
+
+SECTIONS
+{
+  .text : {
+    *(.text)
+
+    . = ALIGN(4);
+
+    *(.rodata)
+  } > sram
+
+  . = ALIGN(4);
+
+  .bss : {
+    *(.bss)
+  } > sram
+
+  . = ALIGN(4);
+}

data/helpers/stm32f10xx_hd.hex

@@ -0,0 +1,12 @@
+:020000042000DA
+:1000000000BF1C4F1C4878601C48786070474FF058
+:10001000800139617047396941F0020139617861C5
+:1000200041F040013961FA6812F0010FFBD121F073
+:100030004201396102F01400FA607047396941F0F9
+:10004000010139610E4C4FF00002A35A8352F96846
+:1000500011F0010FFBD1F96011F0140104D102F18C
+:100060000202B2F5006FF0D33A6922F001023A6160
+:10007000084670470020024023016745AB89EFCD59
+:0400800084000020D8
+:0400000520000000D7
+:00000001FF

data/helpers/stm32f10xx_hd.sym

@@ -0,0 +1,7 @@
+00000800 PAGE_SIZE
+20000000 trap
+20000002 initialize
+2000000e finalize
+20000016 erase
+2000003c program
+20000084 page_buffer

data/helpers/stm32f10xx_md.hex

@@ -0,0 +1,12 @@
+:020000042000DA
+:1000000000BF1C4F1C4878601C48786070474FF058
+:10001000800139617047396941F0020139617861C5
+:1000200041F040013961FA6812F0010FFBD121F073
+:100030004201396102F01400FA607047396941F0F9
+:10004000010139610E4C4FF00002A35A8352F96846
+:1000500011F0010FFBD1F96011F0140104D102F18C
+:100060000202B2F5806FF0D33A6922F001023A61E0
+:10007000084670470020024023016745AB89EFCD59
+:0400800084000020D8
+:0400000520000000D7
+:00000001FF

data/helpers/stm32f10xx_md.sym

@@ -0,0 +1,7 @@
+00000400 PAGE_SIZE
+20000000 trap
+20000002 initialize
+2000000e finalize
+20000016 erase
+2000003c program
+20000084 page_buffer

data/helpers/stm32f4xx.hex

@@ -0,0 +1,13 @@
+:020000042000DA
+:1000000000BF214F214878602148786070474FF049
+:10001000004038617047F96811F4803FFBD14FF020
+:10002000F001F9601B4A4FEAC00141EA020139615F
+:1000300041F480313961F86810F4803FFBD100F061
+:10004000F0004FF0000139617047F96811F4803F0A
+:10005000FBD1114939614FF0F001F9600F4C4FF0BD
+:100060000002A3588350F96811F4803FFBD111F0CE
+:10007000F00104D102F10402B2F5804FF1D3084639
+:100080004FF0000139617047003C02402301674591
+:10009000AB89EFCD0202000001020000A0000020A9
+:0400000520000000D7
+:00000001FF

data/helpers/stm32f4xx.sym

@@ -0,0 +1,7 @@
+00004000 PAGE_SIZE
+20000000 trap
+20000002 initialize
+2000000e finalize
+20000016 erase
+2000004a program
+200000a0 page_buffer

data/helpers/stm32l1xx.hex

@@ -0,0 +1,12 @@
+:020000042000DA
+:1000000000BF1C4F1C48F8601C48F8601C48386151
+:100010001C48386170474FF00700786070474FF414
+:1000200003717960B96911F0010FFBD14FF0000144
+:100030000160B96911F0010FFBD101F470604FF05C
+:10004000040179607047B96911F0010FFBD10E4CC2
+:100050004FF00002A3588350B96911F0010FFBD192
+:1000600011F4706104D102F10402B2F5807FF1D382
+:1000700008467047003C0240EFCDAB8905040302FF
+:0C008000BFAE9D8C161514138C000020E0
+:0400000520000000D7
+:00000001FF

data/helpers/stm32l1xx.sym

@@ -0,0 +1,7 @@
+00000100 PAGE_SIZE
+20000000 trap
+20000002 initialize
+20000016 finalize
+2000001e erase
+20000046 program
+2000008c page_buffer

data/lib/gdbflasher/cortexm.rb

@@ -0,0 +1,19 @@
+module GdbFlasher
+
+  class CortexM < MCU
+    protected
+
+    def initialize_environment
+      @connection.write_register 25, 0x01000000
+    end
+
+    def breakpoint_kind
+      2 # Thumb-2 breakpoint
+    end
+
+    def lr_offset
+      1
+    end
+  end
+
+end

data/lib/gdbflasher/ihex.rb

@@ -0,0 +1,189 @@
+module GdbFlasher
+  class IHex
+    class Record
+      attr_accessor :length, :address, :type, :data
+
+      TYPES = {
+        0 => :data,
+        1 => :eof,
+        4 => :extended_address,
+        5 => :start_address
+      }
+
+      def initialize
+        @length = nil
+        @address = nil
+        @type = nil
+        @data = nil
+      end
+
+      def valid?
+        @length == @data.length
+      end
+
+      def self.parse(line)
+        if line.match(/^:([0-9a-fA-F]{2})+$/).nil?
+          raise "Malformed Intel Hex line: #{line}"
+        end
+
+        line.slice! 0
+
+        bytes = Array.new(line.length / 2) { |i| line[i * 2..i * 2 + 1].hex }
+
+        record = Record.new
+        record.length = bytes[0]
+        record.address = (bytes[1] << 8) | bytes[2]
+        record.type = TYPES[bytes[3]]
+        record.data = bytes[4..-2].pack("C*")
+
+        checksum = (~bytes.reduce(:+) + 1) & 0xFF
+
+        if !record.valid? || record.type.nil? || checksum != 0
+          raise "Malformed Intel Hex line: #{line}"
+        end
+
+        record
+      end
+    end
+
+    class Segment
+      attr_accessor :base, :data
+
+      def initialize
+        @base = 0
+        @data = ""
+      end
+
+      def size
+        @data.length
+      end
+
+      def intersect(region_base, region_end)
+        if region_base == region_end
+          raise ArgumentError, "Region is empty"
+        end
+
+        segment_range = @base...@base + size
+        region_range  = region_base..region_end
+
+        intersection_base = nil, intersection_end = nil
+
+        if segment_range.cover? region_range.min
+          intersection_base = region_range.min
+        elsif region_range.cover? segment_range.min
+          intersection_base = segment_range.min
+        else
+          return Segment.new
+        end
+
+        if segment_range.cover? region_range.max
+          intersection_end = region_range.max
+        elsif region_range.cover? segment_range.max
+          intersection_end = segment_range.max
+        else
+          return Segment.new
+        end
+
+        segment = Segment.new
+        segment.base = intersection_base
+        segment.data = @data[intersection_base - @base..intersection_end - @base]
+
+        segment
+      end
+
+      def pad_segment!(psize, fill_byte = 0x00)
+        if @base % size != 0
+          padding = size - (@base % size)
+
+          @base -= padding
+          @data = ([ fill_byte ] * padding).pack("C*") + @data
+        end
+
+        if @data.size % size != 0
+          padding = size - (@data.size % size)
+
+          @data += ([ fill_byte ] * padding).pack "C*"
+        end
+      end
+    end
+
+
+    attr_accessor :segments
+
+    def initialize
+      @segments = []
+    end
+
+    def self.load(stream)
+      high_address = 0
+      lines = {}
+
+      stream.each_line do |line|
+        line.rstrip!
+
+        record = Record.parse line
+
+        case record.type
+        when :eof
+          break
+
+        when :extended_address
+          high_address, = record.data.unpack "n"
+
+        when :data
+          lines[(high_address << 16) | record.address] = record.data
+        end
+      end
+
+      segment = nil
+      ihex = self.new
+
+      lines.sort_by { |k1,v1,k2,b2| k1 <=> k2 }.each do |address, data|
+        if segment.nil? || segment.base + segment.size != address
+          segment = Segment.new
+          segment.base = address
+          segment.data = data
+
+          ihex.segments << segment
+        else
+          segment.data += data
+        end
+      end
+
+      ihex
+    end
+
+    def split_segments!(size, fill_byte = 0x00)
+      pad_segments! size, fill_byte
+
+      i = 0
+
+      while i < @segments.length
+        segment = @segments[i]
+        parts = segment.size / size
+
+        for j in 1...parts do
+          new_segment = Segment.new
+          new_segment.base = segment.base + size * j
+          new_segment.data = segment.data[j * size...(j + 1) * size]
+
+          @segments.insert i + j, new_segment
+        end
+
+        segment.data = segment.data[0...size]
+
+        i += parts
+      end
+
+      self
+    end
+
+    def pad_segments!(size, fill_byte = 0x00)
+      @segments.each do |segment|
+        segment.pad_segment! size, fill_byte
+      end
+
+      self
+    end
+  end
+end

data/lib/gdbflasher/mcu/stm32f10xx_hd.rb

@@ -0,0 +1,17 @@
+module GdbFlasher
+  class Stm32f10xxHD < CortexM
+
+    SECTORS = (0...256).map { |i| [ 0x08000000 + 2048 * i, 0x08000000 + 2048 * (i + 1) - 1 ] }
+
+    protected
+
+    def helper_name
+      "stm32f10xx_hd"
+    end
+
+    def erase(sector_index)
+      call_helper :erase, SECTORS[sector_index][0]
+    end
+  end
+
+end

data/lib/gdbflasher/mcu/stm32f10xx_md.rb

@@ -0,0 +1,17 @@
+module GdbFlasher
+  class Stm32f10xxMD < CortexM
+
+    SECTORS = (0...128).map { |i| [ 0x08000000 + 1024 * i, 0x08000000 + 1024 * (i + 1) - 1 ] }
+
+    protected
+
+    def helper_name
+      "stm32f10xx_md"
+    end
+
+    def erase(sector_index)
+      call_helper :erase, SECTORS[sector_index][0]
+    end
+  end
+
+end

data/lib/gdbflasher/mcu/stm32f4xx.rb

@@ -0,0 +1,25 @@
+module GdbFlasher
+  class Stm32f4xx < CortexM
+    SECTORS = [
+      [ 0x08000000, 0x08003FFF ], # Sector 0, 16 KiB
+      [ 0x08004000, 0x08007FFF ], # Sector 1, 16 KiB
+      [ 0x08008000, 0x0800BFFF ], # Sector 2, 16 KiB
+      [ 0x0800C000, 0x0800FFFF ], # Sector 3, 16 KiB
+      [ 0x08010000, 0x0801FFFF ], # Sector 4, 64 KiB
+      [ 0x08020000, 0x0803FFFF ], # Sector 5, 64 KiB
+      [ 0x08040000, 0x0805FFFF ], # Sector 6, 64 KiB
+      [ 0x08060000, 0x0807FFFF ], # Sector 7, 64 KiB
+      [ 0x08080000, 0x0809FFFF ], # Sector 8, 64 KiB
+      [ 0x080A0000, 0x080BFFFF ], # Sector 9, 64 KiB
+      [ 0x080C0000, 0x080DFFFF ], # Sector 10, 64 KiB
+      [ 0x080E0000, 0x080FFFFF ], # Sector 11, 64 KiB
+    ]
+
+    protected
+
+    def helper_name
+      "stm32f4xx"
+    end
+  end
+
+end

data/lib/gdbflasher/mcu/stm32l1xx.rb

@@ -0,0 +1,21 @@
+module GdbFlasher
+  class Stm32l1xx < CortexM
+
+    SECTORS = (0...512).map { |i| [ 0x08000000 + 256 * i, 0x08000000 + 256 * (i + 1) - 1 ] }
+
+    protected
+
+    def helper_name
+      "stm32l1xx"
+    end
+
+    def erase(sector_index)
+      call_helper :erase, SECTORS[sector_index][0]
+    end
+
+    def blank_byte
+      0x00
+    end
+  end
+
+end